Process.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_Process_Process_h
#define CepGen_Process_Process_h
 
#include "CepGen/Event/Event.h"
#include "CepGen/Physics/Coupling.h"
#include "CepGen/Physics/Kinematics.h"
#include "CepGen/Utils/ProcessVariablesAnalyser.h"
#include "CepGen/Utils/RandomGenerator.h"
 
namespace cepgen {
  namespace proc {
    class Process : public NamedModule<Process> {
    public:
      explicit Process(const ParametersList&);
      Process(const Process&);  
      virtual ~Process() = 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();  
 
      const Kinematics& kinematics() const { return kin_; }  
      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(); }
 
      bool hasEvent() const { return (bool)event_; }  
      const Event& event() const;                     
      Event& event();                                 
      Event* eventPtr();                              
 
      const Momentum& pA() const;                     
      double mA2() const { return mA2_; }             
      double mA() const { return std::sqrt(mA2()); }  
      const Momentum& pB() const;                     
      double mB2() const { return mB2_; }             
      double mB() const { return std::sqrt(mB2()); }  
      const Momentum& pX() const;                     
      double mX2() const { return mX2_; }             
      double mX() const { return std::sqrt(mX2()); }  
      const Momentum& pY() const;                     
      double mY2() const { return mY2_; }             
      double mY() const { return std::sqrt(mY2()); }  
 
      double x1() const { return x1_; }  
      double t1() const { return t1_; }  
      const Momentum& q1() const;        
      double x2() const { return x2_; }  
      double t2() const { return t2_; }  
      const Momentum& q2() const;        
 
      Momentum& q1();  
      Momentum& q2();  
 
      double wCM() const { return wcm_; }  
 
      Momentum& pA();  
      Momentum& pB();  
      Momentum& pX();  
      Momentum& pY();  
 
      double& mX2() { return mX2_; }  
      double& mY2() { return mY2_; }  
      double& t1() { return t1_; }    
      double& x1() { return x1_; }    
      double& t2() { return t2_; }    
      double& x2() { return x2_; }    
 
      Momentum& pc(size_t);              
      const Momentum& pc(size_t) const;  
 
      double s() const { return s_; }                   
      double sqrtS() const { return sqs_; }             
      double inverseSqrtS() const { return inv_sqs_; }  
 
      utils::RandomGenerator& randomGenerator() const;  
 
    protected:
      virtual void addEventContent() = 0;  
      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     
      };
      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;   
 
      std::unique_ptr<utils::RandomGenerator> rnd_gen_;  
 
      inline const std::vector<double>& lastCoordinates() const { return point_coord_; }  
 
    private:
      double s_{-1.};        
      double sqs_{-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> alphaem_;  
      std::unique_ptr<Coupling> alphas_;   
      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;
    };
    typedef std::unique_ptr<Process> ProcessPtr;
  }  // namespace proc
}  // namespace cepgen
 
#endif