Generator.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.
 */
 
#ifndef CepGen_Generator_h
#define CepGen_Generator_h
 
#include <functional>
#include <memory>
 
#include "CepGen/Utils/Value.h"
 
namespace cepgen {
  class Event;
  class Integrator;
  class GeneratorWorker;
  class RunParameters;
  namespace proc {
    class Process;
  }
 
  static std::vector<std::string> loaded_libraries;   
  static std::vector<std::string> invalid_libraries;  
  static std::vector<std::string> search_paths;       
  bool callPath(const std::string&, bool (*callback)(const std::string&));
  bool loadLibrary(const std::string&, bool match = false);  
  void initialise(bool safe_mode = false);
  void printHeader();  
 
  class Generator {
  public:
    explicit Generator(bool safe_mode = false);
    explicit Generator(RunParameters*);  
    ~Generator();
 
    void parseRunParameters(const std::string&);  
    const RunParameters& runParameters() const;   
    RunParameters& runParameters();               
    void setRunParameters(std::unique_ptr<RunParameters>&);  
 
    void setIntegrator(std::unique_ptr<Integrator>);  
    void integrate();                                 
 
    Value computeXsection();  
    [[deprecated("Please use the parameters-less version")]] void computeXsection(double& cross_section, double& err);
    double crossSection() const { return xsect_; }                     
    double crossSectionError() const { return xsect_.uncertainty(); }  
 
    void generate(size_t num_events, const std::function<void(const Event&, size_t)>&);            
    void generate(size_t num_events, const std::function<void(const proc::Process&)>& = nullptr);  
    const Event& next();  
 
    double computePoint(const std::vector<double>& x);
 
  private:
    void initialise();       
    void clearRun();         
    void resetIntegrator();  
 
    std::unique_ptr<RunParameters> parameters_;  
    std::unique_ptr<GeneratorWorker> worker_;    
    std::unique_ptr<Integrator> integrator_;     
    bool initialised_{false};                    
    Value xsect_{-1., -1.};                      
  };
}  // namespace cepgen
 
#endif