#ifndef PHOTONS_Photon_Splitter_Sudakov_H #define PHOTONS_Photon_Splitter_Sudakov_H #include "ATOOLS/Math/Vector.H" #include "ATOOLS/Phys/Blob.H" #include "PHOTONS++/PhotonSplitter/Splitting_Functions.H" #include "PHOTONS++/PhotonSplitter/Kinematics_Base.H" #include #include "ATOOLS/Math/Histogram.H" #include "ATOOLS/Math/Histogram_2D.H" namespace PHOTONS { class Sudakov { private: Kinematics_FF * p_kinematics; Kinematics_FI * p_FIkinematics; SF_Vector m_splitters; Spec_Vector m_spectators; std::vector m_splitterIds; int m_NInP; int m_mode; int m_virtualityOrdering; int m_spectatorScheme; bool m_debug_initProbabilistic; double m_masscutoff; double m_t0; double m_t; // flavour-dependent enhancements std::map m_enhancefac; // for storing splittings Part_List m_remainingphotons; Particle_Vector m_addedparticles; bool m_addedanything; static std::string s_histo_base_name; static ATOOLS::Histogram s_histo_dipole; static ATOOLS::Histogram_2D s_histo_tdR; void RegisterDefaults(); public: Sudakov(); Sudakov(int mode); ~Sudakov(); inline void SetNInParticles(int n) { m_NInP = n; } void AddSplitter(ATOOLS::Particle *softphoton, const size_t&); void AddChargedParticle(ATOOLS::Particle* p, const size_t& id); inline Spec_Vector GetSpectators() { return m_spectators; } bool ClearAll(); void SetCutoff(); Spectator* DefineInitialConditions(double &t,ATOOLS::Vec4D pphoton); bool Run(ATOOLS::Blob *blob); bool Generate(ATOOLS::Blob *blob); std::string Info() const { return std::string(""); } inline Part_List GetRemainingSoftPhotons() { return m_remainingphotons; } inline Particle_Vector GetAddedParticles() { return m_addedparticles; } inline bool AddedAnything() { return m_addedanything; } }; /*! \file Sudakov.H \brief Contains the class PHOTONS::Sudakov */ /*! \class Sudakov \brief Implements the veto algorithm for a 1-step parton shower to split soft photons. */ ///////////////////////////////////////////////////////////////////////////////////////// // Description of member variables for Photon_Splitter ///////////////////////////////////////////////////////////////////////////////////////// /*! \var Sudakov::m_mode \brief encodes which splittings to include. Settings are additive. 1 = electrons, 2 = muons, 4 = taus, 8 = hadrons up to mass cutoff. */ /*! \var Sudakov::m_virtualityOrdering \brief stores the ordering scheme to be used. 0 is transverse momentum ordering, 1 is virtuality ordering and 2 is mixed (default). */ /*! \var Sudakov::m_spectatorScheme \brief stores the spectator scheme to be used: 0 = all final-state charged particles that exist prior to this module being called (default), 1 = only the final-state charged particle that the soft photon is calculated to be emitted off. */ /*! \var Sudakov::m_debug_initProbabilistic \brief if off, chooses starting scale by winner-takes all. Default is on. */ /*! \var Sudakov::m_masscutoff \brief the mass of the heaviest hadron which can be produced by photon splittings. Note only fermion and scalar splitting functions are currently implemented. */ /*! \var Sudakov::m_t0 \brief the IR cutoff of the algorithm. Defaults to 4m^2 where m is the mass of the lightest particle which can be produced in photon splittings. */ /*! \var Sudakov::m_remainingphotons \brief stores the photons which have not (yet) split. */ /*! \var Sudakov::m_addedparticles \brief stores the particles which are to be added to the blob. */ /*! \var Sudakov::m_addedanything \brief flags whether anything has changed so the blob can be updated. */ /*! \var Sudakov::m_splitterIds \brief keeps track of the splitter photon associated with each splitting function. */ /*! \var Sudakov::m_NInP \brief the number of incoming particles in the blob. Used to classify particles as incoming or outgoing by their ID without referring to the blob. */ ///////////////////////////////////////////////////////////////////////////////////////// // Description of member methods for Photon_Splitter ///////////////////////////////////////////////////////////////////////////////////////// /*! \fn void Sudakov::AddSplitter(ATOOLS::Particle* photon, const size_t& id) \brief Creates the splitting functions for this photon. */ /*! \fn void Sudakov::AddChargedParticle(ATOOLS::Particle* p, const size_t& id) \brief Assesses whether the charged particle can be a spectator and adds it if so. */ /*! \fn bool Sudakov::ClearAll() \brief resets the Sudakov for the next event. */ /*! \fn void Sudakov::SetCutoff() \brief sets the IR cutoff for the algorithm as described above. */ /*! \fn Spectator* Sudakov::DefineInitialConditions(double &t, Vec4D pphoton) \brief Reconstructs the emission history of the given photon and returns the recontructed spectator and starting scale. */ /*! \fn bool Sudakov::Run(ATOOLS::Blob *) \brief Runs the algorithm until the scale is below the cutoff. */ /*! \fn bool Sudakov::Generate (ATOOLS::Blob *) \brief Generates trial emissions, lets the splitting functions compete and corrects the splitting probability with a veto. */ } #endif