EIC code displayed by LXR master/​include/​SHERPA-MC/​BEAM/​Main/​Beam_Base.H	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-04-19 09:09:59

 #ifndef BEAM_Main_Beam_Base_H
 #define BEAM_Main_Beam_Base_H
 
 #include "BEAM/Main/Beam_Parameters.H"
 #include "ATOOLS/Phys/Flavour.H"
 #include "ATOOLS/Math/Vector.H"
 
 namespace BEAM {
 
   class Beam_Base {
   protected:
     beamspectrum::code           m_type;
     ATOOLS::Flavour              m_beam;
     ATOOLS::Vec4D                m_lab, m_position;
     std::vector<ATOOLS::Flavour> m_bunches;
     std::vector<ATOOLS::Vec4D>   m_vecouts;
     size_t             m_Nbunches;
     int                m_dir;
     double             m_energy, m_polarisation;
     double             m_x, m_Q2, m_weight;
     bool               m_on;
     
   public:
     Beam_Base(beamspectrum::code type,const ATOOLS::Flavour& _beam,
           const double _energy,const double _polarisation,
           const int _dir, int mode = 0);
     virtual ~Beam_Base() = default;
 
     virtual Beam_Base * Copy()                                     = 0;
     virtual bool        CalculateWeight(const double,const double) = 0;
     virtual void FixPosition() {}
     virtual inline const beamspectrum::code & Type()                      const { return m_type; }
     virtual inline const size_t             & NBunches()                  const { return m_Nbunches; } 
     virtual inline const ATOOLS::Flavour    & Beam()                      const { return m_beam; }
     virtual inline const ATOOLS::Flavour    & Bunch(const size_t & i=0)   const { return m_bunches[i]; }
     virtual inline const ATOOLS::Flavour    & Remnant()                   const { return m_beam; }
     virtual inline const ATOOLS::Vec4D & OutMomentum(const size_t & i=0)  const { return m_vecouts[i]; }
     virtual inline const ATOOLS::Vec4D & InMomentum()                     const { return m_lab; }
     virtual inline const ATOOLS::Vec4D & Position()                       const { return m_position; }
     virtual inline const std::vector<ATOOLS::Flavour> & Bunches()         const { return m_bunches; }
     virtual inline const std::vector<ATOOLS::Vec4D> & OutMomenta()        const { return m_vecouts; }
     
     virtual inline const double & Energy()       const { return m_energy; }
     virtual inline const double & Polarisation() const { return m_polarisation; }
     virtual inline double Weight(ATOOLS::Flavour fl=kf_none) { return m_weight; }
     virtual inline double Exponent()      const { return 0.; }
     virtual inline double X()             const { return m_x; }
     virtual inline double Xmin()          const { return 0.; }
     virtual inline double Xmax()          const { return 1.; }
     virtual inline double Peak()          const { return 1.; }
 
     virtual inline bool On()             const { return m_on; }
     virtual inline bool PolarisationOn() const { return (m_polarisation!=0.); }
 
     virtual inline void SetInMomentum(const ATOOLS::Vec4D &in)                       { m_lab = in; }
     virtual inline void SetOutMomentum(const ATOOLS::Vec4D &out, const size_t & i=0) { m_vecouts[i] = out; }
 
     inline void SetX(const double &x) { m_x=x; }
   };
   /*!
     \file
     \brief contains the class BEAM::Beam_Base.
   */
   /*!
     \class Beam_Base
     \brief A mainly virtual class for different beam spectra.
 
     This class is the base class for all possible beam spectra that are implemented and
     for interfaces to new beam spectra provided from outside the program. So far, two
     spectra have been implemented, one for monochromatic beams BEAM::Monochromatic,
     and one for Laser back scattering of an electron BEAM::Laser_Backscattering.
     \todo
     A number of beam spectra are still missing :
     Gaussian, Beamstrahlung and Weiszaecker-Williams off both electron and protons.
   */
   /*!
     \var std::string Beam_Base::m_type
     The type of the Beam_Base, either "Monochromatic", "LaserBackScattering",
     "Gaussian", or "Beamstrahlung". The latter two have not been implemented yet.
     The handling of different beam types is closely related to the class Beam_Type.
     \sa ATOOLS::Beam_Type
   */
   /*!
     \var ATOOLS::Flavour Beam_Base::m_beam
     The flavour of the incoming beam particle.
   */
   /*!
     \var double Beam_Base::m_energy
     Energy of the incoming beam particle.
   */
   /*!
     \var double Beam_Base::m_polarisation
     The polarization degree of the incoming particle. It should
     range between -1 and 1 and it should - preferably - be a helicity.
   */
   /*!
     \var ATOOLS::Vec4D Beam_Base::m_lab
     The momentum of the incoming beam particle, i.e. before the spectrum becomes effective.
   */
   /*!
     \var ATOOLS::Vec4D Beam_Base::m_vecouts
     The momentum of the outgoing bunch particle, i.e. after the spectrum becomes effective.
   */
   /*!
     \var Beam_Base::m_dir
     A direction flag for the construction of the beam momentum.
   */
   /*!
     \var double Beam_Base::m_weight
     The internal weight for the spectrum. It is calculated through the method
     CalculateWeight(const double,const double).
   */
   /*!
     \var double Beam_Base::m_x
     The energy portion the outgoing bunch particle carries away from the beam particle.
     This is in the c.m. frame of the two incoming beams.
   */
   /*!
     \var double Beam_Base::m_Q2
     The scale of the transition of the beams into bunches. This can - in principle - be set
     individually, for instance for Weizsaecker-Williams photons. This option has not been
     fully implemented yet because all beam spectra included so far depend on the energy fraction
     only.
   */
   /*!
     \fn Beam_Base::Beam_Base(std::string,const ATOOLS::Flavour,const double,const double,const int)
     \brief The constructor, initializes the full structure of this beam spectrum.
 
     In this constructor the incoming vectors are constructed from the direction flag, the energy of
     the beam in the lab frame and the mass of the beam particle. By default, also the outgonig momentum
     is set as the incoming one.
   */
   /*!
     \fn Beam_Base * Beam_Base::Copy()
     This method produces an exact copy of the beam base in question. All internal parameters -
     excluding the actual weight, m_weight, are copied.
   */
   /*!
     \fn bool Beam_Base::CalculateWeight(const double,const double)
     This is the method that will calculate the weight for a given beam spectrum in
     dependence on the energy fraction of the outgoing particle w.r.t. the incoming one
     and in dependence on the scale of the process. The scale might, for instance, become
     important once Weizsaecker-Williams type spectra are considered.
   */
   /*!
     \fn double Beam_Base::Weight(ATOOLS::Flavour fl=Flavour(kf_none))
     Returns the weight. A flavour checking could be included in the future.
   */
   /*!
     \fn bool Beam_Base::On()
     Returns .false. if no beam-handling is necessary, i.e. for monochromatic beams and
     .true. in all other cases.
   */
   /*!
     \fn double Beam_Base::Exponent()
     This is a helper for the phase space integration. It returns a characteristic value -
     usually an exponent - for simple channel structures.
   */
   /*!
     \fn double Beam_Base::Xmax()
     The maximally accessible energy fraction an outgoing particle can have.
   */
   /*!
     \fn double Beam_Base::Peak()
     The peak position for spectra. in most cases this will be 0 or 1; in contrast, for
     laser back scattering it has a different value. This is also needed for the construction
     of integration channels.
   */
 }
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team