Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-12-16 10:32:15 

0001 #ifndef PHASIC_Main_Phase_Space_Handler_H
0002 #define PHASIC_Main_Phase_Space_Handler_H
0003 
0004 #include "PHASIC++/Main/Process_Integrator.H"
0005 #include "PHASIC++/Main/Phase_Space_Point.H"
0006 #include "PHASIC++/Main/Phase_Space_Enhance.H"
0007 #include "PHASIC++/Main/Phase_Space_Variation_Weights.H"
0008 
0009 #include "PHASIC++/Selectors/Cut_Data.H"
0010 #include "ATOOLS/Math/Algebra_Interpreter.H"
0011 #include "ATOOLS/Org/Info_Key.H"
0012 #include "ATOOLS/Org/CXXFLAGS.H"
0013 #include "ATOOLS/Phys/Weights.H"
0014 #include <list>
0015 
0016 namespace ATOOLS { 
0017   class Blob_Data_Base; 
0018   class Poincare;
0019   class Mass_Selector;
0020   struct Weight_Info;
0021 }
0022 
0023 namespace BEAM {
0024   class Beam_Spectra_Handler;
0025 }
0026 
0027 namespace PDF {
0028   class ISR_Handler;
0029 }
0030 
0031 namespace YFS {
0032   class YFS_Handler;
0033 }
0034 
0035 namespace PHASIC {
0036   class Multi_Channel;
0037   class Beam_Channels;
0038   class ISR_Channels;
0039   class Subprocess_Info;
0040   class Process_Info;
0041 
0042   class Phase_Space_Integrator;
0043   class Process_Base;
0044 
0045   class Phase_Space_Handler {
0046   private: 
0047     BEAM::Beam_Spectra_Handler * p_beamhandler;
0048     PDF::ISR_Handler           * p_isrhandler;
0049     YFS::YFS_Handler           * p_yfshandler;
0050     std::string                  m_name;
0051     int                          m_nin, m_nout, m_nvec;
0052     ATOOLS::Flavour_Vector       p_flavours;
0053     ATOOLS::Vec4D_Vector         p_lab;
0054 
0055     Process_Integrator          * p_process, *p_active;
0056     Phase_Space_Integrator      * p_integrator;
0057     Phase_Space_Point             m_pspoint;
0058     Phase_Space_Enhance           m_psenhance;
0059 
0060     ATOOLS::Weights_Map           m_wgtmap;
0061     static ATOOLS::Integration_Info * p_info;
0062 
0063     double m_enhanceweight, m_ISsymmetryfactor, m_psweight;
0064 
0065     psmode::code m_cmode;
0066     double    m_thkill, m_error, m_abserror;
0067     bool      m_initialized, m_sintegrator, m_fin_opt, m_printpspoint;
0068     long int  m_killedpoints;
0069     std::vector<std::vector<double> > m_stats;
0070 
0071     std::string m_enhanceObs, m_enhanceFunc;
0072 
0073     void RegisterDefaults() const;
0074     void InitParameters(const double & error);
0075 
0076     void ManageWeights(const double & factor);
0077     bool CheckStability();
0078 
0079     void PrintIntermediate();
0080     void CheckSinglePoint();
0081     static void TestPoint(ATOOLS::Vec4D *const p,
0082               ATOOLS::Vec4D_Vector cp,ATOOLS::Flavour_Vector fl,
0083               const Subprocess_Info *info,size_t &n,
0084                           const ATOOLS::Mass_Selector* ms);
0085 
0086   public:
0087 
0088     //constructor
0089     Phase_Space_Handler(Process_Integrator *,double error,
0090                         const std::string eobs,const std::string efunc);
0091 
0092     //destructor
0093     ~Phase_Space_Handler();
0094 
0095     bool CreateIntegrators();
0096     inline void InitCuts() { m_pspoint.InitCuts(p_process); }
0097 
0098     double Integrate();
0099     ATOOLS::Weight_Info *OneEvent(
0100         Process_Base *const proc,
0101         ATOOLS::Variations_Mode varmode=ATOOLS::Variations_Mode::all,
0102         const int mode=0);
0103     inline ATOOLS::Weights_Map Differential(ATOOLS::Variations_Mode varmode) {
0104       return Differential(p_process, varmode);
0105     }
0106     ATOOLS::Weights_Map Differential(Process_Integrator *const process,
0107                                      ATOOLS::Variations_Mode,
0108                                      const psmode::code mode=psmode::normal_call);
0109 
0110     inline ATOOLS::Weights_Map CalculateME(ATOOLS::Variations_Mode varmode)  {
0111       return p_active->Process()->Differential(p_lab, varmode);
0112     }
0113     inline double CalculatePS()  { return m_pspoint.CalculateWeight(); }
0114     inline double Weight(ATOOLS::Vec4D_Vector& moms) {
0115       m_pspoint.SetMomenta(moms);
0116       return m_pspoint.CalculateWeight();
0117     }
0118 
0119     void   AddPoint(const double xs);
0120 
0121     static void TestPoint(ATOOLS::Vec4D *const p,const Process_Info *info,
0122                           const ATOOLS::Mass_Selector* ms,const int mode=0);
0123     static void TestPoint(ATOOLS::Vec4D *const p,
0124               const size_t &nin,const size_t &nout,
0125               const ATOOLS::Flavour_Vector &flavs,
0126               const ATOOLS::Mass_Selector* ms);
0127 
0128 
0129     inline static ATOOLS::Integration_Info* GetInfo() {
0130       if (p_info==NULL) p_info = new ATOOLS::Integration_Info();
0131       return p_info;
0132     }
0133     inline static void DeleteInfo() {
0134       if (p_info) { delete p_info; p_info=NULL; }
0135     }
0136 
0137     void   WriteOut(const std::string &path);
0138     bool   ReadIn(const std::string &path,const size_t exclude=0);
0139     bool   YFSEvent();
0140 
0141     inline void MPISync() {
0142       m_pspoint.MPISync();
0143       p_process->MPISync();
0144     }
0145     inline void Optimize() {
0146       m_pspoint.Optimize(m_error);
0147       p_process->ResetMax(2);
0148       m_psenhance.Optimize();
0149     }
0150     inline void EndOptimize() {
0151       m_pspoint.EndOptimize(m_error);
0152     }
0153     inline void SetEnhanceWeight(const double& enhance)
0154     {
0155       m_enhanceweight = enhance;
0156       m_psenhance.SetFactor(enhance);
0157     }
0158     inline void SetOSMass(const double &osmass) { m_pspoint.SetOSMass(osmass); }
0159     inline void SetError(const double error)    { m_error=error; }
0160     inline void SetAbsError(const double error) { m_abserror=error; }
0161 
0162     inline void SetBeamIntegrator(Multi_Channel * channels) { m_pspoint.SetBeamIntegrator(channels); }
0163     inline void SetISRIntegrator(Multi_Channel * channels)  { m_pspoint.SetISRIntegrator(channels); }
0164     inline void SetFSRIntegrator(Multi_Channel * channels)  { m_pspoint.SetFSRIntegrator(channels); }
0165 
0166     inline BEAM::Beam_Spectra_Handler   * GetBeamSpectra() const { return p_beamhandler; }
0167     inline PDF::ISR_Handler              * GetISRHandler() const { return p_isrhandler; }
0168     inline YFS::YFS_Handler              * GetYFSHandler() const { return p_yfshandler; }
0169     inline Phase_Space_Integrator           * Integrator() const { return p_integrator; }
0170     inline const std::vector<std::vector<double> > Stats() const { return m_stats; }
0171     inline ATOOLS::Vec4D_Vector &                Momenta()       { return p_lab; }
0172     inline ATOOLS::Flavour_Vector &                Flavs()       { return p_flavours; }
0173     inline Cut_Data                               * Cuts()       { return m_pspoint.Cuts(); }
0174     inline Process_Integrator *                  Process() const { return p_process; }
0175     inline Process_Integrator *            Active()  const { return p_active;  }
0176     inline const double &                 PSWeight() const { return m_psweight; }
0177     inline const double &            EnhanceWeight() const { return m_enhanceweight;  }
0178     inline const double &                    Error() const { return m_error; }
0179     inline const double &                 AbsError() const { return m_abserror; }
0180     inline Multi_Channel *          BeamIntegrator() const { return m_pspoint.BeamIntegrator(); }
0181     inline Multi_Channel *           ISRIntegrator() const { return m_pspoint.ISRIntegrator(); }
0182     inline Multi_Channel *           FSRIntegrator() const { return m_pspoint.FSRIntegrator(); }
0183     inline void AddStats(const std::vector<double> &stats) {
0184       std::vector<double> nstats(1,m_stats.size()+1);
0185       nstats.insert(nstats.end(),stats.begin(),stats.end());
0186       m_stats.push_back(nstats); 
0187     }
0188   };// end of class Phase_Space_Handler
0189 
0190   /*!
0191     \class Phase_Space_Handler
0192     \brief the main steering class for integration and event generation
0193   */
0194 
0195   /*!
0196     \var ATOOLS::Integration_Info *Phase_Space_Handler::p_info
0197 
0198     Phase_Space_Handler distributes information on the various 
0199     integration variables and weights through an instance of Integration_Info.
0200     Each Single_Channel is able to gain access to the variables via the assignment 
0201     of an Info_Key during its initialization.
0202   */
0203 
0204 }//end of namespace PHASIC
0205 
0206 #endif
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!