diff --git a/Shower/ShowerHandler.h b/Shower/ShowerHandler.h --- a/Shower/ShowerHandler.h +++ b/Shower/ShowerHandler.h @@ -1,407 +1,407 @@ // -*- C++ -*- #ifndef PYTHIA7_ShowerHandler_H #define PYTHIA7_ShowerHandler_H // This is the declaration of the ShowerHandler class. #include "Pythia7/Config/Pythia7.h" #include "ThePEG/Handlers/CascadeHandler.h" #include "ThePEG/Utilities/ObjectIndexer.h" // #include "ShowerHandler.fh" // #include "ShowerHandler.xh" #include "Pythia7/Shower/SpaceShowerHandler.h" #include "Pythia7/Shower/TimeShowerHandler.h" #include "Pythia7/Shower/Basics.h" #include "Pythia7/Shower/Shower.h" #include "ThePEG/PDF/PartonBinInstance.h" namespace Pythia7 { /** * The ShowerHandler class administers parton showers for * external partons in a hard SubProcess or in a * decay of a heavy resonance. The main function will identify partons * in the current step which should shower and create corresponding * TimeParticle and SpaceParticle * objects which, using the assigned TimeShower and * SpaceShower objects, will administer the * showering. * * @see \ref ShowerHandlerInterfaces "The interfaces" * defined for ShowerHandler. * @see SubProcess * @see TimeParticle * @see SpaceParticle * @see TimeShower * @see SpaceShower * */ class ShowerHandler: public CascadeHandler { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline ShowerHandler(); /** * The copy constructor. */ inline ShowerHandler(const ShowerHandler &); /** * The destructor. */ virtual ~ShowerHandler(); //@} public: /** @name Virtual functions required by the CascadeHandler class. */ //@{ /** * The main function called by the EventHandler class to * perform a step. Stores important information and calls * cascade(). * @param eh the EventHandler in charge of the Event generation. * @param tagged if not empty these are the only particles which should * be considered by the StepHandler. * @param hint a Hint object with possible information from previously * performed steps. * @throws Veto if the StepHandler requires the current step to be * discarded. * @throws Stop if the generation of the current Event should be stopped * after this call. * @throws Exception if something goes wrong. */ virtual void handle(EventHandler & eh, const tPVector & tagged, const Hint & hint); /** * Perform the actual cascade. */ virtual void cascade(); //@} /** * Perform a final-state cascade on the given partons. */ virtual void cascade(const tPVector & final); /** * Perform an initial-state cascade on the incoming partons of the * given sub-process. */ virtual void cascade(tSubProPtr sub); /** * Return true if the given particle can be showered. If \a inc is * true, test if the particle can initiate an initial state shower. */ virtual bool canShower(tcPPtr p, bool inc = false) const; /** * If true all branchings in the shower will be added to the new * step. Otherwise only the final partons will be added. */ inline bool history() const; public: /** @name Functions used by the persistent I/O system. */ //@{ /** * Function used to write out object persistently. * @param os the persistent output stream written to. */ void persistentOutput(PersistentOStream & os) const; /** * Function used to read in object persistently. * @param is the persistent input stream read from. * @param version the version number of the object when written. */ void persistentInput(PersistentIStream & is, int version); //@} /** * Standard Init function used to initialize the interfaces. */ static void Init(); protected: /** * Add a particle to the internal event record with the given * status. Note that if the parent particles has not already been * added, they will not be listed as parents in the internal event * record. */ long addParticle(tPPtr p, long status); /** * Add a particle to the internal event record with the given status * and mother indices. Note that if the parent particles has not * already been added, they will not be listed as parents in the * internal event record. */ long addParticle(tPPtr p, long status, long mother1, long mother2); /** * Add a time-like particle to the internal event record with the * given mother indices. If the particle has decayed add its * children recursively. */ void addFinalParticles(tPPtr p, long mother1, long mother2); /** * Set the static parameters of the underlying model object and * return an instance. */ Shower::Shower * getModel(); /** * Return true if the given particle is a resonance (defined by the * fact that all children only has the resonance as a parent). */ bool isResonance(tcPPtr r) const; protected: /** * Recursively find the first and last indices in the internal event * record of the incoming shower initiator. */ void findChain(pair & chain, long init) const; /** * Find the parent ThePEG::Particle pair of a given entry in the * internal event record. */ tPPair findParent(long i) const; /** * Create a ThePEG::Particle corresponding to a given entry in the * internal event record. If \a inc is true the particle is an * initiator for an intial state shower. */ tPPtr createParticle(long i, bool inc = false); /** * Copy information of the given entry in the internal event record * to the given ThePEG::Particle. */ tPPtr copyParticle(long i, tPPtr p); /** * Return the ThePEG::Particle corresponding to a given entry in the * internal event record. */ tPPtr getParticle(long i) const; /** * Return the momentum of the given entry in the internal event * record. */ Lorentz5Momentum momentum(long i) const; protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ inline virtual IBPtr clone() const; /** Make a clone of this object, possibly modifying the cloned object * to make it sane. * @return a pointer to the new object. */ inline virtual IBPtr fullclone() const; //@} public: /** * Return a pointer to the object which implements the actual * time-like shower model. */ inline tTimeShowerPtr timeShower() const; /** * Return a pointer to the object which implements the actual * space-like shower model. */ inline tSpaceShowerPtr spaceShower() const; protected: protected: /** @name Standard Interfaced functions. */ //@{ /** * Check sanity of the object during the setup phase. */ inline virtual void doupdate(); /** * Initialize this object after the setup phase before saving an * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ inline virtual void doinit(); /** * Initialize this object. Called in the run phase just before * a run begins. */ inline virtual void doinitrun(); /** * Finalize this object. Called in the run phase just after a * run has ended. Used eg. to write out statistics. */ inline virtual void dofinish(); /** * Rebind pointer to other Interfaced objects. Called in the setup phase * after all objects used in an EventGenerator has been cloned so that * the pointers will refer to the cloned objects afterwards. * @param trans a TranslationMap relating the original objects to * their respective clones. * @throws RebindException if no cloned object was found for a given * pointer. */ inline virtual void rebind(const TranslationMap & trans); /** * Return a vector of all pointers to Interfaced objects used in this * object. * @return a vector of pointers. */ inline virtual IVector getReferences(); //@} private: /** * The object implementing the administration of the time- and * space-like showers. */ Shower::Shower * theShowerModel; /** * The object which implements the actual time-like shower model. */ TimeShowerPtr theTimeShower; /** * The object which implements the actual space-like shower model. */ SpaceShowerPtr theSpaceShower; /** * If true add final-state radiation off initial-state cascade. */ bool addFSROnISR; /** * If true all branchings in the shower will be added to the new * step. Otherwise only the final partons will be added. */ bool theFullHistory; /** * The maximum number of attempts to cascade a sub process before * giving up and throwing an eventerror. */ long maxTries; protected: /** * The event record used internally. */ Shower::Event event; /** * Association between ColourLines and colour indices. */ ObjectIndexer colourIndex; /** * Association between Particles and indices. */ ObjectIndexer particleIndex; private: /** * Exception class used if too many attempts is made to shower a * sub-process. */ struct InfiniteLoopException: public Exception {}; private: /** * Describe a concrete class with persistent data. */ static ClassDescription initShowerHandler; /** * Private and non-existent assignment operator. */ - ShowerHandler & operator=(const ShowerHandler &); + ShowerHandler & operator=(const ShowerHandler &) = delete; }; } namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** * This template specialization informs ThePEG about the base class of * Pythia7::ShowerHandler. */ template <> struct BaseClassTrait: public ClassTraitsType { /** Typedef of the base class of Pythia7::ShowerHandler. */ typedef CascadeHandler NthBase; }; /** * This template specialization informs ThePEG about the name of the * Pythia7::ShowerHandler class and the shared object where it is * defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return the class name. */ static string className() { return "Pythia7::ShowerHandler"; } /** Return the name of the shared library be loaded to get access to * the Pythia7::ShowerHandler class and every other class it uses * (except the base class). */ static string library() { return "libP7Shower.so"; } }; /** @endcond */ } #include "ShowerHandler.icc" #ifndef PYTHIA7_TEMPLATES_IN_CC_FILE // #include "ShowerHandler.tcc" #endif #endif /* PYTHIA7_ShowerHandler_H */ diff --git a/Shower/SpaceShowerHandler.h b/Shower/SpaceShowerHandler.h --- a/Shower/SpaceShowerHandler.h +++ b/Shower/SpaceShowerHandler.h @@ -1,566 +1,566 @@ // -*- C++ -*- #ifndef PYTHIA7_SpaceShowerHandler_H #define PYTHIA7_SpaceShowerHandler_H // This is the declaration of the SpaceShowerHandler class. #include "Pythia7/Config/Pythia7.h" #include "ThePEG/Handlers/HandlerBase.h" #include "Pythia7/Shower/SpaceShower.h" #include "SpaceShowerHandler.fh" // #include "SpaceShowerHandler.xh" #include "TimeShowerHandler.fh" namespace Pythia7 { /** * SpaceShowerHandler is a wrapper around the internal * Shower::SpaceShower class to perform a space-like parton shower. * * @see \ref SpaceShowerHandlerInterfaces "The interfaces" * defined for SpaceShowerHandler. */ class SpaceShowerHandler: public HandlerBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline SpaceShowerHandler(); /** * The copy constructor. */ inline SpaceShowerHandler(const SpaceShowerHandler &); /** * The destructor. */ virtual ~SpaceShowerHandler(); //@} public: /** * Set the static parameters of the underlying model object and * return an instance. */ Shower::SpaceShower * getModel(); /** * Allowed ISR showers for incoming hadron: = 0: none; = 1: QCD * ones; = 2 : also allow photon emission; = 3 : allow spacelike * photon branchings, if supported by the PDF used (not the case * currently) (does not address VMD part of resolved photons). */ inline int hadronShower() const; /** * Allowed ISR showers for incoming lepton: = 0: none; = 1: photon * emission; = 2 : allow spacelike photon branchings, if supported * by the PDF used (not the case currently) (does not address VMD * part of resolved photons). */ inline int leptonShower() const; /** * Number of allowed quark flavours in \f$g\rightarrow q \bar{q}\f$ * branching. */ inline int nQuarks() const; /** * Running of alpha_strong in evolution: = 0: fixed; = 1: scale * \f$Q^2\f$; = 2: scale \f$p_\perp^2\f$. But note that PDF's are * always evaluated at \f$Q^2\f$. */ inline int alphaSMode() const; /** * Maximum virtuality setting the starting point of the evolution: = * 0: \f$s\f$; = 1: \f$\hat{s}\f$; = 2: average \f$m_\perp^2\f$; = * 3: smallest \f$m_\perp^2\f$. */ inline int maxVirtuality() const; /** * Use of matrix element corrections: * = 0: no; = 1: yes. */ inline int MEMode() const; /** * Resum the effect of multiple soft gluon emissions: = 0: no; = 1: yes. */ inline int softGluonResum() const; /** * Restrict first emission within cone given by colour flow in hard * process. = 0: no; = 1: yes, isotropic phi angle inside cone; = 2: * yes, also with anisotropic phi angle inside cone. */ inline int finalCone() const; /** * Q2 ordering is normal, but could be relaxed (to be developed in * future). = 0: yes; = 1: no, allow maximum kinematically possible * (toy scenario). */ inline int Q2Order() const; /** * Use angular ordering? */ inline bool angularOrdering() const; /** * Azimuthal asymmetry induced by gluon polarization. * = 0: no; = 1: yes. */ inline int phiPolAsym() const; /** * Azimuthal asymmetry induced by colour coherence. * = 0: no; = 1: yes. */ inline int phiCoherAsym() const; /** * Use the scale variable of original partons to restrict * branchings. = 0: no; = 1: yes, \f$Q^2 <\f$ scale; = 2: yes, * \f$p_\perp^2 <\f$ scale, = 3: yes, \f$(E\theta)^2 <\f$ scale; = * 4: yes, \f$\theta^2 <\f$ scale. Here theta is the full opening * angle of a branching, defined in the rest frame of the event. (In * all cases relations are approximate.) */ inline int respectScale() const; /** * Parton shower cut-off mass for QCD emissions. */ inline Energy Q0() const; /** * Parton shower cut-off mass for photon coupling to coloured particle. */ inline Energy Q0ChgQ() const; /** * Parton shower cut-off mass for pure QED branchings. Assumed <= Q0CHGQ. */ inline Energy Q0ChgL() const; /** * Fixed alpha_strong value for AlphaSMode == 0. */ inline double alphaSFix() const; /** * Lambda_QCD(five flavours) in alpha_strong for AlphaSMode >= 1. */ inline Energy Lambda5() const; /** * Fixed alpha_em value. */ inline double alphaEMFix() const; /** * Minimum energy of emitted QCD parton in rest frame of subprocess. */ inline Energy EMinEmitted() const; /** * Minimum fraction \f$1 - z\f$ of emitted QCD parton, in addition * to other limits. */ inline double zMinEmitted() const; /** * Minimum \f$x\f$ fraction of emitted photon - matched to treatment of * photon PDF. */ inline double xMinEmittedChg() const; /** * Smallest particle mass for QED evolution (= electron mass). */ inline Energy tinyQChg() const; /** * Vanishingly small parton density. */ inline double tinyPDF() const; /** * Vanishingly small product of splitting kernels and parton density * ratios. */ inline double tinyKernelPDF() const; /** * Vanishingly small recoil mass in branching kinematics reconstruction. */ inline double tinyKinPrec() const; /** * Safety margin in \f$x\f$ that heavy flavour evolution is at all * possible. */ inline double heavyEvol() const; /** * Extra preweight in QED shower evolution, to avoid maximum violation. */ inline double extraPreweight() const; /** * Maximum allowed \f$x\f$ when reconstructing back to heavy flavour * from gluon or photon. */ inline double heavyMax() const; /** * Mimimum gap in \f$Q^2\f$ values to allow iteration when parton * density vanishes. */ inline double Q2StartFrac() const; public: /** @name Functions used by the persistent I/O system. */ //@{ /** * Function used to write out object persistently. * @param os the persistent output stream written to. */ void persistentOutput(PersistentOStream & os) const; /** * Function used to read in object persistently. * @param is the persistent input stream read from. * @param version the version number of the object when written. */ void persistentInput(PersistentIStream & is, int version); //@} /** * Standard Init function used to initialize the interfaces. */ static void Init(); protected: protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ inline virtual IBPtr clone() const; /** Make a clone of this object, possibly modifying the cloned object * to make it sane. * @return a pointer to the new object. */ inline virtual IBPtr fullclone() const; //@} protected: protected: /** @name Standard Interfaced functions. */ //@{ /** * Check sanity of the object during the setup phase. */ inline virtual void doupdate(); /** * Initialize this object after the setup phase before saving an * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ inline virtual void doinit(); /** * Initialize this object. Called in the run phase just before * a run begins. */ inline virtual void doinitrun(); /** * Finalize this object. Called in the run phase just after a * run has ended. Used eg. to write out statistics. */ inline virtual void dofinish(); /** * Rebind pointer to other Interfaced objects. Called in the setup phase * after all objects used in an EventGenerator has been cloned so that * the pointers will refer to the cloned objects afterwards. * @param trans a TranslationMap relating the original objects to * their respective clones. * @throws RebindException if no cloned object was found for a given * pointer. */ inline virtual void rebind(const TranslationMap & trans); /** * Return a vector of all pointers to Interfaced objects used in this * object. * @return a vector of pointers. */ inline virtual IVector getReferences(); //@} private: /** * The object implementing the actual model. */ Shower::SpaceShower * theShowerModel; /** * Allowed ISR showers for incoming hadron: = 0: none; = 1: QCD * ones; = 2 : also allow photon emission; = 3 : allow spacelike * photon branchings, if supported by the PDF used (not the case * currently) (does not address VMD part of resolved photons). */ int theHadronShower; /** * Allowed ISR showers for incoming lepton: = 0: none; = 1: photon * emission; = 2 : allow spacelike photon branchings, if supported * by the PDF used (not the case currently) (does not address VMD * part of resolved photons). */ int theLeptonShower; /** * Number of allowed quark flavours in g -> q qbar branching. */ int theNQuarks; /** * Running of alpha_strong in evolution: * = 0: fixed; = 1: scale Q^2; = 2: scale pT^2. * But note that PDF's are always evaluated at Q2. */ int theAlphaSMode; /** * Maximum virtuality setting the starting point of the evolution: = * 0: s; = 1: sHat; = 2: average mT^2; = 3: smallest mT^2. */ int theMaxVirtuality; /** * Use of matrix element corrections: * = 0: no; = 1: yes. */ int theMEMode; /** * Resum the effect of multiple soft gluon emissions: = 0: no; = 1: yes. */ int theSoftGluonResum; /** * Restrict first emission within cone given by colour flow in hard * process. = 0: no; = 1: yes, isotropic phi angle inside cone; = 2: * yes, also with anisotropic phi angle inside cone. */ int theFinalCone; /** * Q2 ordering is normal, but could be relaxed (to be developed in * future). = 0: yes; = 1: no, allow maximum kinematically possible * (toy scenario). */ int theQ2Order; /** * Use angular ordering if non-zero. */ int useAngularOrdering; /** * Azimuthal asymmetry induced by gluon polarization. * = 0: no; = 1: yes. */ int thePhiPolAsym; /** * Azimuthal asymmetry induced by colour coherence. * = 0: no; = 1: yes. */ int thePhiCoherAsym; /** * Use the scale variable of original partons to restrict * branchings. = 0: no; = 1: yes, the Q2 < scale; = 2: yes, the pT2 * < scale, = 3: yes, the (E*theta)^2 < scale; = 4: yes, the theta^2 * < scale. Here theta is the full opening angle of a branching, * defined in the rest frame of the event. (In all cases relations * are approximate.) */ int theRespectScale; /** * Parton shower cut-off mass for QCD emissions. */ Energy theQ0; /** * Parton shower cut-off mass for photon coupling to coloured particle. */ Energy theQ0ChgQ; /** * Parton shower cut-off mass for pure QED branchings. Assumed <= Q0CHGQ. */ Energy theQ0ChgL; /** * Fixed alpha_strong value for AlphaSMode == 0. */ double theAlphaSFix; /** * Lambda_QCD(five flavours) in alpha_strong for AlphaSMode >= 1. */ Energy theLambda5; /** * Fixed alpha_em value. */ double theAlphaEMFix; /** * Minimum energy of emitted QCD parton in rest frame of subprocess. */ Energy theEMinEmitted; /** * Minimum fraction 1 - z of emitted QCD parton, in addition to * other limits. */ double theZMinEmitted; /** * Minimum x fraction of emitted photon - matched to treatment of * photon PDF. */ double theXMinEmittedChg; /** * Smallest particle mass for QED evolution (= electron mass). */ Energy theTinyQChg; /** * Vanishingly small parton density. */ double theTinyPDF; /** * Vanishingly small product of splitting kernels and parton density * ratios. */ double theTinyKernelPDF; /** * Vanishingly small recoil mass in branching kinematics reconstruction. */ double theTinyKinPrec; /** * Safety margin in x that heavy flavour evolution is at all possible. */ double theHeavyEvol; /** * Extra preweight in QED shower evolution, to avoid maximum violation. */ double theExtraPreweight; /** * Maximum allowed x when reconstructing back to heavy flavour from * gluon or photon. */ double theHeavyMax; /** * Mimimum gap in Q2 values to allow iteration when parton density * vanishes. */ double theQ2StartFrac; private: /** * Describe a concrete class with persistent data. */ static ClassDescription initSpaceShowerHandler; /** * Private and non-existent assignment operator. */ - SpaceShowerHandler & operator=(const SpaceShowerHandler &); + SpaceShowerHandler & operator=(const SpaceShowerHandler &) = delete; }; } namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** * This template specialization informs ThePEG about the base class of * Pythia7::SpaceShowerHandler. */ template <> struct BaseClassTrait: public ClassTraitsType { /** Typedef of the base class of Pythia7::SpaceShowerHandler. */ typedef HandlerBase NthBase; }; /** * This template specialization informs ThePEG about the name of the * Pythia7::SpaceShowerHandler class and the shared object where it is * defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return the class name. */ static string className() { return "Pythia7::SpaceShowerHandler"; } /** Return the name of the shared library be loaded to get access to * the Pythia7::SpaceShowerHandler class and every other class it uses * (except the base class). */ static string library() { return "libP7Shower.so"; } }; /** @endcond */ } #include "SpaceShowerHandler.icc" #ifndef PYTHIA7_TEMPLATES_IN_CC_FILE // #include "SpaceShowerHandler.tcc" #endif #endif /* PYTHIA7_SpaceShowerHandler_H */ diff --git a/Shower/TimeShowerHandler.h b/Shower/TimeShowerHandler.h --- a/Shower/TimeShowerHandler.h +++ b/Shower/TimeShowerHandler.h @@ -1,416 +1,416 @@ // -*- C++ -*- #ifndef PYTHIA7_TimeShowerHandler_H #define PYTHIA7_TimeShowerHandler_H // This is the declaration of the TimeShowerHandler class. #include "Pythia7/Config/Pythia7.h" #include "ThePEG/Handlers/HandlerBase.h" #include "Pythia7/Shower/TimeShower.h" #include "TimeShowerHandler.fh" // #include "TimeShowerHandler.xh" namespace Pythia7 { /** * TimeShowerHandler is a wrapper around the internal * Shower::TimeShower class to perform a space-like parton shower. * * @see \ref TimeShowerHandlerInterfaces "The interfaces" * defined for TimeShowerHandler. */ class TimeShowerHandler: public HandlerBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline TimeShowerHandler(); /** * The copy constructor. */ inline TimeShowerHandler(const TimeShowerHandler &); /** * The destructor. */ virtual ~TimeShowerHandler(); //@} public: /** * Set the static parameters of the underlying model object and * return an instance. */ Shower::TimeShower * getModel(); /** * Angular ordering; = 0: off, = 1: on for g emission, = 2: on also * for \f$g\rightarrow q \bar{q}\f$ splitting. */ inline int angularOrder() const; /** * Number of allowed quark flavours in \f$g\rightarrow q \bar{q}\f$ * branching. */ inline int nQuark() const; /** * Running of alpha_strong in evolution: = 0: fixed; = 1: scale * \f$Q^2/4\f$; = 2: scale \f$p_\perp^2\f$; = 3: scale * \f$p_\perp^2\f$, except for \f$g\rightarrow q \bar{q}\f$, where * it is \f$Q^2/4\f$. */ inline int alphaSMode() const; /** * Also allow a QED shower together with QCD ones: = 0: no; = 1: * radiate on-shell photons; = 2 : also allow photons to branch. */ inline int MEMode() const; /** * Also allow a QED shower together with QCD ones: = 0: no; * = 1: radiate on-shell photons; = 2 : also allow photons to branch. */ inline int QEDShower() const; /** * Restrict first emission within cone given by colour flow in hard * process. = 0: no; = 1: yes, isotropic phi angle inside cone; = * 2: yes, also with anisotropic phi angle inside cone. */ inline int initialCone() const; /** * Azimuthal asymmetry induced by gluon polarization. * = 0: no; = 1: yes. */ inline int phiPolAsym() const; /** * Azimuthal asymmetry induced by colour coherence. * = 0: no; = 1: yes. */ inline int phoCoherAsym() const; /** * Use the scale variable of original partons to restrict * branchings. = 0: no; = 1: yes, \f$Q^2 <\f$ scale; = 2: yes, * \f$p_\perp^2 <\f$ scale, = 3: yes, \f$(E\theta)^2 <\f$ scale; = * 4: yes, \f$\theta^2 <\f$ scale. (In all cases relations are * approximate.) */ inline int respectScale() const; /** * Parton shower cut-off mass for QCD emissions. */ inline Energy Q0() const; /** * Parton shower cut-off mass for photon coupling to coloured particle. */ inline Energy Q0ChgQ() const; /** * Parton shower cut-off mass for pure QED branchings. Assumed <= Q0CHGQ. */ inline Energy Q0ChgL() const; /** * Fixed alpha_strong value for AlphaSMode == 0. */ inline double alphaSFix() const; /** * \f$\Lambda_{\mbox{QCD}}\f$ (five flavours) in alpha_strong for * AlphaSMode >= 1. */ inline Energy Lambda5() const; /** * Fixed \f$\alpha_{\mbox{EM}}\f$ value. */ inline double alphaEMFix() const; /** * Fraction of Q0 cut-off mass used as safety margin in * daughter mass sum. Relevant for total parton multiplicity. */ inline double Q0FracPS() const; public: /** @name Functions used by the persistent I/O system. */ //@{ /** * Function used to write out object persistently. * @param os the persistent output stream written to. */ void persistentOutput(PersistentOStream & os) const; /** * Function used to read in object persistently. * @param is the persistent input stream read from. * @param version the version number of the object when written. */ void persistentInput(PersistentIStream & is, int version); //@} /** * Standard Init function used to initialize the interfaces. */ static void Init(); protected: protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ inline virtual IBPtr clone() const; /** Make a clone of this object, possibly modifying the cloned object * to make it sane. * @return a pointer to the new object. */ inline virtual IBPtr fullclone() const; //@} protected: protected: /** @name Standard Interfaced functions. */ //@{ /** * Check sanity of the object during the setup phase. */ inline virtual void doupdate(); /** * Initialize this object after the setup phase before saving an * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ inline virtual void doinit(); /** * Initialize this object. Called in the run phase just before * a run begins. */ inline virtual void doinitrun(); /** * Finalize this object. Called in the run phase just after a * run has ended. Used eg. to write out statistics. */ inline virtual void dofinish(); /** * Rebind pointer to other Interfaced objects. Called in the setup phase * after all objects used in an EventGenerator has been cloned so that * the pointers will refer to the cloned objects afterwards. * @param trans a TranslationMap relating the original objects to * their respective clones. * @throws RebindException if no cloned object was found for a given * pointer. */ inline virtual void rebind(const TranslationMap & trans); /** * Return a vector of all pointers to Interfaced objects used in this * object. * @return a vector of pointers. */ inline virtual IVector getReferences(); //@} private: /** * The object implementing the actual model. */ Shower::TimeShower * theShowerModel; /** * Angular ordering; = 0: off, = 1: on for g emission, = 2: on also * for g -> q qbar splitting. */ int theAngularOrdering; /** * Number of allowed quark flavours in g -> q qbar branching. */ int theNQuark; /** * Running of alpha_strong in evolution: = 0: fixed; = 1: scale * Q^2/4; = 2: scale pT^2; = 3: scale pT2, except for g -> q qbar, * where it is Q^2/4 . */ int theAlphaSMode; /** * Also allow a QED shower together with QCD ones: = 0: no; = 1: * radiate on-shell photons; = 2 : also allow photons to branch. */ int theMEMode; /** * Also allow a QED shower together with QCD ones: = 0: no; * = 1: radiate on-shell photons; = 2 : also allow photons to branch. */ int theQEDShower; /** * Restrict first emission within cone given by colour flow in hard * process. = 0: no; = 1: yes, isotropic phi angle inside cone; = * 2: yes, also with anisotropic phi angle inside cone. */ int theInitialCone; /** * Azimuthal asymmetry induced by gluon polarization. * = 0: no; = 1: yes. */ int thePhiPolAsym; /** * Azimuthal asymmetry induced by colour coherence. * = 0: no; = 1: yes. */ int thePhiCoherAsym; /** * Use the scale variable of original partons to restrict * branchings. = 0: no; = 1: yes, the Q2 < scale; = 2: yes, the pT2 * < scale, = 3: yes, the (E*theta)^2 < scale; = 4: yes, the theta^2 * < scale. (In all cases relations are approximate.) */ int theRespectScale; /** * Parton shower cut-off mass for QCD emissions. */ Energy theQ0; /** * Parton shower cut-off mass for photon coupling to coloured particle. */ Energy theQ0ChgQ; /** * Parton shower cut-off mass for pure QED branchings. Assumed <= Q0CHGQ. */ Energy theQ0ChgL; /** * Fixed alpha_strong value for AlphaSMode == 0. */ double theAlphaSFix; /** * Lambda_QCD(five flavours) in alpha_strong for AlphaSMode >= 1. */ Energy theLambda5; /** * Fixed alpha_EM value. */ double theAlphaEMFix; /** * Fraction of Q0 cut-off mass used as safety margin in * daughter mass sum. Relevant for total parton multiplicity. */ double theQ0FracPS; private: /** * Describe a concrete class with persistent data. */ static ClassDescription initTimeShowerHandler; /** * Private and non-existent assignment operator. */ - TimeShowerHandler & operator=(const TimeShowerHandler &); + TimeShowerHandler & operator=(const TimeShowerHandler &) = delete; }; } namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** * This template specialization informs ThePEG about the base class of * Pythia7::TimeShowerHandler. */ template <> struct BaseClassTrait: public ClassTraitsType { /** Typedef of the base class of Pythia7::TimeShowerHandler. */ typedef HandlerBase NthBase; }; /** * This template specialization informs ThePEG about the name of the * Pythia7::TimeShowerHandler class and the shared object where it is * defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return the class name. */ static string className() { return "Pythia7::TimeShowerHandler"; } /** Return the name of the shared library be loaded to get access to * the Pythia7::TimeShowerHandler class and every other class it uses * (except the base class). */ static string library() { return "libP7Shower.so"; } }; /** @endcond */ } #include "TimeShowerHandler.icc" #ifndef ThePEG_TEMPLATES_IN_CC_FILE // #include "TimeShowerHandler.tcc" #endif #endif /* PYTHIA7_TimeShowerHandler_H */ diff --git a/Strategy/Pythia7Strategy.h b/Strategy/Pythia7Strategy.h --- a/Strategy/Pythia7Strategy.h +++ b/Strategy/Pythia7Strategy.h @@ -1,165 +1,165 @@ // -*- C++ -*- #ifndef PYTHIA7_Pythia7Strategy_H #define PYTHIA7_Pythia7Strategy_H // This is the declaration of the Pythia7Strategy class. #include "ThePEG/Repository/Strategy.h" #include "ThePEG/PDT/ParticleData.h" // #include "Pythia7Strategy.fh" // #include "Pythia7Strategy.xh" namespace Pythia7 { using namespace ThePEG; /** * The Pythia7Strategy class is a sub-class of the Strategy * class, simply implementing the correct citation for Pythia7 in the * ClassDocumentation interface. * * See also \ref Pythia7StrategyInterfaces "the interfaces" defined * for Pythia7Strategy. */ class Pythia7Strategy: public Strategy { public: /** @name Standard constructors and destructors. */ //@{ /** * Default constructor. */ inline Pythia7Strategy(); /** * Copy-constructor. */ inline Pythia7Strategy(const Pythia7Strategy &); /** * Destructor. */ virtual ~Pythia7Strategy(); //@} public: /** * Standard Init function used to initialize the interface. */ static void Init(); protected: protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ inline virtual IBPtr clone() const; /** Make a clone of this object, possibly modifying the cloned object * to make it sane. * @return a pointer to the new object. */ inline virtual IBPtr fullclone() const; //@} protected: /** @name Standard Interfaced functions. */ //@{ /** * Check sanity of the object during the setup phase. */ inline virtual void doupdate(); /** * Initialize this object after the setup phase before saving an * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ inline virtual void doinit(); /** * Finalize this object. Called in the run phase just after a * run has ended. Used eg. to write out statistics. */ inline virtual void dofinish(); /** * Rebind pointer to other Interfaced objects. Called in the setup phase * after all objects used in an EventGenerator has been cloned so that * the pointers will refer to the cloned objects afterwards. * @param trans a TranslationMap relating the original objects to * their respective clones. * @throws RebindException if no cloned object was found for a given * pointer. */ inline virtual void rebind(const TranslationMap & trans); /** * Return a vector of all pointers to Interfaced objects used in this * object. * @return a vector of pointers. */ inline virtual IVector getReferences(); //@} private: /** * Describe concrete class without persistent data. */ static NoPIOClassDescription initPythia7Strategy; /** * Private and non-existent assignment operator. */ - Pythia7Strategy & operator=(const Pythia7Strategy &); + Pythia7Strategy & operator=(const Pythia7Strategy &) = delete; }; } namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the base classes * of Pythia7::Pythia7Strategy. */ template <> struct BaseClassTrait: public ClassTraitsType { /** Typedef of the first base class of Pythia7::Pythia7Strategy. */ typedef Strategy NthBase; }; /** This template specialization informs ThePEG about the name of the * Pythia7::Pythia7Strategy class and the shared object where it is * defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Pythia7::Pythia7Strategy"; } /** Return the name of the shared library be loaded to get access to * the Pythia7::Pythia7Strategy class and every other class it uses * (except the base class). */ static string library() { return "Pythia7Strategy.so"; } }; /** @endcond */ } #include "Pythia7Strategy.icc" #ifndef PYTHIA7_TEMPLATES_IN_CC_FILE // #include "Pythia7Strategy.tcc" #endif #endif /* PYTHIA7_Pythia7Strategy_H */ diff --git a/StringFrag/LundPtGenerator.h b/StringFrag/LundPtGenerator.h --- a/StringFrag/LundPtGenerator.h +++ b/StringFrag/LundPtGenerator.h @@ -1,227 +1,227 @@ // -*- C++ -*- #ifndef PYTHIA7_LundPtGenerator_H #define PYTHIA7_LundPtGenerator_H // This is the declaration of the LundPtGenerator class. #include "FragConfig.h" // #include "LundPtGenerator.fh" // #include "LundPtGenerator.xh" #include "ThePEG/Handlers/PtGenerator.h" namespace Pythia7 { /** * LundPtGenerator is the transverse momentum generator used in the * Lund string fragmentation scheme. It generates the \f$(p_x,p_y)\f$ * components of the transverse momentum of a quark (diquark) in a * \f$q-\bar{q}\f$ (or a \f$(qq)-(\overline{qq})\f$) pair created in * the string colour field, according to the flavour independent * Gaussian distribution in \f$p_x\f$ and \f$p_y\f$ including the * possibility of non-Gaussian tails. * * LundPtGenerator inherits the from the PtGenerator class and * overrides the generate() function. * * Note that the 4-vector version of the transverse momentum is * obtained given the transverse vectors of the StringRegion where the * pair is produced. * * @see \ref LundPtGeneratorInterfaces "The interfaces" defined * for LundPtGenerator. * */ class LundPtGenerator: public ThePEG::PtGenerator { public: /** @name Standard constructors and destructors. */ //@{ /** * Default constructor. */ inline LundPtGenerator(); /** * Copy-constructor. */ inline LundPtGenerator(const LundPtGenerator &); /** * Destructor. */ virtual ~LundPtGenerator(); //@} public: /** @name Virtual functions required by the PtGenerator class. */ //@{ /** * Generate (\f$k_x, k_y\f$) components of the transverse * momentum. They will be distributed as * \f$\exp(-k_\perp^2/\sigma^2)k_\perp dk_\perp\f$ with * \f$k_\perp^2=k_x^2+k_y^2\f$ and \f$\sigma=\f$ Sigma(). */ virtual TransverseMomentum generate() const ; //@} /** @name Access to parameters. */ //@{ /** * Get the gaussian width. */ inline Energy Sigma() const; /** * Get the non-Gaussian fraction of the Gaussian transverse momentum * distribution to be enhanced by the factor nGaussFactor(). */ inline double NGaussFraction() const; /** * Get the non-Gaussian tails enhancement factor. */ inline double NGaussFactor() const; //@} public: /** @name Functions used by the persistent I/O system. */ //@{ /** * Function used to write out object persistently. * @param os the persistent output stream written to. */ void persistentOutput(PersistentOStream & os) const; /** * Function used to read in object persistently. * @param is the persistent input stream read from. * @param version the version number of the object when written. */ void persistentInput(PersistentIStream & is, int version); //@} /** * Standard Init function used to initialize the interface. */ static void Init(); protected: protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ inline virtual IBPtr clone() const; /** Make a clone of this object, possibly modifying the cloned object * to make it sane. * @return a pointer to the new object. */ inline virtual IBPtr fullclone() const; //@} protected: /** @name Standard Interfaced functions. */ //@{ /** * Check sanity of the object during the setup phase. */ inline virtual void doupdate(); /** * Initialize this object after the setup phase before saving an * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ inline virtual void doinit(); /** * Finalize this object. Called in the run phase just after a * run has ended. Used eg. to write out statistics. */ inline virtual void dofinish(); //@} private: /** * The gaussian width. */ Energy sigma; //PARJ(21) /** * The non-Gaussian fraction of the Gaussian transverse momentum * distribution to be enhanced by the factor nGaussFactor(). */ double nGaussfraction; //PARJ(23) /** * The non-Gaussian tails enhancement factor. */ double nGaussfactor; //PARJ(24) /** * Describe a concrete class with persistent data. */ static ClassDescription initLundPtGenerator; /** * Private and non-existent assignment operator. */ - LundPtGenerator & operator=(const LundPtGenerator &); + LundPtGenerator & operator=(const LundPtGenerator &) = delete; }; } namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** * This template specialization informs ThePEG about the base class of * Pythia7::LundPtGenerator. */ template <> struct BaseClassTrait: public ClassTraitsType { /** Typedef of the base class of Pythia7::LundPtGenerator. */ typedef PtGenerator NthBase; }; /** * This template specialization informs ThePEG about the name of the * Pythia7::LundPtGenerator class and the shared object where it is * defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return the class name. */ static string className() { return "Pythia7::LundPtGenerator"; } /** Return the name of the shared library to be loaded to get access * to the Pythia7::LundPtGenerator class and every other class it * uses (except the base class). */ static string library() { return "libP7String.so"; } }; /** @endcond */ } #include "LundPtGenerator.icc" #ifndef PYTHIA7_TEMPLATES_IN_CC_FILE // #include "LundPtGenerator.tcc" #endif #endif /* PYTHIA7_LundPtGenerator_H */ diff --git a/StringFrag/LundZGenerator.h b/StringFrag/LundZGenerator.h --- a/StringFrag/LundZGenerator.h +++ b/StringFrag/LundZGenerator.h @@ -1,328 +1,328 @@ // -*- C++ -*- #ifndef PYTHIA7_LundZGenerator_H #define PYTHIA7_LundZGenerator_H // This is the declaration of the LundZGenerator class. #include "FragConfig.h" // #include "LundZGenerator.fh" // #include "LundZGenerator.xh" #include "ThePEG/Handlers/ZGenerator.h" namespace Pythia7 { /** * The LundZGenerator generates longitudinal scaling variable z of * hadron produced in the Lund string fragmentation scheme, according * to the Lund Symmetric Fragmentation Function, * \f$f(z)=(1/z^{c})(1-z)^{a}exp(-bm_\perp^2/z)\f$, where the \f$a\f$, * \f$b\f$ and \f$c\f$ factors are determined by the setShape() * function. * * For diuark production there is an enhancement of the effective * \f$a\f$ parameter (see deltaDQ). * * A heavy endpoint quark (above c quark) is treated according to the * Bowler modification of the Lund Symmetric fragmentation function. * (see the rQ() method). * * The LundZGenerator inherits all the necessary interfaces from the * ZGenerator class. * * @see \ref LundZGeneratorInterfaces "The interfaces" * defined for LundZGenerator. */ class LundZGenerator: public ThePEG::ZGenerator { public: /** @name Standard constructors and destructors. */ //@{ /** * Default constructor. */ inline LundZGenerator(); /** * Copy-constructor. */ inline LundZGenerator(const LundZGenerator &); /** * Destructor. */ virtual ~LundZGenerator(); //@} public: /** @name Virtual functions mandated by the ZGenerator base class. */ //@{ /** * generate the scaling variable z of hadrons created at each step * of the fragmentation procedure, given the two hadron constituents * \a lastPD leftover at the previous step, and the \a newPD newly * created in the current step and the hadron transverse mass * squared \a mT2. */ virtual double generate(cPDPtr lastPD, cPDPtr newPD, Energy2 mT2) const; /** * Return the default value of the \f$a\f$ parameter of the Lund Symmetric * fragmentation function */ inline double aSym() const; /** * Return the default value of the \f$b\f$ parameter of the Lund * Symmetric fragmentation function */ inline InvEnergy2 bSym() const; //@} public: /** @name Functions used by the persistent I/O system. */ //@{ /** * Function used to write out object persistently. * @param os the persistent output stream written to. */ void persistentOutput(PersistentOStream & os) const; /** * Function used to read in object persistently. * @param is the persistent input stream read from. * @param version the version number of the object when written. */ void persistentInput(PersistentIStream & is, int version); //@} /** * Standard Init function used to initialize the interface. */ static void Init(); protected: /** * Determine the \f$a\f$, \f$b\f$ and \f$c\f$ parameters of the * fragmentation function parametrization, given the flavour content * of the two end-points \a lastPD and \a newPD and the hadron \a * mT2. */ virtual void setShape(cPDPtr lastPD, cPDPtr newPD, Energy2 mT2) const; /** * Return the value of the \f$r_Q\f$ parameter of the Bowler * parametrization given the the heavy quark id number, \a hf. Note * that the same \f$r_Q\f$ value is returned for all \a hf above the * c-quark. */ inline virtual double rQ(long hf) const; protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ inline virtual IBPtr clone() const; /** Make a clone of this object, possibly modifying the cloned object * to make it sane. * @return a pointer to the new object. */ inline virtual IBPtr fullclone() const; //@} protected: /** @name Standard Interfaced functions. */ //@{ /** * Check sanity of the object during the setup phase. */ inline virtual void doupdate(); /** * Initialize this object after the setup phase before saving an * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ inline virtual void doinit(); /** * Finalize this object. Called in the run phase just after a * run has ended. Used eg. to write out statistics. */ inline virtual void dofinish(); //@} private: /** * Return the \f$a\f$ factor of the fragmentation function * parametrization. */ inline double af() const; /** * Return the \f$b m_\perp^2\f$ factor of the fragmentation function * parametrization. */ inline double bf() const; /** * Return the \f$c\f$ factor of the fragmentation function * parametrization. */ inline double cf() const; /** * Return true when \a zm is below the minimal * value for Zmax. */ inline bool smallZmax(double zm) const; /** * Return true when \a zm is above the maximal value for Zmax. */ inline bool largeZmax(double zm) const; /** * Return true when both \a zm and \a bmt2 are large */ inline bool largeZmax(double zm, double bmt2) const; /** * Return true when \f$c\f$ is close to 1. */ inline bool cCloseToOne() const; /** * Return true when \f$c\f$ is close to \f$a\f$. */ inline bool cCloseToA() const; private: /** * The default \f$a\f$ parameter of the Lund Symmetric fragmentation * function */ double asym; // PARJ(41) /** * The default \f$b\f$ parameter of the Lund Symmetric fragmentation * function */ InvEnergy2 bsym; // PARJ(42) /** * The amount by which the effective a\f$a\f$ parameter in the Lund * flavour dependent symmetric fragmentation function is assumed to * be larger than the default \f$a\f$ when diquarks are produced. */ double deltaDQ; // PARJ(45) /** * The value of the \f$r_Q\f$ parameter of the Bowler * parametrization for all quarks heavier than the c-quark. */ double rQc; // PARJ(46) /** * Current value of \f$bm_\perp^2\f$. */ mutable double bmT2; /** * Current value of \f$a\f$. */ mutable double theAf; /** * Current value of \f$c\f$. */ mutable double theCf; /** * Init Interface Description/Map */ static ClassDescription initLundZGenerator; /** * Private and non-existent assignment operator. */ - LundZGenerator & operator=(const LundZGenerator &); + LundZGenerator & operator=(const LundZGenerator &) = delete; }; } namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** * This template specialization informs ThePEG about the base class of * Pythia7::LundZGenerator. */ template <> struct BaseClassTrait: public ClassTraitsType { /** Typedef of the base class of Pythia7::LundZGenerator. */ typedef ZGenerator NthBase; }; /** * This template specialization informs ThePEG about the name of the * Pythia7::LundZGenerator class and the shared object where it is * defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return the class name. */ static string className() { return "Pythia7::LundZGenerator"; } /** * Return the name of the shared library to be loaded to get access * to the Pythia7::LundZGenerator class and every other class it * uses (except the base class). */ static string library() { return "libP7String.so"; } }; /** @endcond */ } #include "LundZGenerator.icc" #ifndef PYTHIA7_TEMPLATES_IN_CC_FILE // #include "LundZGenerator.tcc" #endif #endif /* PYTHIA7_LundZGenerator_H */ diff --git a/StringFrag/StringCollapser.h b/StringFrag/StringCollapser.h --- a/StringFrag/StringCollapser.h +++ b/StringFrag/StringCollapser.h @@ -1,196 +1,196 @@ // -*- C++ -*- #ifndef PYTHIA7_StringCollapser_H #define PYTHIA7_StringCollapser_H // This is the declaration of the StringCollapser class. #include "Pythia7/Config/Pythia7.h" #include "ThePEG/Handlers/ClusterCollapser.h" // #include "StringCollapser.fh" // #include "StringCollapser.xh" namespace Pythia7 { /** * StringCollapser is the class used by the LundFragHandler class to * collapse strings which are deemed too small to fragment into one or * two hadrons. Currently this class does not introduce any * functionality on top the ClusterCollapser base class. * * @see \ref StringCollapserInterfaces "The interfaces" * defined for StringCollapser. */ class StringCollapser: public ClusterCollapser { public: /** @name Standard constructors and destructors. */ //@{ /** * Default constructor. */ inline StringCollapser(); /** * Copy-constructor. */ inline StringCollapser(const StringCollapser &); /** * Destructor. */ virtual ~StringCollapser(); //@} public: /** @name Functions used by the persistent I/O system. */ //@{ /** * Function used to write out object persistently. * @param os the persistent output stream written to. */ void persistentOutput(PersistentOStream & os) const; /** * Function used to read in object persistently. * @param is the persistent input stream read from. * @param version the version number of the object when written. */ void persistentInput(PersistentIStream & is, int version); //@} /** * Standard Init function used to initialize the interfaces. */ static void Init(); protected: protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ inline virtual IBPtr clone() const; /** Make a clone of this object, possibly modifying the cloned object * to make it sane. * @return a pointer to the new object. */ inline virtual IBPtr fullclone() const; //@} protected: protected: /** @name Standard Interfaced functions. */ //@{ /** * Check sanity of the object during the setup phase. */ inline virtual void doupdate(); /** * Initialize this object after the setup phase before saving an * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ inline virtual void doinit(); /** * Initialize this object. Called in the run phase just before * a run begins. */ inline virtual void doinitrun(); /** * Finalize this object. Called in the run phase just after a * run has ended. Used eg. to write out statistics. */ inline virtual void dofinish(); /** * Rebind pointer to other Interfaced objects. Called in the setup phase * after all objects used in an EventGenerator has been cloned so that * the pointers will refer to the cloned objects afterwards. * @param trans a TranslationMap relating the original objects to * their respective clones. * @throws RebindException if no cloned object was found for a given * pointer. */ inline virtual void rebind(const TranslationMap & trans); /** * Return a vector of all pointers to Interfaced objects used in this * object. * @return a vector of pointers. */ inline virtual IVector getReferences(); //@} private: /** * Describe a concrete class with persistent data. */ static ClassDescription initStringCollapser; /** * Private and non-existent assignment operator. */ - StringCollapser & operator=(const StringCollapser &); + StringCollapser & operator=(const StringCollapser &) = delete; }; } namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** * This template specialization informs ThePEG about the base class of * Pythia7::StringCollapser. */ template <> struct BaseClassTrait: public ClassTraitsType { /** Typedef of the base class of Pythia7::StringCollapser. */ typedef ClusterCollapser NthBase; }; /** * This template specialization informs ThePEG about the name of the * Pythia7::StringCollapser class and the shared object where it * is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return the class name. */ static string className() { return "Pythia7::StringCollapser"; } /** * Return the name of the shared library to be loaded to get access * to the Pythia7::StringCollapser class and every other class * it uses (except the base class). */ static string library() { return "libP7String.so"; } }; /** @endcond */ } #include "StringCollapser.icc" #ifndef PYTHIA7_TEMPLATES_IN_CC_FILE // #include "StringCollapser.tcc" #endif #endif /* PYTHIA7_StringCollapser_H */ diff --git a/src/CMSlrnsac.h b/src/CMSlrnsac.h --- a/src/CMSlrnsac.h +++ b/src/CMSlrnsac.h @@ -1,200 +1,200 @@ // -*- C++ -*- #ifndef THEPEG_CMSlrnsac_H #define THEPEG_CMSlrnsac_H // // This is the declaration of the CMSlrnsac class. // #include "ThePEG/Handlers/AnalysisHandler.h" #include "ThePEG/Utilities/CFileLineReader.h" namespace ThePEG { /** * Here is the documentation of the CMSlrnsac class. * * @see \ref CMSlrnsacInterfaces "The interfaces" * defined for CMSlrnsac. */ class CMSlrnsac: public AnalysisHandler { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ CMSlrnsac(); /** * The copy constructor. */ CMSlrnsac(const CMSlrnsac &); /** * The destructor. */ virtual ~CMSlrnsac(); //@} public: /** @name Virtual functions required by the AnalysisHandler class. */ //@{ /** * Analyze the given vector of particles. The default version calls * analyze(tPPtr) for each of the particles. * @param particles the vector of pointers to particles to be analyzed * @param weight the event weight */ virtual void analyze(const tPVector & particles, double weight); //@} /** * Find the correct pt-bin */ static int ptbin(Energy pt) { if ( pt < 1.0*GeV ) return 0; if ( pt < 2.0*GeV ) return 1; if ( pt < 3.0*GeV ) return 2; if ( pt < 4.0*GeV ) return 3; return 4; } /** * Find the correct multiplicity bin. */ static int nchbin(int n) { if ( n < 35 ) return 0; if ( n < 90 ) return 1; if ( n < 110 ) return 2; return 3; } static double nozero(double x) { return x == 0.0? 1.0: x; } public: /** @name Functions used by the persistent I/O system. */ //@{ /** * Function used to write out object persistently. * @param os the persistent output stream written to. */ void persistentOutput(PersistentOStream & os) const; /** * Function used to read in object persistently. * @param is the persistent input stream read from. * @param version the version number of the object when written. */ void persistentInput(PersistentIStream & is, int version); //@} /** * The standard Init function used to initialize the interfaces. * Called exactly once for each class by the class description system * before the main function starts or * when this class is dynamically loaded. */ static void Init(); protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual IBPtr clone() const; /** Make a clone of this object, possibly modifying the cloned object * to make it sane. * @return a pointer to the new object. */ virtual IBPtr fullclone() const; //@} protected: /** @name Standard Interfaced functions. */ //@{ /** * Initialize this object. Called in the run phase just before * a run begins. */ virtual void doinitrun(); /** * Finalize this object. Called in the run phase just after a * run has ended. Used eg. to write out statistics. */ virtual void dofinish(); //@} private: vector< vector > Sphi; vector< vector > Bphi; vector< vector > S2phi; vector< vector > B2phi; vector< vector > S3phi; vector< vector > B3phi; vector< vector > multbin; vector< vector > multbin2; tH2DPtr SMB01; tH2DPtr BMB01; tH2DPtr SMB13; tH2DPtr BMB13; tH2DPtr SHN01; tH2DPtr BHN01; tH2DPtr SHN13; tH2DPtr BHN13; tH2DPtr S2MB01; tH2DPtr B2MB01; tH2DPtr S2MB13; tH2DPtr B2MB13; tH2DPtr S2HN01; tH2DPtr B2HN01; tH2DPtr S2HN13; tH2DPtr B2HN13; tH1DPtr multMB01; tH1DPtr multMB13; tH1DPtr multHN01; tH1DPtr multHN13; vector< vector< vector > > refphi; vector< vector< vector > > refeta; vector refNch04; vector refweight; vector sumrefweight; vector sumweight; tH1DPtr mult; vector bdist; double etamax; int doRweight; string dir; string externalFile; CFileLineReader file; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - CMSlrnsac & operator=(const CMSlrnsac &); + CMSlrnsac & operator=(const CMSlrnsac &) = delete; }; } #endif /* THEPEG_CMSlrnsac_H */