RunParameters.h

Go to the documentation of this file.

/*
 *  CepGen: a central exclusive processes event generator
 *  Copyright (C) 2013-2025  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;
  enum class IntegratorType;
}  // namespace cepgen
namespace cepgen::proc {
  class Process;
}  // namespace cepgen::proc
namespace cepgen::utils {
  class Functional;
  class TimeKeeper;
}  // namespace cepgen::utils
namespace cepgen::utils {…}
 
namespace cepgen {
  using EventModifiersSequence = std::vector<std::unique_ptr<EventModifier> >;  
  using EventExportersSequence = std::vector<std::unique_ptr<EventExporter> >;  
  using TamingFunctionsSequence = std::vector<std::unique_ptr<utils::Functional> >;  
}  // namespace cepgen
 
namespace cepgen {
  class RunParameters : public SteeredObject<RunParameters> {
  public:
    RunParameters();
    RunParameters(RunParameters&);  
    RunParameters(const RunParameters&);  
    ~RunParameters() override;            // 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 timer_.get(); }              
    const utils::TimeKeeper* timeKeeper() const { return timer_.get(); }  
 
    void initialiseModules();  
 
    inline ParametersList& integrator() { return integrator_; }              
    inline const ParametersList& integrator() const { return integrator_; }  
 
    //----- process to compute
 
    inline 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();
 
      inline void setTargetLuminosity(double lumi) { target_lumi_ = lumi; }  
      inline double targetLuminosity() const { return target_lumi_; }        
      inline void setMaxGen(size_t max_gen) { max_gen_ = max_gen; }  
      inline size_t maxGen() const { return max_gen_; }              
      inline bool enabled() const { return max_gen_ > 0; }           
      inline void setPrintEvery(size_t every) { gen_print_every_ = every; }  
      inline size_t printEvery() const { return gen_print_every_; }          
      inline void setSymmetrise(bool sym) { symmetrise_ = sym; }   
      inline bool symmetrise() const { return symmetrise_; }       
      inline void setNumThreads(size_t nt) { num_threads_ = nt; }  
      inline size_t numThreads() const { return num_threads_; }    
      inline void setNumPoints(size_t np) { num_points_ = np; }    
      inline size_t numPoints() const { return num_points_; }  
 
    private:
      int max_gen_;
      int gen_print_every_;
      double target_lumi_;
      bool symmetrise_;
      int num_threads_;
      int num_points_;
    };
    inline Generation& generation() { return generation_; }              
    inline const Generation& generation() const { return generation_; }  
 
    //----- event modification (e.g. hadronisation, decay) algorithm
 
    EventModifier& eventModifier(size_t) const;  
    inline EventModifiersSequence& eventModifiersSequence() { return evt_modifiers_; }
    inline 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) const;  
    inline EventExportersSequence& eventExportersSequence() { return evt_exporters_; }
    inline const EventExportersSequence& eventExportersSequence() const { return evt_exporters_; }
    void clearEventExportersSequence();                     
    void addEventExporter(std::unique_ptr<EventExporter>);  
    void addEventExporter(EventExporter*);                  
 
    //----- taming functions
 
    inline const TamingFunctionsSequence& tamingFunctions() const { return taming_functions_; }
    void addTamingFunction(std::unique_ptr<utils::Functional>);  
 
    //----- run operations
 
    void prepareRun();  
 
    void addGenerationTime(double generation_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> timer_;  
  };
}  // namespace cepgen
 
#endif
    inline unsigned int numGeneratedEvents() const { return num_gen_events_; }   {…}
    EventModifier& eventModifier(size_t) const;   {…}
    inline const Generation& generation() const { return generation_; }   {…}
      inline size_t numPoints() const { return num_points_; }   {…}
      inline void setNumPoints(size_t np) { num_points_ = np; }     {…}
      inline size_t numThreads() const { return num_threads_; }     {…}
      inline void setNumThreads(size_t nt) { num_threads_ = nt; }   {…}
      inline bool symmetrise() const { return symmetrise_; }        {…}
      inline void setSymmetrise(bool sym) { symmetrise_ = sym; }    {…}
      inline size_t printEvery() const { return gen_print_every_; }           {…}
      inline void setPrintEvery(size_t every) { gen_print_every_ = every; }   {…}
      inline bool enabled() const { return max_gen_ > 0; }            {…}
      inline size_t maxGen() const { return max_gen_; }               {…}
      inline void setMaxGen(size_t max_gen) { max_gen_ = max_gen; }   {…}
      inline double targetLuminosity() const { return target_lumi_; }         {…}
    class Generation : public SteeredObject<Generation> {…};
    proc::Process& process();               {…}
    inline bool hasProcess() const { return !!process_; }   {…}
    inline const ParametersList& integrator() const { return integrator_; }   {…}
    void initialiseModules();   {…}
    const utils::TimeKeeper* timeKeeper() const { return timer_.get(); }   {…}
  class RunParameters : public SteeredObject<RunParameters> {…};