RunParameters.h

Go to the documentation of this file.

/*
 *  CepGen: a central exclusive processes event generator
 *  Copyright (C) 2013-2024  Laurent Forthomme
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef CepGen_Core_RunParameters_h
#define CepGen_Core_RunParameters_h
 
#include "CepGen/Physics/Kinematics.h"
 
namespace cepgen {
  class EventExporter;
  class EventModifier;
  class ParametersList;
  namespace proc {
    class Process;
  }
  namespace utils {
    class Functional;
    class TimeKeeper;
  }  // namespace utils
  enum class IntegratorType;
  typedef std::vector<std::unique_ptr<EventModifier> > EventModifiersSequence;  
  typedef std::vector<std::unique_ptr<EventExporter> > EventExportersSequence;  
  typedef std::vector<std::unique_ptr<utils::Functional> > TamingFunctionsSequence;  
 
  class RunParameters : public SteeredObject<RunParameters> {
  public:
    RunParameters();
    RunParameters(RunParameters&);  
    RunParameters(const RunParameters&);  
    ~RunParameters();                     // required for unique_ptr initialisation!
 
    static ParametersDescription description();
 
    RunParameters& operator=(RunParameters);  
 
    friend std::ostream& operator<<(std::ostream&, const RunParameters&);  
 
    void setTimeKeeper(utils::TimeKeeper*);                             
    utils::TimeKeeper* timeKeeper() { return tmr_.get(); }              
    const utils::TimeKeeper* timeKeeper() const { return tmr_.get(); }  
 
    void initialiseModules();  
 
    ParametersList& integrator() { return integrator_; }              
    const ParametersList& integrator() const { return integrator_; }  
 
    //----- process to compute
 
    bool hasProcess() const { return !(!process_); }  
    proc::Process& process();              
    const proc::Process& process() const;  
    std::string processName() const;       
    void clearProcess();                   
    void setProcess(std::unique_ptr<proc::Process>);  
    void setProcess(proc::Process*);                  
 
    //----- events kinematics
 
    const Kinematics& kinematics() const;
 
    //----- events generation
 
    class Generation : public SteeredObject<Generation> {
    public:
      explicit Generation(const ParametersList& = ParametersList());
 
      static ParametersDescription description();
 
      void setTargetLuminosity(double lumi_invpb) { target_lumi_ = lumi_invpb; }  
      double targetLuminosity() const { return target_lumi_; }  
      void setMaxGen(size_t max_gen) { max_gen_ = max_gen; }    
      size_t maxGen() const { return max_gen_; }                
      bool enabled() const { return max_gen_ > 0; }             
      void setPrintEvery(size_t print_every) { gen_print_every_ = print_every; }  
      size_t printEvery() const { return gen_print_every_; }  
      void setSymmetrise(bool sym) { symmetrise_ = sym; }   
      bool symmetrise() const { return symmetrise_; }       
      void setNumThreads(size_t nt) { num_threads_ = nt; }  
      size_t numThreads() const { return num_threads_; }    
      void setNumPoints(size_t np) { num_points_ = np; }  
      size_t numPoints() const { return num_points_; }    
 
    private:
      int max_gen_, gen_print_every_;
      double target_lumi_;
      bool symmetrise_;
      int num_threads_, num_points_;
    };
    Generation& generation() { return generation_; }              
    const Generation& generation() const { return generation_; }  
 
    //----- event modification (e.g. hadronisation, decay) algorithm
 
    EventModifier& eventModifier(size_t);                                        
    EventModifiersSequence& eventModifiersSequence() { return evt_modifiers_; }  
    const EventModifiersSequence& eventModifiersSequence() const { return evt_modifiers_; }
    void clearEventModifiersSequence();                
    void addModifier(std::unique_ptr<EventModifier>);  
    void addModifier(EventModifier*);                  
 
    //----- event output algorithms
 
    EventExporter& eventExporter(size_t);                                                    
    EventExportersSequence& eventExportersSequence() { return evt_exporters_; }              
    const EventExportersSequence& eventExportersSequence() const { return evt_exporters_; }  
    void clearEventExportersSequence();                     
    void addEventExporter(std::unique_ptr<EventExporter>);  
    void addEventExporter(EventExporter*);                  
 
    //----- taming functions
 
    const TamingFunctionsSequence& tamingFunctions() const { return taming_functions_; }
    void addTamingFunction(std::unique_ptr<utils::Functional>);  
 
    //----- run operations
 
    void prepareRun();  
 
    void addGenerationTime(double gen_time);
    inline double totalGenerationTime() const { return total_gen_time_; }  
    inline unsigned int numGeneratedEvents() const { return num_gen_events_; }  
 
  private:
    std::unique_ptr<proc::Process> process_;    
    EventModifiersSequence evt_modifiers_;      
    EventExportersSequence evt_exporters_;      
    TamingFunctionsSequence taming_functions_;  
    double total_gen_time_{0.};                 
    unsigned long num_gen_events_{0ul};         
    ParametersList integrator_;                 
    Generation generation_;                     
    std::unique_ptr<utils::TimeKeeper> tmr_;    
  };
}  // namespace cepgen
 
#endif