Process.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_Process_Process_h
#define CepGen_Process_Process_h
 
#include <cmath>
 
#include "CepGen/Event/Event.h"
#include "CepGen/Physics/Coupling.h"
#include "CepGen/Physics/Kinematics.h"
#include "CepGen/Utils/ProcessVariablesAnalyser.h"
 
namespace cepgen::proc {
  class Process : public NamedModule<Process> {
  public:
    explicit Process(const ParametersList&);
    Process(const Process&);  
    ~Process() override = default;
    Process& operator=(const Process&);  
 
    static ParametersDescription description();
 
    virtual std::unique_ptr<Process> clone() const;  
    virtual double computeWeight() = 0;              
 
    void clear();       
    void clearEvent();  
    void initialise();  
 
    inline const Kinematics& kinematics() const { return kin_; }  
    inline Kinematics& kinematics() { return kin_; }              
    void setKinematics();
 
    // debugging utilities
    double weight(const std::vector<double>&);      
    void dumpPoint(std::ostream* = nullptr) const;  
    void dumpVariables(std::ostream* = nullptr) const;  
 
    inline size_t ndim() const { return mapped_variables_.size(); }  
 
    inline bool hasEvent() const { return static_cast<bool>(event_); }
    const Event& event() const;  
    Event& event();              
    Event* eventPtr();           
 
    const Momentum& pA() const;                            
    inline double mA2() const { return mA2_; }             
    inline double mA() const { return std::sqrt(mA2()); }  
    const Momentum& pB() const;                            
    inline double mB2() const { return mB2_; }             
    inline double mB() const { return std::sqrt(mB2()); }  
    const Momentum& pX() const;                            
    inline double mX2() const { return mX2_; }             
    inline double mX() const { return std::sqrt(mX2()); }  
    const Momentum& pY() const;                            
    inline double mY2() const { return mY2_; }             
    inline double mY() const { return std::sqrt(mY2()); }  
 
    inline double x1() const { return x1_; }  
    inline double t1() const { return t1_; }  
    const Momentum& q1() const;               
    inline double x2() const { return x2_; }  
    inline double t2() const { return t2_; }  
    const Momentum& q2() const;               
 
    Momentum& q1();  
    Momentum& q2();  
 
    inline double wCM() const { return wcm_; }  
 
    Momentum& pA();  
    Momentum& pB();  
    Momentum& pX();  
    Momentum& pY();  
 
    inline double& mX2() { return mX2_; }  
    inline double& mY2() { return mY2_; }  
    inline double& t1() { return t1_; }    
    inline double& x1() { return x1_; }    
    inline double& t2() { return t2_; }    
    inline double& x2() { return x2_; }    
 
    Momentum& pc(size_t);              
    const Momentum& pc(size_t) const;  
 
    inline double s() const { return s_; }                   
    inline double sqrtS() const { return sqs_; }             
    inline double inverseS() const { return inv_s_; }        
    inline double inverseSqrtS() const { return inv_sqs_; }  
 
  protected:
    virtual void addEventContent() = 0;         
    inline virtual void prepareKinematics() {}  
    virtual void fillKinematics() = 0;          
 
    //--- Mandelstam variables
    double shat() const;  
 
    double mp_;   
    double mp2_;  
 
  public:
    enum class Mapping {
      linear = 0,   
      exponential,  
      square,       
      power_law     
    };
    enum class Mapping {…};
    friend std::ostream& operator<<(std::ostream&, const Mapping&);  
    Process& defineVariable(double& out,
                            const Mapping& type,
                            const Limits& lim,
                            const std::string& name,
                            const std::string& description = "");
    double variableValue(size_t i, double x) const;
 
  protected:
    double generateVariables() const;
 
    void setEventContent(const std::unordered_map<Particle::Role, spdgids_t>&);
 
    double alphaEM(double q) const;  
    double alphaS(double q) const;   
 
    inline const std::vector<double>& lastCoordinates() const { return point_coord_; }  
 
  private:
    double s_{-1.};        
    double sqs_{-1.};      
    double inv_s_{-1.};    
    double inv_sqs_{-1.};  
    double wcm_{-1.};      
    double mA2_{-1.};      
    double mB2_{-1.};      
    double mX2_{-1.};      
    double mY2_{-1.};      
    double t1_{-1.};       
    double t2_{-1.};       
    double x1_{0.};        
    double x2_{0.};        
    std::unique_ptr<Coupling> alpha_em_;  
    std::unique_ptr<Coupling> alpha_s_;   
    struct MappingVariable {
      std::string name;         
      std::string description;  
      Limits limits;            
      double& value;            
      Mapping type;             
      size_t index;             
    };
    std::vector<MappingVariable> mapped_variables_;  
    std::vector<double> point_coord_;                
    double base_jacobian_{1.};  
    Kinematics kin_{ParametersList()};  
    std::unique_ptr<Event> event_;      
    friend class utils::ProcessVariablesAnalyser;
  };
  using ProcessPtr = std::unique_ptr<Process>;  
}  // namespace cepgen::proc
 
#endif
    virtual void fillKinematics() = 0;           {…}
    virtual void addEventContent() = 0;          {…}
    inline double inverseSqrtS() const { return inv_sqs_; }   {…}
    inline double inverseS() const { return inv_s_; }         {…}
    inline double sqrtS() const { return sqs_; }              {…}
    Momentum& pc(size_t);               {…}
    inline double& x2() { return x2_; }     {…}
    inline double& t2() { return t2_; }     {…}
    inline double& x1() { return x1_; }     {…}
    inline double& t1() { return t1_; }     {…}
    inline double& mY2() { return mY2_; }   {…}
    Momentum& pA();   {…}
    const Momentum& q2() const;                {…}
    inline double t2() const { return t2_; }   {…}
    const Momentum& q1() const;                {…}
    inline double t1() const { return t1_; }   {…}
    inline double x1() const { return x1_; }   {…}
    inline double mY() const { return std::sqrt(mY2()); }   {…}
    const Momentum& pY() const;                             {…}
    inline double mX() const { return std::sqrt(mX2()); }   {…}
    const Momentum& pX() const;                             {…}
    inline double mB() const { return std::sqrt(mB2()); }   {…}
    const Momentum& pB() const;                             {…}
    inline double mA() const { return std::sqrt(mA2()); }   {…}
    void setKinematics(); {…}
    inline Kinematics& kinematics() { return kin_; }               {…}
  class Process : public NamedModule<Process> {…};