GenCrossSection.h

// -*- C++ -*-
//
// This file is part of HepMC
// Copyright (C) 2014-2023 The HepMC collaboration (see AUTHORS for details)
//
#ifndef HEPMC3_CROSS_SECTION_H
#define HEPMC3_CROSS_SECTION_H
#include <iostream>
#include <algorithm>
#include "HepMC3/Attribute.h"
 
namespace HepMC3 {
using namespace std;
 
class GenCrossSection : public Attribute {
 
//
// Fields
//
private:
 
    long accepted_events;       
    long attempted_events;      
 
    std::vector<double> cross_sections;       
    std::vector<double> cross_section_errors; 
//
// Functions
//
public:
    bool from_string(const std::string &att)  override;

    bool to_string(std::string &att) const override;

    void set_cross_section(const double& xs, const double& xs_err,const long& n_acc = -1, const long& n_att = -1);


    void set_cross_section(const std::vector<double>& xs, const std::vector<double>& xs_err,const long& n_acc = -1, const long& n_att = -1);

    const std::vector<double>& xsecs() const { return cross_sections; }

    const std::vector<double>& xsec_errs() const { return cross_section_errors; }
 

    void set_accepted_events(const long& n_acc ) {
        accepted_events=n_acc;
    }

    void set_attempted_events(const long& n_att ) {
        attempted_events=n_att;
    }

    long get_accepted_events() const {
        return accepted_events;
    }

    long get_attempted_events() const {
        return  attempted_events;
    }

    void set_xsec(const std::string& wName,const double& xs) {
        int pos = windx(wName);
        if ( pos < 0 ) throw std::runtime_error("GenCrossSection::set_xsec(const std::string&,const double&): no weight with given name in this run");
        set_xsec(pos, xs);
    }

    void set_xsec(const unsigned long& index, const double& xs) {
        if ( index >= cross_sections.size() ) {throw std::runtime_error("GenCrossSection::set_xsec(const unsigned long&): index outside of range");}
        cross_sections[index] = xs;
    }

    void set_xsec_err(const std::string& wName, const double& xs_err) {
        int pos = windx(wName);
        if ( pos < 0 ) throw std::runtime_error("GenCrossSection::set_xsec_err(const std::string&,const double&): no weight with given name in this run");
        set_xsec_err(pos, xs_err);
    }

    void set_xsec_err(const unsigned long& index, const double& xs_err) {
        if ( index >= cross_section_errors.size() ) {throw std::runtime_error("GenCrossSection::set_xsec_err(const unsigned long&): index outside of range");}
        cross_section_errors[index] = xs_err;
    }

    double xsec(const std::string& wName) const {
        int pos = windx(wName);
        if ( pos < 0 ) throw std::runtime_error("GenCrossSection::xsec(const std::string&): no weight with given name in this run");
        return xsec(pos);
    }

    double xsec(const unsigned long& index = 0) const {
        if ( index < cross_sections.size() ) { return cross_sections.at(index); }
        else  { throw std::runtime_error("GenCrossSection::xsec(const unsigned long&): index outside of range");}
        return 0.0;
    }

    double xsec_err(const std::string& wName) const {
        int pos = windx(wName);
        if ( pos < 0 ) throw std::runtime_error("GenCrossSection::xsec_err(const std::string&): no weight with given name in this run");
        return xsec_err(pos);
    }

    double xsec_err(const unsigned long& index = 0) const {
        if ( index < cross_section_errors.size() ) {return cross_section_errors.at(index);}
        else  { throw std::runtime_error("GenCrossSection::xsec_err(const unsigned long&): index outside of range");}
        return 0.0;
    }
 
    bool operator==( const GenCrossSection& ) const; 
    bool operator!=( const GenCrossSection& ) const; 
    bool is_valid()                           const; 
 
private:

    int windx(const std::string& wName) const;
 
};
 
} // namespace HepMC3
 
#endif