Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-04-19 09:10:11 

0001 #ifndef PHASIC_Process_Process_Base_H
0002 #define PHASIC_Process_Process_Base_H
0003 
0004 #include "PHASIC++/Process/Process_Info.H"
0005 #include "PHASIC++/Selectors/Selector.H"
0006 #include "PHASIC++/Selectors/Cut_Data.H"
0007 #include "PHASIC++/Scales/Scale_Setter_Base.H"
0008 #include "PHASIC++/Scales/KFactor_Setter_Base.H"
0009 #include "ATOOLS/Phys/NLO_Subevt.H"
0010 #include "ATOOLS/Phys/Weight_Info.H"
0011 #include "ATOOLS/Org/CXXFLAGS.H"
0012 
0013 namespace ATOOLS { 
0014   class Cluster_Leg;
0015   class Cluster_Amplitude; 
0016   class Histogram;
0017   struct Decay_Info;
0018   typedef std::vector<Decay_Info* > DecayInfo_Vector;
0019   struct Weight_Info;
0020 }
0021 
0022 namespace BEAM { class Beam_Spectra_Handler; }
0023 
0024 namespace PDF { 
0025   class ISR_Handler;
0026   class Shower_Base;
0027   class NLOMC_Base;
0028 }
0029 
0030 namespace METOOLS { class Spin_Amplitudes; }
0031 
0032 namespace YFS { class YFS_Handler; }
0033 
0034 namespace PHASIC {
0035 
0036   typedef std::map<int,int> FMMap;
0037 
0038   class Process_Integrator;
0039   class Phase_Space_Handler;
0040   class Phase_Space_Integrator;
0041   class Combined_Selector;
0042   class ME_Generator_Base;
0043 
0044   class Process_Base;
0045   class BBar_Multi_Channel;
0046 
0047   typedef std::vector<PHASIC::Process_Base*> Process_Vector;
0048 
0049   typedef std::map<std::string,Process_Base*> StringProcess_Map;
0050 
0051   typedef std::map<ATOOLS::nlo_type::code,StringProcess_Map*>
0052   NLOTypeStringProcessMap_Map;
0053 
0054   struct Color_Matrix {
0055     std::vector<std::vector<int> > m_perms;
0056     std::vector<std::vector<double> > m_colfacs;
0057   };// end of struct Color_Matrix
0058 
0059   class Process_Base {
0060   protected:
0061 
0062     Process_Base       *p_parent, *p_selected, *p_mapproc, *p_sproc, *p_caller;
0063     Process_Integrator *p_int;
0064     Combined_Selector  *p_selector;
0065     Cut_Data           *p_cuts;
0066     ME_Generator_Base  *p_gen;
0067 
0068     PDF::Shower_Base   *p_shower;
0069     PDF::NLOMC_Base    *p_nlomc;
0070 
0071     BBar_Multi_Channel *p_mc;
0072 
0073     Scale_Setter_Base   *p_scale;
0074     KFactor_Setter_Base *p_kfactor;
0075 
0076     size_t      m_nin, m_nout, m_mcmode, m_cmode;
0077     std::string m_name, m_resname;
0078 
0079     std::vector<double> m_maxcpl, m_mincpl;
0080 
0081     ATOOLS::Flavour_Vector m_flavs;
0082     Process_Info           m_pinfo;
0083     ATOOLS::DecayInfo_Vector m_decins;
0084 
0085     ATOOLS::ME_Weight_Info m_mewgtinfo;
0086 
0087     ATOOLS::Weights_Map m_last, m_lastb;
0088     double m_symfac, m_issymfac;
0089     bool   m_lookup, m_use_biweight;
0090 
0091     bool   m_hasinternalscale;
0092     double m_internalscale;
0093     MODEL::Coupling_Map m_cpls;
0094 
0095     NLOTypeStringProcessMap_Map *p_apmap;
0096 
0097     Color_Matrix m_cols;
0098 
0099     static int s_usefmm;
0100 
0101     static void SortFlavours(Subprocess_Info &info,FMMap *const fmm=0);
0102     static void SortFlavours(std::vector<ATOOLS::Cluster_Leg*> &legs,
0103                  FMMap *const fmm=0);
0104 
0105   public:
0106 
0107     Process_Base();
0108     virtual ~Process_Base();
0109 
0110     // member functions
0111     Process_Base *Parent();
0112     Process_Base *Selected();
0113     size_t SelectedIndex();
0114 
0115     bool SetSelected(Process_Base *const proc);
0116     size_t SynchronizeSelectedIndex(Process_Base &);
0117 
0118     double LastPlus();
0119     double LastMinus();
0120 
0121     void SetSProc(Process_Base *sproc);
0122     void SetBBarMC(BBar_Multi_Channel *mc);
0123 
0124     int NaiveMapping(Process_Base *proc) const;
0125 
0126     std::string ShellName(std::string name="") const;
0127 
0128     Color_Matrix ColorMatrix(const ATOOLS::Flavour_Vector &fls) const;
0129 
0130     virtual void ConstructColorMatrix();
0131     virtual void FillProcessMap(NLOTypeStringProcessMap_Map *apmap);
0132 
0133     virtual void SetScale(const Scale_Setter_Arguments &args) = 0;
0134     virtual void SetKFactor(const KFactor_Setter_Arguments &args) = 0;
0135     virtual void InitializeTheReweighting(ATOOLS::Variations_Mode) = 0;
0136 
0137     virtual void SetFixedScale(const std::vector<double> &s);
0138     virtual void SetSelectorOn(const bool on);
0139     virtual void SetUseBIWeight(bool on);
0140 
0141     virtual size_t SetMCMode(const size_t mcmode);
0142     virtual size_t SetClusterMode(const size_t mcmode);
0143 
0144     virtual size_t Size() const = 0;
0145     virtual Process_Base *operator[](const size_t &i) = 0;
0146 
0147     virtual ATOOLS::Weight_Info *OneEvent(
0148         const int wmode,
0149         ATOOLS::Variations_Mode varmode=ATOOLS::Variations_Mode::all,
0150         const int mode=0) = 0;
0151 
0152     /*!
0153      * Calculate the nominal differential
0154      *
0155      * Use the Variations_Mode argument to steer if only the nominal, or the
0156      * nominal plus all on-the-fly variations are calculated and returned.
0157      *
0158      * The nominal differential can be retrieved using Last, the Born part of
0159      * it via LastB, and the full event weights (i.e. the return value) via
0160      * EventWeights.  The ME weight information can be retrieved using
0161      * GetMEwgtinfo.
0162      *
0163      * Subclasses implementing this virtual function must make sure to set
0164      * update the corresponding member variables.
0165      */
0166     virtual ATOOLS::Weights_Map Differential(const ATOOLS::Vec4D_Vector&,
0167                                              ATOOLS::Variations_Mode) = 0;
0168 
0169     virtual ATOOLS::Weights_Map Differential(const ATOOLS::Cluster_Amplitude&,
0170                                              ATOOLS::Variations_Mode varmode=ATOOLS::Variations_Mode::nominal_only,
0171                                              int mode=0);
0172 
0173     virtual bool GeneratePoint();
0174     virtual void AddPoint(const double &value);
0175     virtual bool ReadIn(const std::string &pid);
0176     virtual void WriteOut(const std::string &pid);
0177     virtual void EndOptimize();
0178     virtual void MPICollect(std::vector<double> &sv,size_t &i);
0179     virtual void MPIReturn(std::vector<double> &sv,size_t &i);
0180     virtual void MPISync(const int mode=0);
0181 
0182     virtual bool IsGroup() const;
0183 
0184     virtual bool CalculateTotalXSec(const std::string &resultpath,
0185                     const bool create=false) = 0;
0186     virtual void SetLookUp(const bool lookup) = 0;
0187 
0188     virtual int  PerformTests();
0189     virtual bool InitScale();
0190     virtual void Init(const Process_Info &pi,
0191               BEAM::Beam_Spectra_Handler *const beamhandler,
0192               PDF::ISR_Handler *const isrhandler,
0193               YFS::YFS_Handler *const yfshandler,const int mode=0);
0194 
0195     virtual bool FillIntegrator(Phase_Space_Handler *const psh);
0196     virtual bool InitIntegrator(Phase_Space_Handler *const psh);
0197     virtual void UpdateIntegrator(Phase_Space_Handler *const psh);
0198     virtual bool FillResonances(ATOOLS::Flavour_Vector & flavs) { return false; }
0199 
0200     virtual void SetGenerator(ME_Generator_Base *const gen);
0201     virtual void SetShower(PDF::Shower_Base *const ps);
0202     virtual void SetNLOMC(PDF::NLOMC_Base *const mc);
0203     const ATOOLS::Weights_Map& WeightsMap() const { return m_last; }
0204     virtual void SetSelector(const Selector_Key &key);
0205     virtual void SetCaller(Process_Base *const proc);
0206 
0207     virtual void InitCuts(Cut_Data *const cuts);
0208     virtual void BuildCuts(Cut_Data *const cuts);
0209 
0210     virtual bool Trigger(const ATOOLS::Vec4D_Vector &p);
0211 
0212     virtual ATOOLS::NLO_subevtlist *GetSubevtList();
0213     virtual ATOOLS::NLO_subevtlist *GetRSSubevtList();
0214 
0215     virtual void SetRBMap(ATOOLS::Cluster_Amplitude *ampl);
0216     virtual void InitPSHandler(const double &maxerror,
0217                    const std::string eobs,
0218                    const std::string efunc);
0219 
0220     virtual void FillOnshellConditions();
0221     virtual bool FillFinalState(const ATOOLS::Vec4D_Vector &p);
0222 
0223     virtual std::vector<std::vector<int> > *Colours() const;
0224 
0225     static void SortFlavours(ATOOLS::Cluster_Amplitude *const ampl,
0226                  const int mode=1);
0227     static void SortFlavours(Process_Info &pi,const int mode=1);
0228 
0229     static std::string BaseName(const std::string &name,
0230                 const std::string &addname=std::string(""));
0231 
0232     static std::string GenerateName(const ATOOLS::Cluster_Amplitude *ampl);
0233     static std::string GenerateName(const ATOOLS::NLO_subevt *sub,
0234                     const size_t &nin);
0235 
0236     static std::string GenerateName(const Subprocess_Info &info);
0237     static std::string GenerateName(const Subprocess_Info &ii,
0238                     const Subprocess_Info &fi);
0239 
0240     // inline functions
0241     inline void SetParent(Process_Base *const proc) { p_parent=proc; }
0242 
0243     inline size_t NIn()                             const { return m_nin;  }
0244     inline size_t NOut()                            const { return m_nout; }
0245     inline const ATOOLS::Flavour_Vector &Flavours() const { return m_flavs; }
0246     inline void SetFlavours(const ATOOLS::Flavour_Vector& flavs) { m_flavs = flavs; }
0247 
0248     inline const std::string &Name() const        { return m_name;    }
0249     inline const std::string &ResultsName() const { return m_resname; }
0250 
0251     inline void SetMaxOrders(const std::vector<double> &o) { m_maxcpl=o; }
0252     inline void SetMinOrders(const std::vector<double> &o) { m_mincpl=o; }
0253 
0254     inline void SetMaxOrder(const size_t &id,const double o)
0255     { if (m_maxcpl.size()<=id) m_maxcpl.resize(id+1,0); m_maxcpl[id]=o; }
0256     inline void SetMinOrder(const size_t &id,const double o)
0257     { if (m_mincpl.size()<=id) m_mincpl.resize(id+1,0); m_mincpl[id]=o; }
0258 
0259     inline const std::vector<double> &MaxOrders() const { return m_maxcpl; }
0260     inline const std::vector<double> &MinOrders() const { return m_mincpl; }
0261 
0262     inline double MaxOrder(const size_t &id) const { return m_maxcpl[id]; }
0263     inline double MinOrder(const size_t &id) const { return m_mincpl[id]; }
0264 
0265     PDF::Shower_Base *Shower() const { return p_shower; }
0266     PDF::NLOMC_Base  *NLOMC() const  { return p_nlomc;  }
0267 
0268     inline Process_Info       &Info()       { return m_pinfo; }
0269     inline const Process_Info &Info() const { return m_pinfo; }
0270 
0271     inline ATOOLS::DecayInfo_Vector       &DecayInfos()       {return m_decins;}
0272     inline const ATOOLS::DecayInfo_Vector &DecayInfos() const {return m_decins;}
0273 
0274     inline ATOOLS::ME_Weight_Info *GetMEwgtinfo() { return &m_mewgtinfo; }
0275     inline void SetMEwgtinfo(const ATOOLS::ME_Weight_Info i) { m_mewgtinfo=i; }
0276 
0277     inline Process_Integrator *Integrator() const { return p_int; }
0278     
0279     inline virtual const bool   HasInternalScale() const { return m_hasinternalscale; }
0280     inline virtual const double InternalScale()    const { return m_internalscale; }
0281 
0282     virtual void FillAmplitudes(std::vector<METOOLS::Spin_Amplitudes>& amps,
0283                                 std::vector<std::vector<Complex> >& cols);
0284 
0285     inline double Last() const { return m_last.Nominal(); }
0286     inline double LastB() const { return m_lastb.Nominal(); }
0287 
0288     inline bool LookUp() const { return m_lookup; }
0289 
0290     inline double SymFac() const { return m_symfac; }
0291     inline double ISSymFac() const { return m_issymfac; }
0292 
0293     inline Scale_Setter_Base *ScaleSetter(const int map=0) const
0294     { return map?(p_mapproc?p_mapproc->p_scale:p_scale):p_scale; }
0295     inline KFactor_Setter_Base *KFactorSetter(const int map=0) const
0296     { return map?(p_mapproc?p_mapproc->p_kfactor:p_kfactor):p_kfactor; }
0297 
0298     inline bool IsMapped() const { return p_mapproc; }
0299 
0300     inline size_t MCMode() const      { return m_mcmode; }
0301     inline size_t ClusterMode() const { return m_cmode;  }
0302 
0303     inline ME_Generator_Base *Generator() const { return p_gen; }
0304 
0305     inline Process_Base *MapProc() const  { return p_mapproc; }
0306     inline Process_Base *Caller() const   { return p_caller;  }
0307 
0308     inline Cut_Data          * Cuts() const { return p_cuts; }
0309     inline Combined_Selector * Selector() const 
0310     { return p_mapproc?p_mapproc->p_selector:p_selector; }
0311     inline virtual const double SPrimeMin() const { return -1.; }
0312     inline virtual const double SPrimeMax() const { return -1.; }
0313     template <class PType> inline PType *Get() 
0314     { return dynamic_cast<PType*>(this); }
0315     template <class PType> inline const PType *Get() const 
0316     { return dynamic_cast<PType*>(this); }
0317 
0318     inline NLOTypeStringProcessMap_Map *AllProcs() { return p_apmap; }
0319 
0320     inline BBar_Multi_Channel *BBarMC() const { return p_mc; }
0321 
0322     inline const Color_Matrix &ColorMatrix(const int map=0) const
0323     { return map?(p_mapproc?p_mapproc->m_cols:m_cols):m_cols; }
0324 
0325   };// end of class Process_Base
0326 
0327   class Order_Flavour {
0328     FMMap* p_fmm;
0329     int Order_SVFT(const ATOOLS::Flavour &a,const ATOOLS::Flavour &b) 
0330     {
0331       if (a.IsScalar() && !b.IsScalar()) return 1;
0332       if (a.IsVector() && !b.IsScalar() && 
0333       !b.IsVector()) return 1;
0334       if (a.IsFermion() && !b.IsFermion() && 
0335       !b.IsScalar() && !b.IsVector()) return 1;
0336       return 0;
0337     }
0338     int Order_Multi(const ATOOLS::Flavour &a,const ATOOLS::Flavour &b)
0339     {
0340       if ((*p_fmm)[int(a.Kfcode())]==0 || 
0341       (*p_fmm)[int(b.Kfcode())]==0) return 0;
0342       if ((*p_fmm)[int(a.Kfcode())]>
0343       (*p_fmm)[int(b.Kfcode())]) return 1;
0344       return 0;
0345     }
0346     int Order_Photons(const ATOOLS::Flavour &a,const ATOOLS::Flavour &b)
0347     {
0348       if (a.Strong() && a.Mass() && b.IsPhoton()) return 1;
0349       return 0;
0350     }
0351 
0352   public:
0353     int operator()(const ATOOLS::Flavour &a,const ATOOLS::Flavour &b)
0354     {
0355       if (a.Priority()>b.Priority()) return 1;
0356       if (a.Priority()<b.Priority()) return 0;
0357       if (Order_Photons(a,b)) return 1;
0358       if (Order_Photons(b,a)) return 0;
0359       if (!a.Strong()&&b.Strong()) return 1;
0360       if (a.Strong()&&!b.Strong()) return 0;
0361       if (a.Mass()>b.Mass()) return 1;
0362       if (a.Mass()<b.Mass()) return 0;
0363       if (p_fmm) {
0364     if (Order_Multi(a,b)) return 1;
0365     if (Order_Multi(b,a)) return 0;
0366       }
0367       if (Order_SVFT(a,b)) return 1;
0368       if (Order_SVFT(b,a)) return 0;
0369       if (!a.IsAnti()&&b.IsAnti()) return 1;
0370       if (a.IsAnti()&&!b.IsAnti()) return 0;
0371       return a.Kfcode()<b.Kfcode();
0372     }
0373     Order_Flavour(FMMap* fmm): p_fmm(fmm) {}
0374     int operator()(const Subprocess_Info &a,const Subprocess_Info &b)
0375     { return (*this)(a.m_fl,b.m_fl); }
0376     int operator()(const ATOOLS::Cluster_Leg *a,
0377            const ATOOLS::Cluster_Leg *b)
0378     { return (*this)(a->Flav(),b->Flav()); }
0379   };// end of class Order_Flavour
0380 
0381 }// end of namespace ATOOLS
0382 
0383 #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!