diff --git a/Cascade/AriadneHandler.h b/Cascade/AriadneHandler.h --- a/Cascade/AriadneHandler.h +++ b/Cascade/AriadneHandler.h @@ -1,664 +1,664 @@ // -*- C++ -*- #ifndef Ariadne5_AriadneHandler_H #define Ariadne5_AriadneHandler_H // // This is the declaration of the AriadneHandler class. // #include "Ariadne/Config/Ariadne5.h" #include "ThePEG/Handlers/CascadeHandler.h" #include "ThePEG/StandardModel/AlphaSBase.h" #include "AriadneHandler.fh" #include "History.fh" #include "ReweightBase.fh" #include "DipoleState.fh" #include "EmitterBase.fh" #include "BornCheckerBase.fh" #include "ScaleSetter.fh" #include "DISFinder.fh" #include "QCDDipoleFinder.fh" #include "EMDipoleFinder.fh" #include "ResonanceFinder.fh" #include "History.h" #include "ConsistencyChecker.fh" #include "QCDDipole.fh" #include "EMDipole.fh" #include "Ariadne/Cascade/Models/RemnantModel.fh" #include "Ariadne/Cascade/Models/ColourResonanceModel.fh" #include "ThePEG/Analysis/FactoryBase.h" namespace Ariadne5 { using namespace ThePEG; /** * The AriadneHandler class inherits form the ThePEG::CascadeHandler * base class and implements the Dipole Cascade Model for partonic * cascades. * * @see \ref AriadneHandlerInterfaces "The interfaces" * defined for AriadneHandler. */ class AriadneHandler: public CascadeHandler { public: /** * Enum different options for running \f$\alpha_s\f$. */ enum RunningOption { externalRunning = -1, /**< Use the \f$\alpha_s\f$ specified in the current StandardModel object. */ noRunning = 0, /**< Use a fixed \f$\alpha_s\f$ specified by alpha0(). */ simpleRunning = 1, /**< Use simple leading order running with \f$\Lambda_{QCD}\f$ given by lambdaQCD() */ internalRunning = 2 /**< Use internal AlphaSBase object in theInternalAlphaS for the running. */ }; /** * Enumerate strategies for purging gluons with too small transverse momentum. */ enum PurgeStrategy { onlybefore = -1, /**< Only purge gluons before the cascade. */ onlyafter = -2, /**< Only purge gluons after the cascade. */ neverpurge = 0, /**< Never purge gluons. */ beforeandafter = 1, /**< Purge gluons before and after the cascade. */ everystep = 2 /**< Purge gluons every step. */ }; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ AriadneHandler(); /** * The destructor. */ virtual ~AriadneHandler(); //@} public: /** * The main function to be overwritten by sub-classes. It is called * by handle() after storing some information which is then * available through simple access functions. */ virtual void cascade(); /** * The AriadneHandler can be used inside the process generation to do * so-called CKKW reweighting of the hard sub-process. In this case * this function is called after information about the sub-process is * made available through the LastXCombInfo base class. Only the * function belonging to the primary AriadneHandler for the event to * be generated is called. This default implementation of the function * simply return one. The current sub-process is mixed together with * other processes with a multiplicity of outgoing particles between * \a minMult and \a maxMult. * @throws CKKWMultiplicityException if the minMult > maxMult or if * the number of outgoing particle is outside the specified range. */ virtual double reweightCKKW(int minMult, int maxMult); /** * Check if the particles in the dipole state passes the cuts from * lastXComb. */ bool passCuts(tcDipoleStatePtr state); public: /** @name Functions relating to the running coupling. */ //@{ /** * Strategy for \f$\alpha_S\f$. 0 means constant a constant * \f$\alpha_S\f$ with a value given by alpha0(). 1 means a leading * order running \f$\alpha_S\f$ with a \f$\Lambda_{QCD}\f$ given by * lambdaQCD(). -1 means take whatever is specified in the current * StandardModelBase object. */ inline RunningOption runningCoupling() const { return theRunningCoupling; } /** * The constant \f$\alpha_S\f$ to be used if runningCoupling() is 0. */ inline double alpha0() const { return theAlpha0; } /** * Return the \f$\alpha_S\f$ to be used for the given \a scale. */ double alphaS(Energy2 scale) const; /** * The \f$\Lambda_{QCD}\f$ to use in the one loop running * \f$\alpha_S\f$ if runningCoupling is 1 */ inline Energy lambdaQCD() const { return theLambdaQCD; } /** * An internal \f$\alpha_S\f$ object to be used if runningCoupling() * is internalRunning. */ inline Ptr::const_pointer internalAlphaS() const { return theInternalAlphaS; }; /** * Return the flavour thresholds used in calculating \f$\alpha_S\f$. */ inline const set & flavourThresholds() const { return theFlavourThresholds; } /** * The constant \f$\alpha_{EM}\f$ to be used. If zero, use whatever * is specified in the current StandardModelBase object. */ inline double alphaEM0() const { return theAlphaEM0; } /** * The number of different colour indices available to dipoles. */ inline int nCol() const { return theNCol; } /** * The number of possible flavours in a \f$g\to q\bar{q}\f$ splitting. */ inline int nFlav() const { return theNFlav; } //@} /** * Check if photon emission are switched on or off. */ inline bool photonEmissions() const { return thePhotonEmissions; } public: /** * Calculate the starting scale for the given DipoleState. */ Energy startingScale(const DipoleState & state) const; /** * If DIS-like scattered leptons are found in the given SubProcess, * return properly setup corresponding hard remnants. The * remnants will belong to the given DipoleState. */ pair findDISLeptons(SubProcess & sub, DipoleState & state) const; /** * If findDISLeptons() has found scattered leptons, find also the * scattered quarks in the SubProcess and return them as hard * remnants. The remnants will belong to the given DipoleState. */ pair findDISQuarks(pair leptons, SubProcess & sub, DipoleState & state) const; /** * Return a list of intermediate s-channel resonances in the given * SubProcess. Resonances which have decayed into further resonances * will come before their children in the list. */ tPVector resonances(SubProcess & sub) const; /** * Return the object responsible for radiating from decay products * from coloured resonances. */ tColourResonanceModelPtr colourResonanceModel() const { return theColourResonanceModel; } /** * Return the object responsible for radiating from remnants. */ const RemnantModel & remnantModel() const { return *theRemnantModel; } /** * Find, create and return the QCD dipoles in the given * DipoleState. */ vector findQCDDipoles(DipoleState & state) const; /** * Find, create and return the electro-magnetic dipoles in the given * DipoleState. */ vector findEMDipoles(DipoleState & state) const; /** * Check the given DipoleState for consistency. */ bool checkState(DipoleState &, tcEmPtr = tEmPtr()); /** * The cutoff in invariant transverse momentum for QCD emissions. */ inline Energy pTCut() const { return thePTCut; } /** * The cutoff in invariant transverse momentum for QED emissions. */ inline Energy pTCutEM() const { return thePTCutEM; } /** * The inverse extension of a hadron remnant. */ inline Energy softMu() const { return theSoftMu; } /** * The dimension assumed for the extension of a hadron remnant. */ inline double softAlpha() const { return theSoftAlpha; } /** * The dimension assumed for the extension of a perturbative remnant. */ inline double hardAlpha() const { return theHardAlpha >= 0? theHardAlpha: softAlpha(); } /** * The power in the suppression of radiation from extended dipoles. */ inline double beta() const { return theBeta; } /** * Get the strategy for purging gluons with too small transverse momentum. */ inline PurgeStrategy purgeStrategy() const { return thePurgeStrategy; } /** * Get the factor used to determine how far below the cutoff a gluon may be before it is purged. */ inline double purgeFactor() const { return thePurgeFactor; } /** * Return the vector of available reweighting objects. */ inline const vector & reweighters() const { return theReweighters; } /** * The maximum number of allowed emission in the cascade. */ inline int maxEmissions() const { return theMaxEmissions; } /** * Return the vector of available emitter objects. */ inline const vector & emitters() const { return theEmitters; } /** * Check if the given dipole state corresponds to a valid * Born-level state in a CKKW-L merging and return the scale * associated with that state. If not return the negative of the * scale associated with the state. */ Energy checkBornState(const DipoleState &) const; /** * Check if the given dipole state corresponds to a valid state from * a matrix element generator in a CKKW-L merging. */ bool checkTreeState(const DipoleState &) 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); //@} /** * 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(); public: /** * Exception class used if the outgoing multiplicity is out of range * or the maximum multiplicity is larger than the minimum in * reweightCKKW. */ struct CKKWMultiplicityException: Exception {}; /** * Exception class used if no reasonable state was reconstructed in * the CKKW-L algorithm. */ struct CKKWBornException: Exception {}; /** * Exception class used if the dipole state is not self consistant at * any stage of the cascade. */ struct IntegretyException: Exception {}; /** * Exception class indicating no model could be found when requested. */ struct MissingModel: public Exception {}; 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 after the setup phase before saving an * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ virtual void doinit(); /** * Initialize this object. Called in the run phase just before * a run begins. */ virtual void doinitrun(); /** * Return true if this object needs to be initialized before all * other objects because it needs to extract PDFs from the event * file. This version will return true if runningCoupling() returns * internalRunning and no internalAlphaS() object has been given. */ virtual bool preInitialize() const; //@} private: /** * Function used by the interface. */ Energy minPTCut() const; /** * Function used by the interface. */ Energy maxLambdaQCD() const; private: /** * Strategy for \f$\alpha_S\f$. 0 means constant a constant * \f$\alpha_S\f$ with a value given by alpha0(). 1 means a leading * order running \f$\alpha_S\f$ with a \f$\Lambda_{QCD}\f$ given by * lambdaQCD(). -1 means take whatever is specified in the current * StandardModelBase object. */ RunningOption theRunningCoupling; /** * The constant \f$\alpha_S\f$ to be used if runningCoupling() is * noRunning. */ double theAlpha0; /** * The \f$\Lambda_{QCD}\f$ to use in the one loop running * \f$\alpha_S\f$ if runningCoupling is simpleRunning. */ Energy theLambdaQCD; /** * An internal \f$\alpha_S\f$ object to be used if runningCoupling() * is internalRunning. */ Ptr::pointer theInternalAlphaS; /** * Scale factor used to multiply the emission scales in the argument * of \f$\alpha_S\f$. */ double scaleFactor; /** * The flavour thresholds used in calculating \f$\alpha_S\f$. */ set theFlavourThresholds; /** * The cutoff in invariant transverse momentum for QCD emissions. */ Energy thePTCut; /** * The constant \f$\alpha_{EM}\f$ to be used. If zero, use whatever * is specified in the current StandardModelBase object. */ double theAlphaEM0; /** * The cutoff in invariant transverse momentum for QED emissions. */ Energy thePTCutEM; /** * The number of different colour indices available to dipoles. */ int theNCol; /** * The number of possible flavours in a \f$g\to q\bar{q}\f$ splitting. */ int theNFlav; /** * Switch to turn on and off photon emission in the cascade. */ bool thePhotonEmissions; /** * The inverse extension of a hadron remnant. */ Energy theSoftMu; /** * The dimension assumed for the extension of a hadron remnant. */ double theSoftAlpha; /** * The dimension assumed for the extension of a hard remnant. */ double theHardAlpha; /** * The power in the suppression of radiation from extended dipoles. */ double theBeta; /** * A list of reweighting objects which may be applied to dipole * emissions. */ vector theReweighters; /** * The maximum number of emissions allowed in the cascade. */ int theMaxEmissions; /** * The vector of EmittorBase objects responsible for generating and * performing emissions according to the Dipole Cascade Model and * its extentions. */ vector theEmitters; /** * A vector of BornCheckerBase objects which are used in the CKKW-L * algorithm. */ vector theBornCheckers; /** * The object responsible for choosing the starting scale of the * shower. */ ScaleSetterPtr theScaleSetter; /** * The object responsible for identifying DIS-like event. */ DISFinderPtr theDISFinder; /** * The object responsible for identifying DIS-like event. */ ResonanceFinderPtr theResonanceFinder; /** * The Object responsible for identifying QCD Diploles. */ QCDFinderPtr theQCDFinder; /** * The Object responsible for identifying electro-magnetic Diploles. */ EMFinderPtr theEMFinder; /** * The object responsible for radiating from decay products from * coloured resonances. */ ColourResonanceModelPtr theColourResonanceModel; /** * The object responsible for radiating from remnants. */ RemnantModelPtr theRemnantModel; /** * The object responsible for checking the consistency of a DipoleState. */ CCheckPtr consistency; /** * If set true, the consistencyh checking of emissions in this * dipole state is suspended as the initial state was not * consistent. */ bool suspendConsistencyChecks; /** * The strategy for purging gluons with too small transverse momentum. */ PurgeStrategy thePurgeStrategy; /** * The factor used to determine how far below the cutoff a gluon may be before it is purged. */ double thePurgeFactor; /** * A map containing the states generated by reweight CKKW. The map * assiciates an XComb to a struct containing the dipole state, the * the clustering History and a boolean which specifies if the state * has the maximum parton multiplicity or not. */ struct CKKWState { HistoryPtr history; LorentzRotation rotation; bool maxMult; }; map theCKKWMap; private: /** * Histograms for debugging purposes. */ FactoryBase::tH1DPtr histswing, histall, histglue, histqq, histlam; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - AriadneHandler & operator=(const AriadneHandler &); + AriadneHandler & operator=(const AriadneHandler &) = delete; }; } #endif /* Ariadne5_AriadneHandler_H */ diff --git a/Cascade/BornCheckerBase.h b/Cascade/BornCheckerBase.h --- a/Cascade/BornCheckerBase.h +++ b/Cascade/BornCheckerBase.h @@ -1,92 +1,92 @@ // -*- C++ -*- #ifndef Ariadne5_BornCheckerBase_H #define Ariadne5_BornCheckerBase_H // // This is the declaration of the BornCheckerBase class. // #include "ThePEG/Interface/Interfaced.h" #include "BornCheckerBase.fh" #include "DipoleState.fh" namespace Ariadne5 { using namespace ThePEG; /** * The BornCheckerBase is the base class for any class implementing * the checking of a DipoleState reclustered in the CKKW-L algorithm, * to make sure it corresponds to a reasonable Born-level state (the * lowest jet-multiplicity state in a CKKW-L merging). * * @see \ref BornCheckerBaseInterfaces "The interfaces" * defined for BornCheckerBase. */ class BornCheckerBase: public Interfaced { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ BornCheckerBase(); /** * The destructor. */ virtual ~BornCheckerBase(); //@} public: /** @name Virtual functions to be overidden in sub-classes. */ //@{ /** * If the given state corresponds to a valid Born-level, minimum * jet-multiplicity in a CKKW-L merging, return the factorization * scale associated with that state. If the given state does not * correspond to a Born-level state, return the the factorization * scale, but with a minus sign. If the given state is completely * unknown return zero. The factorization scale should be the one * normally used when Ariadne is run non-merged. */ virtual Energy check(const DipoleState &) const = 0; /** * If the given state corresponds to a valid state from a matrix * element generator in a CKKW-L merging return true. */ virtual bool checkTree(const DipoleState &) const = 0; //@} public: /** * 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(); // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - BornCheckerBase & operator=(const BornCheckerBase &); + BornCheckerBase & operator=(const BornCheckerBase &) = delete; }; } #endif /* Ariadne5_BornCheckerBase_H */ diff --git a/Cascade/CascadeBase.h b/Cascade/CascadeBase.h --- a/Cascade/CascadeBase.h +++ b/Cascade/CascadeBase.h @@ -1,172 +1,172 @@ // -*- C++ -*- #ifndef Ariadne5_CascadeBase_H #define Ariadne5_CascadeBase_H // // This is the declaration of the CascadeBase class. // #include "Ariadne/Config/Ariadne5.h" #include "Ariadne/Config/CloneBase.h" #include "CascadeBase.fh" #include "DipoleState.fh" #include "AriadneHandler.fh" #include "ThePEG/Utilities/Current.h" namespace Ariadne5 { /** * CascadeBase is the base class of all Partons, Dipoles and * DipoleState classes in the Ariadne dipole cascade classes. It keeps * track of the DioleState to which an object belongs. */ class CascadeBase: public CloneBase { public: /** * The DipoleState is a friend. */ friend class DipoleState; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor has an optional pointer to the * CascadeHandler in charge as argument. */ inline CascadeBase(): isTouched(true) {} /** * The destructor. */ inline virtual ~CascadeBase() {} //@} public: /** @name Functions relating to the DipoleState and CascadeHandler * to which this belongs. */ //@{ /** * Get the Ariadne::AriadneHandler in charge of the current generation. */ inline tHandlerPtr handler() const { return Current::ptr(); } /** * Get the DipoleState to which this Object belongs. */ inline tDipoleStatePtr state() const { return theState; } protected: /** * Set the DipoleState to which this Dipole belongs. */ inline void state(tDipoleStatePtr ds) { theState= ds; } /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} public: /** @name Functions determining if the object has been changed since the last generation. */ //@{ /** * If true, this object has been modified since the last round of * generating emissions. */ inline bool touched() const { return isTouched; } /** * Signal that this object has been modified. */ inline void touch() { isTouched = true; } /** * Signal that all possible emissions involving this object has been * generated. */ inline void untouch() { isTouched = false; } //@} 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(); private: /** * The DipoleState to which this Dipole belongs. */ tDipoleStatePtr theState; /** * If true, this object has been modified since the last round of * generating emissions. */ bool isTouched; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - CascadeBase & operator=(const CascadeBase &); + CascadeBase & operator=(const CascadeBase &) = delete; }; } #endif /* Ariadne5_CascadeBase_H */ diff --git a/Cascade/ConsistencyChecker.h b/Cascade/ConsistencyChecker.h --- a/Cascade/ConsistencyChecker.h +++ b/Cascade/ConsistencyChecker.h @@ -1,191 +1,191 @@ // -*- C++ -*- #ifndef Ariadne5_ConsistencyChecker_H #define Ariadne5_ConsistencyChecker_H // // This is the declaration of the ConsistencyChecker class. // #include "ThePEG/Handlers/HandlerBase.h" #include "DipoleState.fh" #include "Emission.fh" #include "Parton.fh" namespace Ariadne5 { using namespace ThePEG; /** * The ConsistencyChecker class is used by the AriadneHandler to check * a DipoleState for consistency. The check is done on the initial * DipoleState, and then after each Emission, to veto any emission * which gives an inconsistent state. If the initial DipoleState is * inconsistent, the whole event may be vetoed, otherwise further * checking is suspended. This base class optionally checks that all * gluons have an invariant transverse momentum above the cutoff and * that all stings are large enough to be able to produce a minimum * set of hadrons. Sub-classes may introduce further checks. * * @see \ref ConsistencyCheckerInterfaces "The interfaces" * defined for ConsistencyChecker. */ class ConsistencyChecker: public HandlerBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ ConsistencyChecker(): vetoInitial(true), tryFixing(false), checkGluonPT(false), checkStrings(false) {} /** * The destructor. */ virtual ~ConsistencyChecker(); //@} protected: /** * The main virtual function. Returns true if the given DipoleState * is consistent. The initial DipoleState is called with the * Emission pointer set to null. */ virtual bool isConsistent(const DipoleState &, tcEmPtr) const; /** * If the initial state is inconsistent but not vetoed, this * function may be implemented to possibly fix the state to become * consistent. Return false if it could not be fixed. */ virtual bool fixme(DipoleState &) const { return false; } public: /** * The function which is called by the AriadneHandler. Forwards the * call to isConsistent() and, in case of the initial DipoleState, * optionally vetoes the whole event. */ bool check(DipoleState & state, tcEmPtr emission) const { if ( isConsistent(state, emission) ) return true; if ( !emission && tryFixing && fixme(state) ) return true; if ( !emission && vetoInitial ) throw Veto(); return false; } protected: /** * Returns true if all gluon have an invariant transverse momentum * above the cutoff. */ bool gluonPT(const DipoleState &) const; /** * Returns false if a gluon \a p2 has an invariant transverse * momentum below \a pt2cut w.r.t. \a p1 and \a p3. If none of the * partons have been touched or any of the partons are failsafe, no * check is done and true is returned. */ bool gluonPT(tcParPtr p1, tcParPtr p2, tcParPtr p3, Energy2 pt2cut) const; /** * Returns true if all remnants are consistent. */ bool remnantPhaseSpace(const DipoleState & state) const; /** * Returns true if all strings have large enough mass. */ bool strings(const DipoleState &) 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); //@} /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * If true, an event is vetoed if the initial DipoleState is * inconsistent. */ bool vetoInitial; /** * If true, a broken state may be fixed by subclasses. */ bool tryFixing; /** * If true, all gluons are required to have an invariant transverse * momentum above the cutoff. */ bool checkGluonPT; /** * If true, all strings are required to have an invariant mass big * enough to produce a minimum set of hadrons. */ bool checkStrings; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ConsistencyChecker & operator=(const ConsistencyChecker &); + ConsistencyChecker & operator=(const ConsistencyChecker &) = delete; }; } #endif /* Ariadne5_ConsistencyChecker_H */ diff --git a/Cascade/DISFinder.h b/Cascade/DISFinder.h --- a/Cascade/DISFinder.h +++ b/Cascade/DISFinder.h @@ -1,150 +1,150 @@ // -*- C++ -*- #ifndef Ariadne5_DISFinder_H #define Ariadne5_DISFinder_H // // This is the declaration of the DISFinder class. // #include "ThePEG/Handlers/HandlerBase.h" #include "DipoleState.fh" #include "RemnantParton.fh" #include "DISFinder.fh" namespace Ariadne5 { using namespace ThePEG; /** * The DISFinder class is responsible for finding DIS-type scattered * leptons in a SubProcess. This base class only looks at the * mother-daughter relationships in the SubProcess. The case where * these relationships are not available is treated very crudely and * more sophisticated methods may implemented in sub-classes. * * @see \ref DISFinderInterfaces "The interfaces" * defined for DISFinder. */ class DISFinder: public HandlerBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ DISFinder(); /** * The destructor. */ virtual ~DISFinder(); //@} public: /** @name Main virtual function. */ //@{ /** * If DIS-like scattered leptons are found in the given SubProcess, * return properly setup corresponding hard remnants. The * DipoleState is supplied to allow for proper creation of * RemnantParton objects. */ virtual pair findDISLeptons(SubProcess &, DipoleState &) const; /** * If findDISLeptons() has found scattered leptons, find also the * scattered quarks in the SubProcess and return them as hard * remnants. The DipoleState is supplied to allow for proper * creation of RemnantParton objects. */ virtual pair findDISQuarks(pair leptons, SubProcess &, DipoleState &) const; //@} protected: /** @name Additional helper function. */ //@{ /** * Check if the given particle is a t-channel electro-weak boson. */ bool virtualBoson(tPPtr) const; /** * Return the scattered lepton and virtual boson in a SubProcess if * the given \a incoming particle is a lepton. */ virtual pair getScattered(tPPtr incoming, SubProcess & sub) const; /** * Create and setup a remnant given the incoming and scattered * lepton, and the boson (if found). The DipoleState is supplied to * allow for proper creation of RemnantParton objects. */ virtual tRemParPtr createRemnant(tPPtr inc, tPPtr lep, tPPtr bos, DipoleState & state) const; /** * Find the quark in a SubProcess corresponding to the scattered \a * lepton. */ virtual tPPtr getQuark(tRemParPtr lepton, SubProcess & sub) const; /** * Create a hard remnant corresponding to the scattered \a quark, * given a scattered \a lepton. The DipoleState is supplied to * allow for proper creation of RemnantParton objects. */ tRemParPtr createQuarkRemnant(tRemParPtr lepton, tPPtr quark, DipoleState & state) const; //@} public: /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - DISFinder & operator=(const DISFinder &); + DISFinder & operator=(const DISFinder &) = delete; }; } #endif /* Ariadne5_DISFinder_H */ diff --git a/Cascade/DipoleBase.h b/Cascade/DipoleBase.h --- a/Cascade/DipoleBase.h +++ b/Cascade/DipoleBase.h @@ -1,110 +1,110 @@ // -*- C++ -*- #ifndef Ariadne5_DipoleBase_H #define Ariadne5_DipoleBase_H // // This is the declaration of the DipoleBase class. // #include "CascadeBase.h" #include "DipoleBase.fh" namespace Ariadne5 { using namespace ThePEG; /** * DipoleBase is the base class of all Dipole classes used in the * Dipole Cascade Model and its extensions. Currently it does not * introduce any functionality. */ class DipoleBase: public CascadeBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ DipoleBase() {} /** * The destructor. */ virtual ~DipoleBase() {} //@} public: /** * Get (or create and return) the colour line corresponding * corresponding to this dipole, if present. Is only meaningful if * Parton::produceParticle() has been called for the connected * partons. The colour line should be properly connected to the * produced particle. */ virtual ColinePtr colourLine() const; /** * The cutoff scale for this dipole. */ Energy rhoCut() const { return theRhoCut; } 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); //@} /** * Check the integrity of this dipole. Return false if error is * found. */ virtual bool checkIntegrity(); public: /** * 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: /** * The cutoff scale for this dipole. To be set by sub-classes on * construction. */ Energy theRhoCut; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - DipoleBase & operator=(const DipoleBase &); + DipoleBase & operator=(const DipoleBase &) = delete; }; } #endif /* ARIADNE_DipoleBase_H */ diff --git a/Cascade/DipoleState.h b/Cascade/DipoleState.h --- a/Cascade/DipoleState.h +++ b/Cascade/DipoleState.h @@ -1,623 +1,623 @@ // -*- C++ -*- #ifndef Ariadne5_DipoleState_H #define Ariadne5_DipoleState_H // // This is the declaration of the DipoleState class. // #include "Ariadne/Cascade/CascadeBase.h" #include "DipoleState.fh" #include "DipoleBase.h" #include "Parton.h" #include "EmissionGenerator.h" #include "Emission.h" #include "RemnantParton.h" #include "Resonance.fh" #include "ThePEG/Utilities/ObjectIndexer.h" namespace Ariadne5 { using namespace ThePEG; /** * The DipoleState class describes a complete state of partons and * dipoles in a Ariadne cascade at a given stage of the process. */ class DipoleState: public CascadeBase { public: /** * A vector of CascadeBase pointers. */ typedef set BaseSet; /** * A set of dipole pointers. */ typedef list DipoleSet; /** * The SaveDipoleState helper class is a friend. */ friend class SaveDipoleState; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. Optional argument is the incoming * particles to the collision. */ DipoleState(tPPair inc = tPPair()); /** * The destructor. */ virtual ~DipoleState(); //@} public: /** * Setup this DipoleState from a SubProcess. */ void setup(SubProcess &); /** * Setup this DipoleState from a simple set of final-state particles */ void setup(const set &); /** * Select a dipole. Go through the list of active DipoleBase objects * and tell them to calculate the scale of the next emission and * select the Emitter with largest transverse momentum. Subsequent * calls to selected() will return the selected dipole. * * @param rhomin the minimum allowed evolution scale. * * @param pt2max the maximum allowed evolution scale. * * @return the generated evolution scale. If less that rhomin, no * emission was generated and subsequent calls to selected() will * return null. */ Energy select(Energy rhomin, Energy rhomax); /** * Perform an emission. * * @return false if no emission was possible. */ bool perform(); /** * After the cascade is done, fill the produced partons in the * supplied Step. */ void fill(Step &) const; /** @name Simple access functions. */ //@{ /** * The next Emission */ inline tEmPtr selected() const { return theSelected; } /** * Set the next Emission. */ inline void selected(const tEmPtr & x) { theSelected = x; } /** * The number of emissions made from this state so far. */ inline int nEmissions() const { return theNe; } /** * Return the colliding particles if present. */ tPPair incoming() const { return theIncoming; } /** * Return the final-state partons. This includes all final-state * particles, also remnants. */ const set & finalState() const { return theFinalState; } /** * Add a parton to the final state. */ void addFS(tParPtr p) { theFinalState.insert(p); } /** * Add a parton to the hard final state. */ void addHardFS(tParPtr p) { theHardFinalState.insert(p); addFS(p); } /** * Add a parton to the hadronic final state. */ void addHadronicFS(tParPtr p) { theHadronicFinalState.insert(p); addHardFS(p); } /** * Remove the given parton from the final state and forget it ever * existed. */ void forgetParton(tParPtr p); /** * Remove the given dipole from the active dipoles and forget it ever * existed. */ void forgetDipole(tDBPtr d); /** * Return the partons in the hard final state. Returns finalState() * excluding all soft remnants. */ const set & hardFS() const { return theHardFinalState; } /** * Return the partons in the hadronic final state excluding all soft * and non-coloured remnants. */ const set & hadronicFS() const { return theHadronicFinalState; } /** * Return the remnants. Are a subset of theFinalState */ const pair< vector, vector > & remnants() const { return theRemnants; } /** * Return the set of active dipoles. */ const set & activeDipoles() const { return active; } /** * Return massive resonances. */ const vector & resonances() const { return theResonances; } //@} public: /** @name Functions relating to the book-keeping of included objects. */ //@{ /** * Create a new object to be included in this DipoleState. */ template inline typename Ptr::pointer create() { typedef typename Ptr::pointer PTR; PTR obj = ptr_new(); objects.insert(objects.end(), obj); obj->state(this); if ( tDBPtr d = dynamic_ptr_cast(obj) ) { active.insert(d); dipindx(d); } if ( tParPtr p = dynamic_ptr_cast(obj) ) parindx(p); return obj; } /** * Create a Parton of the given type \a pd. Optionally inherit the * system properties of the \a parent parton and insert in the * hadronic final state if \a hfs is true. */ tParPtr create(tcPDPtr pd, tcParPtr parent = tcParPtr(), bool hfs = true); /** * Remove a Parton from the final state. (The parton will still * exist in the DipoleState). */ void remove(tParPtr p) { theFinalState.erase(p); theHardFinalState.erase(p); theHadronicFinalState.erase(p); } /** * Clone this DipoleState. Also cloning all included objects and fixing up * their inter-dependence. */ DipoleStatePtr fullclone() const; /** * Clone this DipoleState. Also clone all included objects but do * not fix up their inter-dependence, ie. the cloned objects in the * new DipoleState may still point to objects in the this. Before * the new DipoleState can be used, its postclone() function must * be called with the \a trans object as argument. The \a trans * object will contain the translation map between the objects in * the old and new DipoleState. */ DipoleStatePtr preclone(TranslationMap & trans) const; /** * Fix up the inter-dependence among the included objects in this * DipoleState which was produced by the preclone() function. The * same \a trans object which was used in the preclone() call must * be given here as argument. */ void postclone(const TranslationMap & trans) const; //@} public: /** * Calculate the total momentum of the dipole state. */ const Lorentz5Momentum & sumTotalMomentum(); /** * Return the total momentum of the dipole state. This is * recalculated after each emission. */ const Lorentz5Momentum & totalMomentum() const { return theTotalMomentum; } /** * Calculate the total momentum of the hardFinalState(). */ const Lorentz5Momentum & sumHardMomentum(); /** * Return the total momentum of the hardFS(). This is * recalculated after each emission. */ const Lorentz5Momentum & hardMomentum() const { return theHardMomentum; } /** * Return the total momentum of the hadronicFS(). This is * recalculated after each emission. */ const Lorentz5Momentum & hadronicMomentum() const { return theHadronicMomentum; } /** * Return the total sting length in terms of the lambda measure * using the given scale. */ pair lambdaMeasure(Energy2 scale = 1.0*GeV2) const; /** * Return thenumber of dipoles which stretches across the 0-rapidity line. */ int crossings() const; /** * Return the number of gluons below cutoff (for debugging). */ int gluonsBelow() const; /** * Return the length in true rapidity of all stings divided by the * total rapidity span of the state (for debugging). */ double folding() const; /** * Transform the hadronicFS(). */ void transformHadronicState(const LorentzRotation & R); /** * Touch all remnants to indicate that the hadronicFS() has changed * collectively. */ void touchHadronicState(); /** * Untouch all remnants to indicate that the hadronicFS() has * reverted collectively. */ void untouchHadronicState(); /** * Print out debugging information on std::cerr. */ virtual void debugme() const; /** * Print out more debugging information on std::cerr. */ void debugEmissions() const; /** * Check integrity of all dipoles. Return false if error is * found. */ bool checkIntegrity(); /** * Create and return an index for the given object. Only used in for * debugging. */ int index(tcCascadeBasePtr o) const; /** * For the given particle set, remove all particles that have * decayed and replace them with their children. */ static void fixupDecays(set & out); /** * Purge all gluons with transvese momentum less that the given cut. */ void purgeGluons(Energy cut); /** * Purge the outgoing gluon in the given dipole. */ void purgeGluon(QCDDipole & d); /** * For the given particle insert recursively all undecayed decay * products in the given vector. */ static bool addChildren(tPVector & v, tPPtr p); public: /** * Trace a dipole to find (a piece of) string. */ static pair StringEnds(tcQCDPtr); protected: /** @name The virtual functions to be overridden in sub-classes. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual ClonePtr clone() const; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} 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(); private: /** * The SubProcess from which this state was created (may be null). */ tSubProPtr subprocess; /** * The colliding particles in the SubProcess or 0 if none was * present. */ tPPair theIncoming; /** * The set of all diferent objects belonging to this state. */ BaseSet objects; /** * The final state partons. */ set theFinalState; /** * The hard final state partons, excluding all soft remnants. */ set theHardFinalState; /** * The hadronic final state, excluding all soft and non-coloured * remnants. */ set theHadronicFinalState; /** * The remnants. Are a subset of theFinalState */ pair< vector, vector > theRemnants; /** * The massive resonances. */ vector theResonances; /** * The total momentum of this state. */ Lorentz5Momentum theTotalMomentum; /** * The total momentum of the hardFS(). */ Lorentz5Momentum theHardMomentum; /** * The total momentum of the hadronicFS(). */ Lorentz5Momentum theHadronicMomentum; /** * The active Dipoles. */ set active; /** * The set of EmissionGenerators corresponding to the dipoles * included in this state. */ set generators; /** * The number of emissions made in this state. */ int theNe; /** * The Emitter selected to perform the next emission. */ EmPtr theSelected; /** * The list of emissions treated in this DipoleState. */ vector emissions; /** * Keep track of indices for debugging purposes. */ mutable ObjectIndexer dipindx; /** * Keep track of indices for debugging purposes. */ mutable ObjectIndexer parindx; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - DipoleState & operator=(const DipoleState &); + DipoleState & operator=(const DipoleState &) = delete; public: /** @cond EXCEPTIONCLASSES */ /** Exception class used by DipoleState if four momentum is * not conserved. */ class MomentumException: public Exception {}; /** Exception class used by DipoleState if the SubProcess was * querried when none was available. */ class SubProcessException: public Exception {}; /** @endcond */ }; /** * Helper class to be able to revert changes made to a DipoleState. */ class SaveDipoleState { public: /** * The constructor taking a pointer to the \a state to be saved. If * necessary (or if \a force is true) the state will be cloned. */ SaveDipoleState(tDipoleStatePtr state, bool force = false); /** * Return the translation map relating the objects in the original * state with the ones in the backup state. */ const DipoleState::TranslationMap & translationMap() const { return trans; } /** * Return a copy of the original state. */ tDipoleStatePtr revert(); private: /** * The backup state. */ DipoleStatePtr backup; /** * The translation map relating the objects in the original state * with the ones in the backup state. */ DipoleState::TranslationMap trans; /** * Flag to indicate that precloning was forced. */ bool forced; }; } #endif /* Ariadne5_DipoleState_H */ diff --git a/Cascade/EMDipole.h b/Cascade/EMDipole.h --- a/Cascade/EMDipole.h +++ b/Cascade/EMDipole.h @@ -1,180 +1,180 @@ // -*- C++ -*- #ifndef Ariadne5_EMDipole_H #define Ariadne5_EMDipole_H // // This is the declaration of the EMDipole class. // #include "DipoleBase.h" #include "EMDipole.fh" #include "Parton.fh" namespace Ariadne5 { using namespace ThePEG; /** * The EMDipole class represents electromagnetic dipoles between partons. */ class EMDipole: public DipoleBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ EMDipole(); /** * The destructor. */ virtual ~EMDipole() {} //@} protected: /** @name Functions relating to the DipoleState to which this belongs. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual ClonePtr clone() const; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointer to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} 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(); public: /** @name Simple access functions. */ //@{ /** * The first parton in this dipole. */ inline tParPtr iPart() const { return theIPart; } /** * The second parton in this dipole. */ inline tParPtr oPart() const { return theOPart; } /** * Set the first parton in this dipole. */ inline void iPart(tParPtr x) { theIPart = x; } /** * Set the second parton in this dipole. */ inline void oPart(tParPtr x) { theOPart = x; } /** * Return the squared invariant mass of this dipole. */ Energy2 sdip() const; /** * The sub system index for which the decay products of this * resonance belong. */ int system() const { return theSystem; } /** * Set the sub system index for which the decay products of this * resonance belong. */ void system(int isys) { theSystem = isys; } //@} private: /** * The first parton in this dipole. */ tParPtr theIPart; /** * The second parton in this dipole. */ tParPtr theOPart; /** * The sub system index for which the decay products of this * resonance belong. */ int theSystem; public: /** * Print out debugging information on std::cerr. */ virtual void debugme() const; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - EMDipole & operator=(const EMDipole &); + EMDipole & operator=(const EMDipole &) = delete; }; } #endif /* Ariadne5_EMDipole_H */ diff --git a/Cascade/EMDipoleFinder.h b/Cascade/EMDipoleFinder.h --- a/Cascade/EMDipoleFinder.h +++ b/Cascade/EMDipoleFinder.h @@ -1,110 +1,110 @@ // -*- C++ -*- #ifndef Ariadne5_EMDipoleFinder_H #define Ariadne5_EMDipoleFinder_H // // This is the declaration of the EMDipoleFinder class. // #include "ThePEG/Handlers/HandlerBase.h" #include "EMDipoleFinder.fh" #include "EMDipole.fh" #include "DipoleState.fh" namespace Ariadne5 { using namespace ThePEG; /** * The EMDipoleFinder class and its sub-classes are responsible for * identifying and introducing of electro-magnetic dipoles in the * setup phase of a given DipoleState. * * @see \ref EMDipoleFinderInterfaces "The interfaces" * defined for EMDipoleFinder. */ class EMDipoleFinder: public HandlerBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ EMDipoleFinder(); /** * The destructor. */ virtual ~EMDipoleFinder(); //@} public: /** * Find, create and return the electro-magnetic dipoles in the given * DipoleState. */ virtual vector findDipoles(DipoleState &) 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); //@} /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - EMDipoleFinder & operator=(const EMDipoleFinder &); + EMDipoleFinder & operator=(const EMDipoleFinder &) = delete; }; } #endif /* Ariadne5_EMDipoleFinder_H */ diff --git a/Cascade/Emission.h b/Cascade/Emission.h --- a/Cascade/Emission.h +++ b/Cascade/Emission.h @@ -1,308 +1,308 @@ // -*- C++ -*- #ifndef Ariadne5_Emission_H #define Ariadne5_Emission_H // // This is the declaration of the Emission class. // #include "Ariadne/Config/Ariadne5.h" #include "Ariadne/Config/CloneBase.h" #include "Emission.fh" #include "EmitterBase.fh" #include "DipoleBase.fh" #include "Parton.fh" #include "ThePEG/Utilities/Triplet.h" namespace Ariadne5 { /** * Emission is the base class to be used by all sub-classes of * EmissionModel to specify a generated emission for an Emitter. */ class Emission: public CloneBase { public: /** Convenient typedef. */ typedef Triplet Trip; /** * Enum giving the state of this Emission. */ enum State { generated, /**< This Emission has been created but not yet performed. */ performed, /**< This Emission has been performed. */ reverted /**< This Emission has been performed but then reverted. */ }; public: /** @name Standard constructors and destructors. */ //@{ /** * The only relevant constructor. */ Emission(const EmitterBase & inmodel, const DipoleBase & indipole) : state(generated), emno(0), geno(0), model(&inmodel), cdipole(&indipole), rho(ZERO), y(0.0), ymax(-1.0), orderAlphaS(1), orderAlphaEW(0), prob(-1.0), weightPDF(-1.0), reversible(true), failsafe(false) {} /** * The deault constructor should not normally be used. */ Emission(): state(generated), emno(0), geno(0), rho(ZERO), y(0.0), ymax(-1.0), orderAlphaS(0), orderAlphaEW(0), prob(-1.0), weightPDF(-1.0), reversible(false), failsafe(false) {} /** * The destructor. */ virtual ~Emission() {} //@} public: /** @name Functions relating to the DipoleState and CascadeHandler * to which this belongs. */ //@{ /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} public: /** * Perform this emission. */ bool perform() const; /** * Revert this emission if it for some reason failed. */ void revert() const; /** * The State of this Emission */ mutable State state; /** * The emission number */ mutable int emno; /** * The generation number */ mutable int geno; /** * The emission model. */ tcEmitterPtr model; /** * The unmutable dipole, available during the generation. */ tcDBPtr cdipole; /** * The dipole. Is only set after the full emission has been generated. */ tDBPtr dipole; /** * The momentum of the original partons. */ mutable pair pold; /** * The evolution scale of the generated emission. */ Energy rho; /** *The invariant rapidity of the generated emission. */ double y; /** * The generated mometa. */ mutable Trip genmom; /** * The approximate maximum invariant rapidity possible for the * given scale (typically given by log(S/pt^2)/2. Is negative if * no such value is given. */ double ymax; /** * The order in \f$\alpha_S\f$ of this emission. If this is a * pre-generated emission (e.g. a decay given already in the hard * sub-process) it should be set to the negative. */ int orderAlphaS; /** * The order in \f$\alpha_{EW}\f$ of this emission. If this is * a pre-generated emission (e.g. a decay given already in the * hard sub-process) it shoule be set to the negative. */ int orderAlphaEW; /** * The partons responsible for the emission (if any). Typically the * two partons spanning a dipole. */ vector radiators; /** * The parent which was the incoming (coloured) parton in the * original dipole. */ tParPtr colourParent; /** * The parent which was the outgoing (anti-coloured) parton in the * original dipole. */ tParPtr antiColourParent; /** * The parent from which the main particle was most likely emitted. */ tParPtr mainParent; /** * The list of emitted partons */ mutable vector partons; /** * The list of partons which are affected by this emission. */ mutable vector affected; /** * The splitting probability for this (inverse) emission given in * units of 1/GeV. */ double prob; /** * The PDF ratio weight for this (inverse) emission. */ double weightPDF; /** * Can the emitter model revert this Emission so that the * DipoleSystem can be completely restored? */ bool reversible; /** * Can the emitter model guarantee that this Emission is failsafe? */ bool failsafe; 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(); /** * Standard debug function to be called from within a debugger. */ void debugme() const; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - Emission & operator=(const Emission &); + Emission & operator=(const Emission &) = delete; }; /** * Special container class to help selecting the emission with largest scale. */ class EmSel { public: /** * The only constructor requires an Energy variable where the * largest scale so far is modified. */ EmSel(Energy & rhom): rhomax(rhom) {} /** * Conditionally assing the given Emission if it is the largest * scale so far. */ EmSel & operator=(EmPtr e) { if ( !sel || ( e && e->rho > sel->rho ) ) sel = e; if ( sel ) rhomax = max(sel->rho, rhomax); return *this; } operator EmPtr () { return sel; } private: /** * The selected Emission. */ EmPtr sel; /** * The Energy variable keeping track of the highest scale so far. */ Energy & rhomax; }; } #endif /* Ariadne5_Emission_H */ diff --git a/Cascade/EmitterBase.h b/Cascade/EmitterBase.h --- a/Cascade/EmitterBase.h +++ b/Cascade/EmitterBase.h @@ -1,327 +1,327 @@ // -*- C++ -*- #ifndef Ariadne5_EmitterBase_H #define Ariadne5_EmitterBase_H // // This is the declaration of the EmitterBase class. // #include "ThePEG/Handlers/HandlerBase.h" #include "DipoleBase.h" #include "QCDDipole.fh" #include "ReweightBase.h" #include "EmitterBase.fh" #include "Emission.fh" #include "ThePEG/Utilities/Triplet.h" #include "ThePEG/Utilities/Current.h" #include "AriadneHandler.h" namespace Ariadne5 { using namespace ThePEG; /** * EmitterBase is the base class of all Ariadne classes implementing * a specific model for emission from different kinds of dipoles. A * sub-class must implement a sub-class of Emission to store the * result of an emission. * * @see \ref EmitterBaseInterfaces "The interfaces" * defined for EmitterBase. */ class EmitterBase: public HandlerBase { public: /** Convenient typedef. */ typedef Triplet Trip; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ EmitterBase(bool reco = false): canReconstruct(reco), willReconstruct(reco) {} /** * The destructor. */ virtual ~EmitterBase() {} //@} public: /** @name Virtual functions to be overridden by sub-classes. */ //@{ /** * Return true if and only if this emitter can handle the given \a * dipole. */ virtual bool canHandle(const DipoleBase & dipole) const = 0; /** * If the given \a emitter overlaps with this model for the given \a * dipole, return true if this object should take precedence. Must * only be called for a \a dipole for which canHandle() is true. */ virtual bool overrides(const EmitterBase & emitter, DipoleBase & dipole) const = 0; /** * Check if objects related to the given \a dipole have been touched * in a way such that emissions must be regenerated. */ virtual bool touched(const DipoleBase & dipole) const; /** * Generate the a phase space point for an emission corresponding to * this model. Must only be called for a \a dipole for which * canHandle() is true. */ virtual EmPtr generate(const DipoleBase & dipole, Energy rhomin, Energy rhomax) const = 0; /** * Perform the \a emission previously generated. * @return true if the emission was successful */ virtual bool perform(const Emission & emission) const = 0; /** * Reverse a previously performed emission. Sub-classes which has * signalled that they can revert an emission but fails to do so, * must throw a Exception::runerror. */ virtual void revert(const Emission & emission) const; /** * Return true if this emitter should be used to reconstruct * emissions in the CKKW-L algorithm. */ bool reconstructor() const { return willReconstruct; } /** * Return a list of inverse emissions which this model could have * performed to arrive at the given \a state. */ virtual vector inverseEmissions(const DipoleState & state) const; /** * Check if an inverse \a emission suggested by the given \a emitter * should rather be handled by this model. */ virtual bool overrideInverse(const Emission & emission) const; /** * Perform the inverse \a emission, previously reported by * inverseEmissions(). * @return false of the reconstruction failed. */ virtual bool performInverse(const Emission &, DipoleState &) const; /** * Possibility to override the general non-perturbative cutoff for * this process. The default is AriadneHandler::pTCut() which is * typically used for QCD radiation. */ virtual Energy rhoCut() const; //@} /** @name These functions are related to external reweighting of * emissions and should normally not be overridden. */ //@{ /** * Return the product of preweights from all reweighters registered * for this model. */ virtual double preweight(const Emission & emission) const; /** * Return the product of reweights from all reweighters registered * for this emission model. */ virtual double reweight(const Emission & emission) const; /** * Return true if any of the reweighters registered for this * emission model says so. */ virtual bool finalVeto(const Emission & emission) const; /** * Return true if any of the reweighters registered for this * emission model may veto in finalVeto(). */ virtual bool hasFinalVeto() const; //@} /** * Access the AriadneHandler object currently in use. */ static AriadneHandler & handler() { return Current::current(); } /** * Generate an squared invariant transverse momentum. The * distribution used is \f$C\alpha_S\frac{dp_\perp^2}{p_\perp^2}\f$ * multiplied with the corresponding Sudakov formfactor. The maximum * \f$p_\perp^2\f$ is \a pt2max and \a C is the constant. If we are * using a running \f$\alpha_S\f$ runrdnsud() will be called * automatically. */ static Energy2 rndsud(double C, Energy2 pt2max, Energy2 pt2min); /** * Generate an squared invariant transverse momentum. The * distribution used is \f$C\alpha_S\frac{dp_\perp^2}{p_\perp^2}\f$ * multiplied with the corresponding Sudakov formfactor. The maximum * \f$p_\perp^2\f$ is \a pt2max and \a C is the constant. This * function takes care of the running of \f$\alpha_S\f$ or whatever. */ static Energy2 runrndsud(double C, Energy2 pt2max, Energy2 pt2min); /** * Check consistency of generated phase-space point for standard * dipole variables. */ static bool check(double x1, double x3, double y1, double y2, double y3); /** * Return the invariant transverse momentum of parton \a p2 * w.r.t. partons \a p1 and \a p3. */ static Energy2 invPT2(tcParPtr p1, tcParPtr p2, tcParPtr p3); /** * Return the invariant rapidity of parton \a p2 w.r.t. partons \a * p1 and \a p3. */ static double invY(tcParPtr p1, tcParPtr p2, tcParPtr p3); /** * Return the momenta of three particles with masses \a m1, \a m2 * and \a m3 respectively and where the first particle takes an * energy fraction \a x1 and the third an energy fraction \a x3 * (x1+x2+x3=2). If \a nr1 is true the first particle will b along * the positive z-axis. Conversely if \a nr3 is true the third * particle will always be along the negative z-axis. If \a nr1 and * \a nr3 is true, the summed squared transverse energy of the * first and third momenta will be minimized, and if niether \a nr1 * or \a nr3 is true, \a nr1 (\a nr3) will be set to true with * probability \f$x_{1(3)}^2/(x_1^2+x_3^2)\f$. If \a userho is true, * the recoils will be determined by the momentum fractions rather * than the energy fractions. */ static Trip getMomenta(Energy2 s, double x1, double x3, Energy m1, Energy m2, Energy m3, bool nr1, bool nr3, bool userho = false); /** * Same as * getMomenta(Energy2,double,double,Energy,Energy,Energy,bool,bool,bool), * but also rotate an angle phi around z-axis */ static Trip getMomenta(Energy2 s, double x1, double x3, Energy m1, Energy m2, Energy m3, bool nr1, bool nr3, double phi, bool userho = false); /** * Calls * getMomenta(Energy2,double,double,Energy,Energy,Energy,bool,bool,bool) * But also rotates the resulting momenta an angle \a phi around the * z-axis and transforms them from the rest frame of \a p1 and \a * p3). \a s must be the squared invariant mass of \a p1 and \a p3. */ static Trip getMomenta(Energy2 s, double x1, double x3, Energy m1, Energy m2, Energy m3, bool nr1, bool nr3, double phi, const Lorentz5Momentum & p1, const Lorentz5Momentum & p3, bool userho = false); protected: /** * Exception class used if weights larger that one is encountered. */ struct WeightException: Exception {}; 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); //@} public: /** * 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(); // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * A list of reweighting objects which may be applied to * emissions generated by this emission model. */ vector theReweighters; /** * If true, this emitter can be used to perform inverse emissions in * the CKKW-L algorithm. */ bool canReconstruct; /** * If true, this emitter will be used to perform inverse emissions in * the CKKW-L algorithm. */ bool willReconstruct; private: /** * Utility function for the interface. */ void setReconstruct(bool t); /** * Utility function for the interface. */ bool defReconstruct() const; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - EmitterBase & operator=(const EmitterBase &); + EmitterBase & operator=(const EmitterBase &) = delete; }; } #endif /* Ariadne5_EmitterBase_H */ diff --git a/Cascade/History.h b/Cascade/History.h --- a/Cascade/History.h +++ b/Cascade/History.h @@ -1,282 +1,282 @@ // -*- C++ -*- #ifndef Ariadne5_History_H #define Ariadne5_History_H // // This is the declaration of the History class. // #include "DipoleState.h" #include "Emission.h" #include "EmitterBase.h" #include "AriadneHandler.fh" #include "History.fh" #include "ThePEG/Utilities/Selector.h" namespace Ariadne5 { using namespace ThePEG; /** * Here is the documentation of the History class. */ class History: public Base { public: /** * Enumerate different ways of reordering scales in unordered paths. */ enum Reordering { UseMax = 1, /**< Always take the maximum. */ UseMin = -1 /**< Always take the minimum. */ }; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor, si never useful. */ History(); /** * The main constructor, which recursively constructs a tree * structure of History objects. \a depth is the maximum number of * clusterings requested. \a statein is the DipoleState to be * clustered. */ History(int depth, DipoleStatePtr statein); protected: /** * The constructor used when creating recursive nodes. The \a depth * is the maximum number of clusterings requested. \a scalein is the * scale at which the \a statein was clustered. If \a isOrdered is * true, the previous clusterings has been ordered. \a probin is the * accumulated probabilities for the previous clusterings, and \a * mothin is the parent history node. \a emin is the inverse * emission which produced the \a statein. */ History(int depth, Energy scalein, DipoleStatePtr statein, bool isOrdered, double probin, tHistoryPtr mothin, tcEmPtr emin); public: /** * The destructor. */ virtual ~History(); //@} public: /** * In the initial history node, select one of the paths according to * the probabilities. This function must only be called for the * initial history node. All reconstructed paths, except the chosen * one, are discarded. */ tHistoryPtr select(Reordering ord = UseMax); /** * Find the weight calculated from the ratio of couplings, the * no-emission probabilities, and possible PDF ratios. \a as0 is the * value of \f$\alpha_s\f$ and \a muF is the factorization scale * used in the matrix element generator. This function must only be * called from the original node. */ double weight(double as0, Energy2 muF2) const; /** * The scale of this step, corresponding to clustering which * constructed the corresponding state. For the initial node, this * is the total energy before selection of the path and the * factorization scale of the fully resconstructed state after the * selection. */ Energy scale() const { return theScale; } /** * The state of the event correponding to this step in the * reconstruction. */ tDipoleStatePtr state() const { return theState; } private: /** * Do the actual recursive clustering, with a maximum number of * steps given by \a depth. If \a isOrdered is false, this belongs * to a path which is already unordered. */ void recurse(int depth, bool isOrdered); /** * Check if an ordered (and complete) path has been found in the * initial node, in which case we will no longer be interested in * any unordered paths. */ bool onlyOrderedPaths() const; /** * When a full path has been found, register it with the initial * history node. */ bool registerPath(tHistoryPtr h, Energy rho0, bool isOrdered, bool isComplete); /** * Helper class to order potential reconstructions in scale. */ struct ScaleCmp { /** Compare two reconstructions. */ bool operator()(tcEmPtr e1, tcEmPtr e2) { return e1->rho < e2->rho; } }; /** * Return the set of all possible single clusterings of the current * state. */ set getClusterings(); /** * Perform the clustering of the current state and return the * clustered state. */ DipoleStatePtr cluster(tEmPtr); /** * Perform a trial shower between \a maxscale down to this scale and * return the corresponding Sudakov form factor. */ double trialShower(Energy maxscale) const; /** * Remove all children from this node, except the given one. */ void clean(HistoryPtr h = HistoryPtr()); /** * Find the weight calculated from the ratio of couplings and * possible PDF ratios. \a as0 is the value of \f$\alpha_s\f$ used * in the matrix element generator. \a hdl is the resonsible * handler. */ double weight(double as0, const AriadneHandler & hdl) const; /** * Reorder scales for an unordered path. */ void reorder(Reordering); 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(); private: /** * The state of the event correponding to this step in the * reconstruction. */ mutable DipoleStatePtr theState; /** * The previous step from which this step has been clustered. If * null, this is the initial step with the n-jet state generated by * the matrix element. */ tHistoryPtr mother; /** * The inverse emission which reconstructed this state. */ tcEmPtr emission; /** * The different steps corresponding to possible clusterings of this * state. */ vector children; /** * Selector keeping track of all reconstructed paths according to * their probabilities. This is empty unless this is the initial * step (mother == null). */ Selector paths; /** * A map keeping track of the maximum scales for each path. */ map scales; /** * This is set true if an ordered (and complete) path has been found * and inserted in paths. */ mutable bool foundOrderedPath; /** * This is set true if a complete (with the required number of * clusterings) path has been found and inserted in paths. */ bool foundCompletePath; /** * The scale of this step, corresponding to clustering which * constructed the corresponding state is zero for the initial node. */ Energy theScale; /** * The probability associated with this step and the previous steps. */ double prob; /** * The last node in the selected path. */ HistoryPtr sel; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - History & operator=(const History &); + History & operator=(const History &) = delete; }; } #endif /* Ariadne5_History_H */ diff --git a/Cascade/Junction.h b/Cascade/Junction.h --- a/Cascade/Junction.h +++ b/Cascade/Junction.h @@ -1,205 +1,205 @@ // -*- C++ -*- #ifndef Ariadne5_Junction_H #define Ariadne5_Junction_H // // This is the declaration of the Junction class. // #include "Parton.h" #include "Junction.fh" namespace Ariadne5 { using namespace ThePEG; /** * The Junction class inherits from Parton, but is only a place holder * so that Another Parton can be colour-connected to it. The class * keeps track of the other partons which are connected to the * Junction. */ class Junction: public Parton { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ Junction(); /** * The destructor. */ virtual ~Junction(); //@} public: /** * Return true if this is a source. */ bool source() const; /** * Return true if this is a sink. */ bool sink() const; /** * Get the Parton which is assumed to be connected to the given * Parton. */ tParPtr getNeighbour(tcParPtr p) const; /** * Return true if any of the neighboring dipoles or partons have * been touched. */ virtual bool touchedNeighbours(tcQCDPtr d) const; /** * Get the neighboring dipoles. */ pair getNeighbours(tcQCDPtr d) const; /** * Randomly choose a neighboring parton in the junction, recursing * if this itself was a junction. */ tParPtr getRandomRecoiler(tcQCDPtr d) const; /** * Replace the \a oldd QCDDipole with the \a newd QCDDipole as connected * to this Junction. * @return false if \a oldd was not a member. */ bool replace(tQCDPtr oldd, tQCDPtr newd); /** * Set the three partons connected to this Junction. */ void set(tParPtr pin1, tParPtr pin2, tParPtr pin3) { p1 = pin1; p2 = pin2; p3 = pin3; } /** * Do not produce a ThePEG::Particle corresponding to this parton, * as it is not really a parton. */ virtual tPPtr produceParticle(const LorentzRotation & r = LorentzRotation()); protected: /** * Helper function for recursing touchedNeighbours(). */ bool touchedBranch(tcQCDPtr d) const; /** @name Functions relating to the DipoleState to which this belongs. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual ClonePtr clone() const; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} 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(); private: /** * The first dipole. */ tQCDPtr d1; /** * The second dipole. */ tQCDPtr d2; /** * The third dipole. */ tQCDPtr d3; /** * The first parton. */ tParPtr p1; /** * The second parton. */ tParPtr p2; /** * The third parton. */ tParPtr p3; public: /** * Print out debugging information on std::cerr. */ virtual void debugme() const; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - Junction & operator=(const Junction &); + Junction & operator=(const Junction &) = delete; }; } #endif /* Ariadne5_Junction_H */ diff --git a/Cascade/MaxPTScale.h b/Cascade/MaxPTScale.h --- a/Cascade/MaxPTScale.h +++ b/Cascade/MaxPTScale.h @@ -1,131 +1,131 @@ // -*- C++ -*- #ifndef ARIADNE5_MaxPTScale_H #define ARIADNE5_MaxPTScale_H // // This is the declaration of the MaxPTScale class. // #include "ScaleSetter.h" #include "DipoleState.fh" namespace Ariadne5 { using namespace ThePEG; /** * The only task of the MaxPTScale class is to calculate a starting * scale for the dipole shower from a given DipoleState. This class * gives the maximum invariant transverse momentum of all gluons in * the sub process as the starting scale. Alternatively It may give * the maximum actual transverse momentum of all partons or the scalar * sum of all transverse momenta. * * @see \ref MaxPTScaleInterfaces "The interfaces" * defined for MaxPTScale. */ class MaxPTScale: public ScaleSetter { public: /** * Enumerate the strategies. */ enum PTStrategy { invariantPT = 0, /**< Use the invariant transverse momentum of any gluon. */ actualPT = 1, /**< Use the actual transverse momentum of any parton. */ scalarSum = 2 /**< Use the scalar sum of all transverse momenta. */ }; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ MaxPTScale(); /** * The destructor. */ virtual ~MaxPTScale(); //@} public: /** * Return the starting scale for the dipole shower from the given * DipoleState. Returns the maximum invariant transverse momentum of * gluons in the event (or the total collision energy if no gluons * are found. */ virtual Energy scale(const DipoleState &) 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); //@} /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The strategy chosen for finding the highest transverse momentum. */ PTStrategy strategy; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - MaxPTScale & operator=(const MaxPTScale &); + MaxPTScale & operator=(const MaxPTScale &) = delete; }; } #endif /* ARIADNE5_MaxPTScale_H */ diff --git a/Cascade/MinPTScale.h b/Cascade/MinPTScale.h --- a/Cascade/MinPTScale.h +++ b/Cascade/MinPTScale.h @@ -1,95 +1,95 @@ // -*- C++ -*- #ifndef ARIADNE5_MinPTScale_H #define ARIADNE5_MinPTScale_H // // This is the declaration of the MinPTScale class. // #include "ScaleSetter.h" #include "DipoleState.fh" namespace Ariadne5 { using namespace ThePEG; /** * The only task of the MinPTScale class is to calculate a starting * scale for the dipole shower from a given DipoleState. This class * gives the minimum invariant transverse momentum of all gluons in * the sub process as the starting scale * * @see \ref MinPTScaleInterfaces "The interfaces" * defined for MinPTScale. */ class MinPTScale: public ScaleSetter { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ MinPTScale(); /** * The destructor. */ virtual ~MinPTScale(); //@} public: /** * Return the starting scale for the dipole shower from the given * DipoleState. Returns the minimum invariant transverse momentum of * gluons in the event (or the total collision energy if no gluons * are found. */ virtual Energy scale(const DipoleState &) const; public: /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - MinPTScale & operator=(const MinPTScale &); + MinPTScale & operator=(const MinPTScale &) = delete; }; } #endif /* ARIADNE5_MinPTScale_H */ diff --git a/Cascade/Models/ColourChargeRegions.h b/Cascade/Models/ColourChargeRegions.h --- a/Cascade/Models/ColourChargeRegions.h +++ b/Cascade/Models/ColourChargeRegions.h @@ -1,156 +1,156 @@ // -*- C++ -*- #ifndef Ariadne5_ColourChargeRegions_H #define Ariadne5_ColourChargeRegions_H // // This is the declaration of the ColourChargeRegions class. // #include "Ariadne/Cascade/ReweightBase.h" #include "Ariadne/Cascade/QCDDipole.fh" #include "Ariadne/Cascade/Emission.fh" namespace Ariadne5 { using namespace ThePEG; /** * The ColourChargeRegions class can be used to reweight gluon * emissions so that a more correct colour charge is assigned to an * emission probability, based not only on the charge of the emitting * partons in the dipole, but also on where in rapidity the gluon is * emitted. This uses a simplified version of the model by Eden and * Gustafson [hep-ph/9805228]. * * @see \ref ColourChargeRegionsInterfaces "The interfaces" * defined for ColourChargeRegions. */ class ColourChargeRegions: public Ariadne5::ReweightBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ ColourChargeRegions(); /** * The destructor. */ virtual ~ColourChargeRegions(); //@} public: /** @name Virtual functions to be overridden in sub-classes. */ //@{ /** * If the emission is from a q-qbar dipole, preweight with Nc/2/CF. */ virtual double preweight(const Emission & emission) const; /** * Reweight with 2CF/Nc if the repisity of the gluon corresponds to * it being emitted off a quark line. */ virtual double reweight(const Emission & emission) const; //@} protected: /** * Set up the charge regions necessary to calculate the colour charge. */ void setup(const QCDDipole & d) const; /** * Return the colour charge for the given rapidity. */ double charge(double y) 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); //@} /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The unique id of last emission for which the colour regions were * set up. */ mutable tcEmPtr lastEmission; mutable unsigned long lastEmissionId; /** * The map tracing the history of the coloured Parton in the Dipole. */ mutable map colregions; /** * The map tracing the history of the anti-coloured Parton in the Dipole. */ mutable map acoregions; public: /** * Print out debugging information on std::cerr. */ virtual void debugme() const; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ColourChargeRegions & operator=(const ColourChargeRegions &); + ColourChargeRegions & operator=(const ColourChargeRegions &) = delete; }; } #endif /* Ariadne5_ColourChargeRegions_H */ diff --git a/Cascade/Models/ColourResonanceModel.h b/Cascade/Models/ColourResonanceModel.h --- a/Cascade/Models/ColourResonanceModel.h +++ b/Cascade/Models/ColourResonanceModel.h @@ -1,130 +1,130 @@ // -*- C++ -*- #ifndef Ariadne5_ColourResonanceModel_H #define Ariadne5_ColourResonanceModel_H // // This is the declaration of the ColourResonanceModel class. // #include "ColourResonanceModel.h" #include "ThePEG/Handlers/HandlerBase.h" #include "Ariadne/Cascade/ResonanceParton.h" #include "Ariadne/Cascade/Emission.h" #include "PseudoParton.h" namespace Ariadne5 { using namespace ThePEG; /** * ColourResonanceModel is a helper class to be used when emitting * from a coloured resonance. * * @see \ref ColourResonanceModelInterfaces "The interfaces" * defined for ColourResonanceModel. */ class ColourResonanceModel: public HandlerBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ ColourResonanceModel(); /** * The destructor. */ virtual ~ColourResonanceModel(); //@} public: /** * Check if the given resonance product should still be considered * special, or if it can be treated as any other parton. */ virtual bool stillSpecial(tResParPtr p) const; /** * Return a pseudo particle to be used in normal dipole emission * from the given resonance product. */ virtual PseudoParton getPseudoParton(tResParPtr p) const; /** * If the given resonance product is still special, generate * possible gluon emissions from the internal coloue line. If \a * iside is true thie is for the iPart() of the emitting dipole. */ virtual EmPtr generateInternalGluon(const EmitterBase &, const QCDDipole & dip, tResParPtr p) const; /** * Set momentum after emission from a pseudo parton. */ virtual void setMomentum(PseudoParton pp, const Lorentz5Momentum & p) 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); //@} /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ColourResonanceModel & operator=(const ColourResonanceModel &); + ColourResonanceModel & operator=(const ColourResonanceModel &) = delete; }; } #endif /* Ariadne5_ColourResonanceModel_H */ diff --git a/Cascade/Models/DISME.h b/Cascade/Models/DISME.h --- a/Cascade/Models/DISME.h +++ b/Cascade/Models/DISME.h @@ -1,188 +1,188 @@ // -*- C++ -*- #ifndef ARIADNE5_DISME_H #define ARIADNE5_DISME_H // // This is the declaration of the DISME class. // #include "Ariadne/Cascade/EmitterBase.h" #include "RemnantGluonEmission.h" #include "ISGtoQEmission.h" #include "ISQEmitter.h" namespace Ariadne5 { using namespace ThePEG; /** * The DISME class implements the emission of gluons and initial-state * splitting of gluons into quarks according to the leading-order * tree-level matrix element for deeply inelastic, neutral-current, * lepton-proton scattering. * * @see \ref DISMEInterfaces "The interfaces" * defined for DISME. */ class DISME: public ISQEmitter { public: /** * Convenient typedef. */ ThePEG_DECLARE_POINTERS(Ariadne5::RemnantGluonEmission,RemGEmPtr); /** * Convenient typedef. */ ThePEG_DECLARE_POINTERS(Ariadne5::ISGtoQEmission,ISGtoQEmPtr); public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ DISME(); /** * The destructor. */ virtual ~DISME(); //@} /** @name Virtual functions to be overridden by sub-classes. */ //@{ /** * Return true if and only if this model can handle the given * Emitter. */ virtual bool canHandle(const DipoleBase &) const; /** * If the given EmissionModel overlaps with this model for the given * Emitter, return true if this model should take precedence. Must * only be called for Emitters for which canHandle() is true. */ virtual bool overrides(const EmitterBase &, DipoleBase &) const; /** * Generate the a phase space point for an emission corresponding to * this model. Must only be called for Emitters for which * canHandle() is true. */ virtual EmPtr generate(const DipoleBase &, Energy rhomin, Energy rhomax) const; /** * Perform an emission previously generated for this Emitter. Must * only be called for Emitters for which canHandle() is true. * @return true if the emission was successful */ virtual bool perform(const Emission &) const; /** * Reverse a previously performed emission. Sub-classes which has * signalled that they can revert an emission but fails to do so, * must throw a Exception::runerror. */ virtual void revert(const Emission & emission) const; //@} public: /** * Generate the a phase space point for a gluon emission. */ virtual EmPtr generateG(tRemParPtr rsoft, tRemParPtr rhard, const QCDDipole & d, Energy rhomin, Energy rhomax) const; /** * Generate the a phase space point for a BGF emission. */ virtual EmPtr generateQ(tRemParPtr rsoft, tRemParPtr rhard, const QCDDipole & d, Energy rhomin, Energy rhomax) const; /** * Perform an emission previously generated by generateG. */ virtual bool performG(const RemnantGluonEmission & e) const; /** * Undo an emission previously generated by performG. */ virtual void revertG(const RemnantGluonEmission & e) const; /** * Perform an emission previously generated by generateQ. */ virtual bool performQ(const ISGtoQEmission & e) const; /** * Undo an emission previously generated by performQ. */ virtual void revertQ(const ISGtoQEmission & e) 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); //@} /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - DISME & operator=(const DISME &); + DISME & operator=(const DISME &) = delete; }; } #endif /* ARIADNE5_DISME_H */ diff --git a/Cascade/Models/DYME.h b/Cascade/Models/DYME.h --- a/Cascade/Models/DYME.h +++ b/Cascade/Models/DYME.h @@ -1,162 +1,162 @@ // -*- C++ -*- #ifndef ARIADNE5_DYME_H #define ARIADNE5_DYME_H // // This is the declaration of the DYME class. // #include "Ariadne/Cascade/EmitterBase.h" #include "RRGluonEmission.h" #include "ISGtoQEmitter.h" namespace Ariadne5 { using namespace ThePEG; /** * The DYME class implements the emission of gluons and initial-state * splitting of gluons into quarks according to the leading-order * tree-level matrix element for deeply inelastic, neutral-current, * lepton-proton scattering. * * @see \ref DYMEInterfaces "The interfaces" * defined for DYME. */ class DYME: public ISGtoQEmitter { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ DYME(); /** * The destructor. */ virtual ~DYME(); //@} /** @name Virtual functions to be overridden by sub-classes. */ //@{ /** * Return true if and only if this model can handle the given * Emitter. */ virtual bool canHandle(const DipoleBase &) const; /** * If the given EmissionModel overlaps with this model for the given * Emitter, return true if this model should take precedence. Must * only be called for Emitters for which canHandle() is true. */ virtual bool overrides(const EmitterBase &, DipoleBase &) const; /** * Generate the a phase space point for an emission corresponding to * this model. Must only be called for Emitters for which * canHandle() is true. */ virtual EmPtr generate(const DipoleBase &, Energy rhomin, Energy rhomax) const; /** * Perform an emission previously generated for this Emitter. Must * only be called for Emitters for which canHandle() is true. * @return true if the emission was successful */ virtual bool perform(const Emission &) const; /** * Reverse a previously performed emission. Sub-classes which has * signalled that they can revert an emission but fails to do so, * must throw a Exception::runerror. */ virtual void revert(const Emission & emission) const; //@} public: /** * Generate the a phase space point for a gluon emission. */ virtual EmPtr generateG(tRemParPtr rsoft, tRemParPtr rhard, const QCDDipole & d, Energy rhomin, Energy rhomax) const; /** * We don't have to implement the whole generation for quark * emission, only (p)reweight the base class method. */ virtual double reweight(const Emission & emission) const; /** * We don't have to implement the whole generation for quark * emission, only (p)reweight the base class method. */ virtual double preweight(const Emission & emission) const; public: 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - DYME & operator=(const DYME &); + DYME & operator=(const DYME &) = delete; }; } #endif /* ARIADNE5_DYME_H */ diff --git a/Cascade/Models/DipoleSwing.h b/Cascade/Models/DipoleSwing.h --- a/Cascade/Models/DipoleSwing.h +++ b/Cascade/Models/DipoleSwing.h @@ -1,129 +1,129 @@ // -*- C++ -*- #ifndef ARIADNE5_DipoleSwing_H #define ARIADNE5_DipoleSwing_H // // This is the declaration of the DipoleSwing class. // #include "Ariadne/Cascade/Emission.h" #include "Ariadne/Cascade/StateDipole.h" #include "Ariadne/Cascade/QCDDipole.h" #include "Ariadne/Cascade/DipoleState.h" namespace Ariadne5 { using namespace ThePEG; /** * The DipoleSwing class contains all information about a generated * Swing. */ class DipoleSwing: public Emission { public: /** @name Standard constructors and destructors. */ //@{ /** * The only relevant constructor. */ DipoleSwing(const EmitterBase & inmodel, const DipoleBase & indipole, QCDDipole & d1, QCDDipole & d2, Time dt) : Emission(inmodel, indipole), forced(false) { setup(d1, d2, dt); } /** * The deault constructor should not normally be used. */ DipoleSwing() {} /** * The destructor. */ virtual ~DipoleSwing(); //@} public: void setup(QCDDipole & d1, QCDDipole & d2, Time dt); protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual ClonePtr 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 ClonePtr fullclone() const; //@} public: /** * The the pair of dipoles that should swing. */ pair dipoles; /** * The colour index of the dipoles that should swing. */ ColourIndex index; /** * This swing was forced on a tiny string. */ bool forced; 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(); /** * Standard debug function to be called from within a debugger. */ void debugme() const; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - DipoleSwing & operator=(const DipoleSwing &); + DipoleSwing & operator=(const DipoleSwing &) = delete; }; } #endif /* ARIADNE_DipoleSwing_H */ diff --git a/Cascade/Models/DipoleSwinger.h b/Cascade/Models/DipoleSwinger.h --- a/Cascade/Models/DipoleSwinger.h +++ b/Cascade/Models/DipoleSwinger.h @@ -1,465 +1,465 @@ // -*- C++ -*- #ifndef ARIADNE5_DipoleSwinger_H #define ARIADNE5_DipoleSwinger_H // // This is the declaration of the DipoleSwinger class. // #include "Ariadne/Cascade/EmitterBase.h" #include "DipoleSwing.h" #include "Ariadne/Cascade/QCDDipole.h" #include "Ariadne/Cascade/PartonTraits.h" namespace Ariadne5 { using namespace ThePEG; /** * The DipoleSwinger class implements the final-state swing method for * colour reconections. * * @see \ref DipoleSwingerInterfaces "The interfaces" * defined for DipoleSwinger. */ class DipoleSwinger: public EmitterBase { public: /** * Convenient typedef. */ ThePEG_DECLARE_POINTERS(Ariadne5::DipoleSwing,DipSwPtr); /** * Another convenient typedef. */ typedef map CacheMap; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ DipoleSwinger(); /** * The destructor. */ virtual ~DipoleSwinger(); //@} /** @name Virtual functions to be overridden by sub-classes. */ //@{ /** * Return true if and only if this model can handle the given * Emitter. */ virtual bool canHandle(const DipoleBase &) const; /** * If the given EmissionModel overlaps with this model for the given * Emitter, return true if this model should take precedence. Must * only be called for Emitters for which canHandle() is true. */ virtual bool overrides(const EmitterBase &, DipoleBase &) const; /** * Check if objects related to the given \a dipole have been touched * in a way such that emissions must be regenerated. */ virtual bool touched(const DipoleBase & dipole) const; /** * Generate the a phase space point for an emission corresponding to * this model. Must only be called for Emitters for which * canHandle() is true. */ virtual EmPtr generate(const DipoleBase &, Energy rhomin, Energy rhomax) const; /** * Perform an emission previously generated for this Emitter. Must * only be called for Emitters for which canHandle() is true. * @return true if the emission was successful */ virtual bool perform(const Emission &) const; /** * Reverse a previously performed emission. Sub-classes which has * signalled that they can revert an emission but fails to do so, * must throw a Exception::runerror. */ virtual void revert(const Emission & emission) const; /** * Possibility to override the general non-perturbative cutoff for * this process. The default is AriadneHandler::pTCut() which is * typically used for QCD radiation. */ virtual Energy rhoCut() const; /** * The maximum allowed value of the evolution variable, Used to * disallow perturbative swings. Inactive if below rhoCut(). */ inline Energy maxRho() const { return theMaxRho; } //@} /** * Swing the given dipoles. */ static void swing(tQCDPtr d1, tQCDPtr d2); /** * Find strings with total mass below some cutoff and place them in * the tinyString container. */ void findTinyStrings() const; public: /** * Select the given Swing if it has the largerst scale. */ void select(DipSwPtr sel) const { if ( sel && ( !lastSelected || sel->rho > lastSelected->rho ) ) lastSelected = sel; } /** * Internal helper class to keep track of distnaces between partons. */ struct DeltaTau2 { /** * Constructor taked two partons and calculates the variables * needed to get the distance as a function of time. */ DeltaTau2(tcParPtr p1, tcParPtr p2, int optin, Length Rmax): sizeOpt(optin) { LorentzDistance dx = p1->vertex() - p2->vertex(); dx2 = min(dx.m2(), ZERO); LorentzVector dp = p1->momentum()/p1->momentum().e() - p2->momentum()/p2->momentum().e(); dp2 = dp.m2(); dpdotdx = dp*dx; if ( sizeOpt >= 1 ) dp2 = max((p1->momentum() + p2->momentum()).m2(), sqr(hbarc/Rmax))/GeV2; pp1 = p1; pp2 = p2; } /** * Return distance between partons after a given time \a dt. */ Area dTau2(Time dt) const { if ( sizeOpt <= 0 ) return - dx2 - dt*2.0*dpdotdx - sqr(dt)*dp2; else return sqr(dt)*dp2; } /** * Return the impact-parameter distance between partons after a * given time \a dt. */ Length db() const { return sqrt(-dx2); } /** * Return the impact-parameter distance between partons after a * given time \a dt. */ Area db2() const { return -dx2; } /** * Function version of dTau2 */ Area operator()(Time dt) const { return dTau2(dt); } /** * If the distance between the partons may become zero in the * given time interval, return the corresponding times. If there * are no zeros, time=0 will be returned. */ pair zeros(Time dt1, Time dt2) const { pair ret; Area squarg = sqr(dpdotdx) - dx2*dp2; if ( squarg < ZERO ) return ret; Time t0 = - (dpdotdx + sqrt(squarg))/dp2; if ( dt1 <= t0 && t0 <= dt2 ) ret.first = t0; t0 = - (dpdotdx - sqrt(squarg))/dp2; if ( dt1 <= t0 && t0 <= dt2 ) ret.second = t0; return ret; } /** * Return the minimum and maximum in the given interval. */ pair minmax(Time dt1, Time dt2) const { pair ret(dTau2(dt1),dTau2(dt2)); if ( ret.first > ret.second ) swap(ret.first, ret.second); Time dtext = -dpdotdx/dp2; if ( dtext >= dt2 || dt1 >= dtext ) return ret; Area dtau2ext = dTau2(dtext); if ( dtau2ext > ret.second ) ret.second = dtau2ext; if ( dtau2ext < ret.first ) ret.first = dtau2ext; return ret; } /** * Return the extreme point if in the given interval. */ Time extreme(Time dt1, Time dt2) const { return min(max(dt1, -dpdotdx/dp2), dt2); } /** * The initial distance between the partons. */ Area dx2; /** * The distance between the momentum vectors, scaled by their energies. */ double dp2; /** * Different options for calculating the dipole size. */ int sizeOpt; /** * The scalar product between the difference between momentum * vectors (scaled with their energies) and the difference between * the initial positions. */ Length dpdotdx; /* **** ATTENTION *** Only for debugging */ InvEnergy2 chris(Time dt) const { InvEnergy2 time = sqr(dt/hbarc); Energy2 E2 = pp1->momentum().plus()*pp2->momentum().minus() + pp1->momentum().minus()*pp2->momentum().plus(); InvEnergy x1x = pp1->vertex().x()/hbarc - pp2->vertex().x()/hbarc + time*pp1->momentum().x(); InvEnergy x1y = pp1->vertex().y()/hbarc - pp2->vertex().y()/hbarc + time*pp1->momentum().y(); InvEnergy x2x = pp1->vertex().x()/hbarc - pp2->vertex().x()/hbarc - time*pp2->momentum().x(); InvEnergy x2y = pp1->vertex().y()/hbarc - pp2->vertex().y()/hbarc - time*pp2->momentum().y(); InvEnergy2 xxScalar = x1x*x2x + x1y*x2y; Energy2 ppScalar = pp1->momentum().x()*pp2->momentum().x() + pp1->momentum().y()*pp2->momentum().y(); return sqr(time)*E2 + xxScalar - sqr(time)*ppScalar; } tcParPtr pp1, pp2; }; /** * Internal helper class to keep track of ratio of distances between * original and reconected dipoles. */ struct TauRatio { /** * The constructor takes the original dipole pair as argument. */ TauRatio(const QCDDipole & d1, const QCDDipole & d2, Length Rmaxin, int optin); /** * Return the swing ratio at the given time. */ double rat(Time dt) const; /** * Return the swing ratio at the given time. */ double operator()(Time dt) const { return rat(dt); } /** * Estimate a maximum value of the swing ratio. */ double maximum(Time dt1, Time dt2) const; void plot(Time dt1, Time dt2, int N = 20) const; /** * The objects for calculating distances between the original and * reconnected dipoles. */ DeltaTau2 d1tau2, d2tau2, r1tau2, r2tau2; /** * Hadronic size to regularize large dipoles. */ Length Rmax; /** * Different options for calculating the dipole size. */ int sizeOpt; /* **** ATTENTION *** Only for debugging */ void debug() const; double chris(Time dt) const { return d1tau2.chris(dt)*d2tau2.chris(dt)/(r1tau2.chris(dt)*r2tau2.chris(dt)); } double srat; Energy2 s12, s34, s14, s32; }; 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). protected: /** * The parameter giving the rate of swinging */ double lambda; /** * The confinement scale used to prevent swinging to too large dipoles. */ Length Rmax; /** * Should we use linear or logarithmic evolution in time? */ bool linear; /** * Different options for calculating the dipole size. */ int sizeOpt; /** * Cutoff in evolution the variable, if different from the standard QCD cutoff. */ Energy theRhoCut; /** * The maximum allowed value of the evolution variable, Used to * disallow perturbative swings. Inactive if below rhoCut(). */ Energy theMaxRho; /** * Cutoff against too small string. No swing is allowed to produce * strings with invarint mass below this value. */ Energy stringMassCut; /** * The tiniest string in the dipole system if below stringMassCut. */ mutable set tinyString; /** * Previously calculated cached swings. */ mutable CacheMap cache; /** * A pointer to the DipoleState last treated. */ mutable tDipoleStatePtr lastState; /** * The uniqueId of DipoleState last treated. */ mutable unsigned long lastStateId; /** * A pointer to the last selected generated swing. */ mutable DipSwPtr lastSelected; /** * A list of swing dipoles that have been rejected and should * therefore not be tried again until something has changed in the * dipole state. */ mutable set< pair > disallowed; /** * If something has been entered in the disallowed set of dipole * pairs, this was the maximum scale when they were entered, */ mutable Energy disallowedrho; private: /** * Helper function used by the interface. */ string setRmax(string); /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - DipoleSwinger & operator=(const DipoleSwinger &); + DipoleSwinger & operator=(const DipoleSwinger &) = delete; }; } #endif /* ARIADNE5_DipoleSwinger_H */ diff --git a/Cascade/Models/FSGluonEmission.h b/Cascade/Models/FSGluonEmission.h --- a/Cascade/Models/FSGluonEmission.h +++ b/Cascade/Models/FSGluonEmission.h @@ -1,120 +1,120 @@ // -*- C++ -*- #ifndef ARIADNE5_FSGluonEmission_H #define ARIADNE5_FSGluonEmission_H // // This is the declaration of the FSGluonEmission class. // #include "Ariadne/Cascade/Emission.h" namespace Ariadne5 { using namespace ThePEG; /** * The FSGluonEmission class contains all information about a generated * and performed final state gluon emission. */ class FSGluonEmission: public Emission { public: /** @name Standard constructors and destructors. */ //@{ /** * The only relevant constructor. */ FSGluonEmission(const EmitterBase & inmodel, const DipoleBase & indipole, double iny1, double iny3) : Emission(inmodel, indipole), x1(1.0), x3(1.0), y1(iny1), y3(iny3) {} /** * The deault constructor should not normally be used. */ FSGluonEmission(): x1(1.0), x3(1.0), y1(0.0), y3(0.0) {} /** * The destructor. */ virtual ~FSGluonEmission(); //@} protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual ClonePtr 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 ClonePtr fullclone() const; //@} public: /** * The energy fraction of the anti-colour emitter (in-parton). */ double x1; /** * The energy-fraction of the colour emitter (out-parton). */ double x3; /** * The scaled mass squared of the anti-colour emitter (in-parton). */ double y1; /** * The scaled mass squared of the colour emitter (out-parton). */ double y3; 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(); private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - FSGluonEmission & operator=(const FSGluonEmission &); + FSGluonEmission & operator=(const FSGluonEmission &) = delete; }; } #endif /* ARIADNE_FSGluonEmission_H */ diff --git a/Cascade/Models/FSGluonEmitter.h b/Cascade/Models/FSGluonEmitter.h --- a/Cascade/Models/FSGluonEmitter.h +++ b/Cascade/Models/FSGluonEmitter.h @@ -1,176 +1,176 @@ // -*- C++ -*- #ifndef ARIADNE5_FSGluonEmitter_H #define ARIADNE5_FSGluonEmitter_H // // This is the declaration of the FSGluonEmitter class. // #include "Ariadne/Cascade/EmitterBase.h" #include "FSGluonEmission.h" namespace Ariadne5 { using namespace ThePEG; /** * The FSGluonEmitter class implements the standard classical gluon * emission from a final-state colour dipole. * * @see \ref FSGluonEmitterInterfaces "The interfaces" * defined for FSGluonEmitter. */ class FSGluonEmitter: public EmitterBase { public: /** * Convenient typedef. */ ThePEG_DECLARE_POINTERS(Ariadne5::FSGluonEmission,FSGEmPtr); public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ FSGluonEmitter(); /** * The destructor. */ virtual ~FSGluonEmitter(); //@} /** @name Virtual functions to be overridden by sub-classes. */ //@{ /** * Return true if and only if this model can handle the given * Emitter. */ virtual bool canHandle(const DipoleBase &) const; /** * If the given EmissionModel overlaps with this model for the given * Emitter, return true if this model should take precedence. Must * only be called for Emitters for which canHandle() is true. */ virtual bool overrides(const EmitterBase &, DipoleBase &) const; /** * Generate the a phase space point for an emission corresponding to * this model. Must only be called for Emitters for which * canHandle() is true. */ virtual EmPtr generate(const DipoleBase &, Energy rhomin, Energy rhomax) const; /** * Perform an emission previously generated for this Emitter. Must * only be called for Emitters for which canHandle() is true. * @return true if the emission was successful */ virtual bool perform(const Emission &) const; /** * Reverse a previously performed emission. Sub-classes which has * signalled that they can revert an emission but fails to do so, * must throw a Exception::runerror. */ virtual void revert(const Emission & emission) const; //@} public: /** * Generic function to generate a phase space point for a gluon * emission, \a e, given a maximum and minimum evolution scale, the * total availabel energy, \a W, a prefactor, \a C, the maximum * rapidity interval, \a yint, and the power of the exponents in the * dipole splitting function. * * @return a negative value if no emission was generated in the * given interval; zero if a point has been generated but should * subsequently be thrown aaway; and a number between 0 and one if a * point has been generated which should be kept with the * corresponding probability. */ static double gluonEngine(FSGluonEmission & e, Energy rhomin, Energy rhomax, Energy W, double C, double yint, int n1, int n3); /** * Generic function for inserting a gluon in a QCDDipole, \a d, this * creating a new dipole. The parton \a p will be assumed to be the * emitting one and the gluon will inherit its corresponding (anti-) * colour. * * @return the created gluon and the created QCDDipole. */ static pair insertGluon(QCDDipole & d, tParPtr p); /** * Remove a gluon previously added by insertGluon() */ static void removeGluon(QCDDipole & d, tParPtr g, tParPtr p); 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - FSGluonEmitter & operator=(const FSGluonEmitter &); + FSGluonEmitter & operator=(const FSGluonEmitter &) = delete; }; } #endif /* ARIADNE5_FSGluonEmitter_H */ diff --git a/Cascade/Models/FSQQEmission.h b/Cascade/Models/FSQQEmission.h --- a/Cascade/Models/FSQQEmission.h +++ b/Cascade/Models/FSQQEmission.h @@ -1,132 +1,132 @@ // -*- C++ -*- #ifndef ARIADNE5_FSQQEmission_H #define ARIADNE5_FSQQEmission_H // // This is the declaration of the FSQQEmission class. // #include "Ariadne/Cascade/Emission.h" #include "Ariadne/Cascade/QCDDipole.fh" namespace Ariadne5 { using namespace ThePEG; /** * The FSQQEmission class contains all information about a generated * and performed final state splitting of a gluon into a q-qbar pair. */ class FSQQEmission: public Emission { public: /** @name Standard constructors and destructors. */ //@{ /** * The only relevant constructor. */ FSQQEmission(const EmitterBase & inmodel, const DipoleBase & indipole, int infl, Energy inmq) : Emission(inmodel, indipole), x1(1.0), x3(1.0), mq(inmq), ifl(infl), yo(0.0) {} /** * The deault constructor should not normally be used. */ FSQQEmission(): x1(1.0), x3(1.0), mq(ZERO), ifl(0), yo(0.0) {} /** * The destructor. */ virtual ~FSQQEmission(); //@} protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual ClonePtr 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 ClonePtr fullclone() const; //@} public: /** * The energy fraction of the anti-colour emitter (in-parton). */ double x1; /** * The energy-fraction of the colour emitter (out-parton). */ double x3; /** * The mass of the quark. */ Energy mq; /** * The flavour of the quark. */ int ifl; /** * The rapidity of the anti-quark which is not considered emitted. */ double yo; /** * The other dipole involved. */ tQCDPtr od; 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(); private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - FSQQEmission & operator=(const FSQQEmission &); + FSQQEmission & operator=(const FSQQEmission &) = delete; }; } #endif /* ARIADNE5_FSQQEmission_H */ diff --git a/Cascade/Models/FSQQEmitter.h b/Cascade/Models/FSQQEmitter.h --- a/Cascade/Models/FSQQEmitter.h +++ b/Cascade/Models/FSQQEmitter.h @@ -1,189 +1,189 @@ // -*- C++ -*- #ifndef ARIADNE5_FSQQEmitter_H #define ARIADNE5_FSQQEmitter_H // // This is the declaration of the FSQQEmitter class. // #include "Ariadne/Cascade/EmitterBase.h" #include "FSQQEmission.h" namespace Ariadne5 { using namespace ThePEG; /** * The FSQQEmitter class implements the final-state splitting of gluons * into a q-qbar pair. * * @see \ref FSQQEmitterInterfaces "The interfaces" * defined for FSQQEmitter. */ class FSQQEmitter: public EmitterBase { public: /** * Convenient typedef. */ ThePEG_DECLARE_POINTERS(Ariadne5::FSQQEmission,FSQQEmPtr); public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ FSQQEmitter(); /** * The destructor. */ virtual ~FSQQEmitter(); //@} /** @name Virtual functions to be overridden by sub-classes. */ //@{ /** * Return true if and only if this model can handle the given * Emitter. */ virtual bool canHandle(const DipoleBase &) const; /** * If the given EmissionModel overlaps with this model for the given * Emitter, return true if this model should take precedence. Must * only be called for Emitters for which canHandle() is true. */ virtual bool overrides(const EmitterBase &, DipoleBase &) const; /** * Check if objects related to the given \a dipole have been touched * in a way such that emissions must be regenerated. */ virtual bool touched(const DipoleBase & dipole) const; /** * Generate the a phase space point for an emission corresponding to * this model. Must only be called for Emitters for which * canHandle() is true. */ virtual EmPtr generate(const DipoleBase &, Energy rhomin, Energy rhomax) const; /** * Perform an emission previously generated for this Emitter. Must * only be called for Emitters for which canHandle() is true. * @return true if the emission was successful */ virtual bool perform(const Emission &) const; /** * Reverse a previously performed emission. Sub-classes which has * signalled that they can revert an emission but fails to do so, * must throw a Exception::runerror. */ virtual void revert(const Emission & emission) const; //@} public: /** * Generic function to generate a phase space point for a gluon * splitting, \a e, given a maximum and minimum evolution scale, the * total availabel energy, \a W, a prefactor, \a C, the maximum * rapidity interval, \a yint, and the scaled masses of the partons, * \a sy1 and \a syq. * * @return a negative value if no emission was generated in the * given interval; zero if a point has been generated but should * subsequently be thrown aaway; and a number between 0 and one if a * point has been generated which should be kept with the * corresponding probability. */ static double qqbarEngine(FSQQEmission & e, Energy rhomin, Energy rhomax, Energy W, double C, double yint, double sy1, double syq); /** * Split the given \a gluon in a \a dipole into a q-qbar pair with * flavour ifl. * * @return a pair of partons where the first is the quark and the * second is the anti-quark. */ static pair splitGluon(QCDDipole & dipole, tParPtr gluon, int ifl); /** * Fuse a \a q and \a qbar into a gluon as if previously split by * splitGluon. If actually a previous split, \a gluon must be * non-zero. \a d is the dipole connecting to either the \a q or the * \a qbar, while \a od is the other dipole. * * @return the gluon. */ static tParPtr fuseQQBar(QCDDipole & d, tParPtr q, tParPtr qbar, tQCDPtr od, tParPtr gluon); 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - FSQQEmitter & operator=(const FSQQEmitter &); + FSQQEmitter & operator=(const FSQQEmitter &) = delete; }; } #endif /* ARIADNE5_FSQQEmitter_H */ diff --git a/Cascade/Models/ISGtoQEmission.h b/Cascade/Models/ISGtoQEmission.h --- a/Cascade/Models/ISGtoQEmission.h +++ b/Cascade/Models/ISGtoQEmission.h @@ -1,87 +1,87 @@ // -*- C++ -*- #ifndef ARIADNE5_ISGtoQEmission_H #define ARIADNE5_ISGtoQEmission_H // // This is the declaration of the ISGtoQEmission class. // #include "ISQEmission.h" namespace Ariadne5 { using namespace ThePEG; /** * The ISGtoQEmission class contains all information about a generated * and performed initial-state gluon splitting into a q-qbar pair. */ class ISGtoQEmission: public ISQEmission { public: /** @name Standard constructors and destructors. */ //@{ /** * The only relevant constructor. */ ISGtoQEmission(const EmitterBase & inmodel, const DipoleBase & indipole, tRemParPtr rem, tcPDPtr qin, Energy mqin, const Lorentz5Momentum & ph) : ISQEmission(inmodel, indipole, rem, ph) { q = qin; mq = mqin; pold.first = rem->momentum(); pold.second = ph; } /** * The deault constructor should not normally be used. */ ISGtoQEmission() {} /** * The destructor. */ virtual ~ISGtoQEmission(); //@} protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual ClonePtr 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 ClonePtr fullclone() const; //@} public: /** * 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(); private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ISGtoQEmission & operator=(const ISGtoQEmission &); + ISGtoQEmission & operator=(const ISGtoQEmission &) = delete; }; } #endif /* ARIADNE5_ISGtoQEmission_H */ diff --git a/Cascade/Models/ISGtoQEmitter.h b/Cascade/Models/ISGtoQEmitter.h --- a/Cascade/Models/ISGtoQEmitter.h +++ b/Cascade/Models/ISGtoQEmitter.h @@ -1,146 +1,146 @@ // -*- C++ -*- #ifndef ARIADNE5_ISGtoQEmitter_H #define ARIADNE5_ISGtoQEmitter_H // // This is the declaration of the ISGtoQEmitter class. // #include "ISQEmitter.h" #include "ISGtoQEmission.h" namespace Ariadne5 { using namespace ThePEG; /** * The ISGtoQEmitter class implements the initial-state splitting of gluons * into a q-qbar pair. * * @see \ref ISGtoQEmitterInterfaces "The interfaces" * defined for ISGtoQEmitter. */ class ISGtoQEmitter: public ISQEmitter { public: /** * Convenient typedef. */ ThePEG_DECLARE_POINTERS(Ariadne5::ISGtoQEmission,ISGtoQEmPtr); public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ ISGtoQEmitter(); /** * The destructor. */ virtual ~ISGtoQEmitter(); //@} /** @name Virtual functions to be overridden by sub-classes. */ //@{ /** * Return true if and only if this model can handle the given * Emitter. */ virtual bool canHandle(const DipoleBase &) const; /** * Generate the a phase space point for an emission corresponding to * this model. Must only be called for Emitters for which * canHandle() is true. */ virtual EmPtr generate(const DipoleBase &, Energy rhomin, Energy rhomax) const; /** * Perform an emission previously generated for this Emitter. Must * only be called for Emitters for which canHandle() is true. * @return true if the emission was successful */ virtual bool perform(const Emission &) const; /** * Reverse a previously performed emission. Sub-classes which has * signalled that they can revert an emission but fails to do so, * must throw a Exception::runerror. */ virtual void revert(const Emission & emission) const; //@} public: /** * Helper function for the main generate function implementing * genetation from a given remnant parton. */ virtual EmPtr generate(tRemParPtr rem, const QCDDipole & d, Energy rhomin, Energy rhomax) 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); //@} /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ISGtoQEmitter & operator=(const ISGtoQEmitter &); + ISGtoQEmitter & operator=(const ISGtoQEmitter &) = delete; }; } #endif /* ARIADNE5_ISGtoQEmitter_H */ diff --git a/Cascade/Models/ISQEmission.h b/Cascade/Models/ISQEmission.h --- a/Cascade/Models/ISQEmission.h +++ b/Cascade/Models/ISQEmission.h @@ -1,141 +1,141 @@ // -*- C++ -*- #ifndef ARIADNE5_ISQEmission_H #define ARIADNE5_ISQEmission_H // // This is the declaration of the ISQEmission class. // #include "Ariadne/Cascade/Emission.h" #include "Ariadne/Cascade/QCDDipole.fh" #include "Ariadne/Cascade/RemnantParton.h" namespace Ariadne5 { using namespace ThePEG; /** * The ISQEmission class contains all information about a generated * and performed initial-state quark emissions. */ class ISQEmission: public Emission { public: /** @name Standard constructors and destructors. */ //@{ /** * The only relevant constructor. */ ISQEmission(const EmitterBase & inmodel, const DipoleBase & indipole, tRemParPtr rem, const Lorentz5Momentum & ph) : Emission(inmodel, indipole), q(tcPDPtr()), mq(ZERO), x(rem->x()), exorig(&rem->extractedData()), z(1.0), xi(0.0) { pold.first = rem->momentum(); pold.second = ph; } /** * The deault constructor should not normally be used. */ ISQEmission() {} /** * The destructor. */ virtual ~ISQEmission(); //@} protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual ClonePtr 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 ClonePtr fullclone() const; //@} public: /** * The type of the emitted quark. */ tcPDPtr q; /** * The mass of the emitted quark. */ Energy mq; /** * Original x-value. */ double x; /** * Original extracted parton. */ tcPDPtr exorig; /** * The energy splitting. */ double z; /** * The lightcone fraction taken by the original hard subsystem- */ double xi; /** * The rotation of the hard sub-system */ mutable LorentzRotation Rh; 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(); private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ISQEmission & operator=(const ISQEmission &); + ISQEmission & operator=(const ISQEmission &) = delete; }; } #endif /* ARIADNE5_ISQEmission_H */ diff --git a/Cascade/Models/ISQEmitter.h b/Cascade/Models/ISQEmitter.h --- a/Cascade/Models/ISQEmitter.h +++ b/Cascade/Models/ISQEmitter.h @@ -1,135 +1,135 @@ // -*- C++ -*- #ifndef ARIADNE5_ISQEmitter_H #define ARIADNE5_ISQEmitter_H // // This is the declaration of the ISQEmitter class. // #include "Ariadne/Cascade/EmitterBase.h" #include "Ariadne/Cascade/RemnantParton.h" #include "ISQEmission.h" namespace Ariadne5 { using namespace ThePEG; /** * The ISQEmitter class implements common functions for initial-state * quark emissions. * * @see \ref ISQEmitterInterfaces "The interfaces" * defined for ISQEmitter. */ class ISQEmitter: public EmitterBase { public: /** * Convenient typedef */ typedef vector< pair > PDFLimits; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ ISQEmitter(); /** * The destructor. */ virtual ~ISQEmitter(); //@} /** @name Virtual functions to be overridden by sub-classes. */ //@{ /** * If the given EmissionModel overlaps with this model for the given * Emitter, return true if this model should take precedence. Must * only be called for Emitters for which canHandle() is true. */ virtual bool overrides(const EmitterBase &, DipoleBase &) const; //@} public: /** * Called by perform in sub-classes to set momenta. */ virtual void setMom(QCDDipole & d, const ISQEmission & e, tRemParPtr rem, tcPDPtr qex) const; /** * Called by revert in sub-classes to reset momenta. */ virtual void revertMom(QCDDipole & d, const ISQEmission & e, tRemParPtr rem) const; /** * Helper function to define maximum PDF ratios in suitable mt2 * intervals. */ PDFLimits maxPDFRatios(tRemParPtr rem, Energy2 mt2max, Energy2 mt2min, tcPDPtr g, Energy2 s, Energy2 mh2, Energy2 mq2, Energy2 Q2 = ZERO) const; public: /** Exception class in case there is not enough energy to emit any quark. */ struct KinematicsException: public Exception {}; /** Exception class in case the PDF ratio wwas not properly overestimated. */ struct WeightException: public Exception {}; 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(); // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). protected: /** * Maximum x-value above which PDF-ratios above the maximum is * silently ignored. */ double maxPDFX; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ISQEmitter & operator=(const ISQEmitter &); + ISQEmitter & operator=(const ISQEmitter &) = delete; }; } #endif /* ARIADNE5_ISQEmitter_H */ diff --git a/Cascade/Models/ISQtoGEmission.h b/Cascade/Models/ISQtoGEmission.h --- a/Cascade/Models/ISQtoGEmission.h +++ b/Cascade/Models/ISQtoGEmission.h @@ -1,107 +1,107 @@ // -*- C++ -*- #ifndef ARIADNE5_ISQtoGEmission_H #define ARIADNE5_ISQtoGEmission_H // // This is the declaration of the ISQtoGEmission class. // #include "ISQEmission.h" namespace Ariadne5 { using namespace ThePEG; /** * The ISQtoGEmission class contains all information about a generated * and performed initial-state splitting of a quark into an * initial-state gluon and a final-state quark. */ class ISQtoGEmission: public ISQEmission { public: /** @name Standard constructors and destructors. */ //@{ /** * The only relevant constructor. */ ISQtoGEmission(const EmitterBase & inmodel, const DipoleBase & indipole, tRemParPtr rem, const Lorentz5Momentum & ph) : ISQEmission(inmodel, indipole, rem, ph) {} /** * The deault constructor should not normally be used. */ ISQtoGEmission() {} /** * The destructor. */ virtual ~ISQtoGEmission(); //@} protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual ClonePtr 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 ClonePtr fullclone() const; //@} public: /** * The neighboring dipole needed to revert an emission. */ tQCDPtr od; 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); //@} public: /** * 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(); private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ISQtoGEmission & operator=(const ISQtoGEmission &); + ISQtoGEmission & operator=(const ISQtoGEmission &) = delete; }; } #endif /* ARIADNE5_ISQtoGEmission_H */ diff --git a/Cascade/Models/ISQtoGEmitter.h b/Cascade/Models/ISQtoGEmitter.h --- a/Cascade/Models/ISQtoGEmitter.h +++ b/Cascade/Models/ISQtoGEmitter.h @@ -1,145 +1,145 @@ // -*- C++ -*- #ifndef ARIADNE5_ISQtoGEmitter_H #define ARIADNE5_ISQtoGEmitter_H // // This is the declaration of the ISQtoGEmitter class. // #include "ISQEmitter.h" #include "ISQtoGEmission.h" namespace Ariadne5 { using namespace ThePEG; /** * The ISQtoGEmitter class implements the initial-state splitting of a * quark into an initial-state gluon and a final-state quark. * * @see \ref ISQtoGEmitterInterfaces "The interfaces" * defined for ISQtoGEmitter. */ class ISQtoGEmitter: public ISQEmitter { public: /** * Convenient typedef. */ ThePEG_DECLARE_POINTERS(Ariadne5::ISQtoGEmission,ISQtoGEmPtr); public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ ISQtoGEmitter(); /** * The destructor. */ virtual ~ISQtoGEmitter(); //@} /** @name Virtual functions to be overridden by sub-classes. */ //@{ /** * Return true if and only if this model can handle the given * Emitter. */ virtual bool canHandle(const DipoleBase &) const; /** * Generate the a phase space point for an emission corresponding to * this model. Must only be called for Emitters for which * canHandle() is true. */ virtual EmPtr generate(const DipoleBase &, Energy rhomin, Energy rhomax) const; /** * Perform an emission previously generated for this Emitter. Must * only be called for Emitters for which canHandle() is true. * @return true if the emission was successful */ virtual bool perform(const Emission &) const; /** * Reverse a previously performed emission. Sub-classes which has * signalled that they can revert an emission but fails to do so, * must throw a Exception::runerror. */ virtual void revert(const Emission & emission) const; //@} public: /** * Helper function for the main generate function implementing * genetation from a given remnant parton. */ virtual ISQtoGEmPtr generate(tRemParPtr rem, const QCDDipole & d, Energy rhomin, Energy rhomax) 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); //@} /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ISQtoGEmitter & operator=(const ISQtoGEmitter &); + ISQtoGEmitter & operator=(const ISQtoGEmitter &) = delete; }; } #endif /* ARIADNE5_ISQtoGEmitter_H */ diff --git a/Cascade/Models/RRGluonEmission.h b/Cascade/Models/RRGluonEmission.h --- a/Cascade/Models/RRGluonEmission.h +++ b/Cascade/Models/RRGluonEmission.h @@ -1,181 +1,181 @@ // -*- C++ -*- #ifndef ARIADNE5_RRGluonEmission_H #define ARIADNE5_RRGluonEmission_H // // This is the declaration of the RRGluonEmission class. // #include "FSGluonEmission.h" #include "Ariadne/Cascade/EmitterBase.h" #include "ThePEG/Utilities/UtilityBase.h" namespace Ariadne5 { using namespace ThePEG; /** * The RRGluonEmission class contains all information about a * generated and performed final state gluon emission from a remnant * parton. */ class RRGluonEmission: public FSGluonEmission { public: /** @name Standard constructors and destructors. */ //@{ /** * The constructor relevant for real emissions. */ RRGluonEmission(const EmitterBase & inmodel, const DipoleBase & indipole, tRemParPtr inrem1, tRemParPtr inrem3, const Lorentz5Momentum & inph) : FSGluonEmission(inmodel, indipole, 0.0, 0.0), rem1(inrem1), rem3(inrem3), mh2(inph.mass2()), oph(inph), ophr1(inrem1->getBoost()*inph), ophr3(inrem3->getBoost()*inph), ph(inph) { pold = make_pair(rem1->momentum(), rem3->momentum()); Rrcm = Utilities::getBoostToCM(pold); Rircm = Rrcm.inverse(); ophr = Rrcm*oph; opr1 = rem1->getBoost()*pold.first; opr3 = rem3->getBoost()*pold.second; } /** * The deault constructor should not normally be used. */ RRGluonEmission() {} /** * The destructor. */ virtual ~RRGluonEmission(); //@} protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual ClonePtr 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 ClonePtr fullclone() const; //@} public: /** * Remnant 1 */ tRemParPtr rem1; /** * Remnant 3 */ tRemParPtr rem3; /** * The squared mass of the hard sub-system. */ Energy2 mh2; /** * The momentum of the hard sub-system before the emission. */ Lorentz5Momentum oph; /** * The momentum of the hard sub-system before the emission in the * remnants rest system. */ Lorentz5Momentum ophr; /** * The momentum of the hard sub-system before the emission in the * system of remnant 1. */ Lorentz5Momentum ophr1; /** * The momentum of the hard sub-system before the emission in the * system of remnant 3. */ Lorentz5Momentum ophr3; /** * The momentum of the remnant 1 in its own system */ Lorentz5Momentum opr1; /** * The momentum of the remnant 3 in its own system */ Lorentz5Momentum opr3; /** * The momentum of the hard sub-system after the emission. */ Lorentz5Momentum ph; /** * The rotation of the hard sub-system giving oph -> ph */ mutable LorentzRotation Rh; /** * The rotation from the lab system to the remnants rest frame. */ LorentzRotation Rrcm; /** * The inverse rotation from the lab system to the remnants rest frame. */ LorentzRotation Rircm; 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(); private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - RRGluonEmission & operator=(const RRGluonEmission &); + RRGluonEmission & operator=(const RRGluonEmission &) = delete; }; } #endif /* ARIADNE_RRGluonEmission_H */ diff --git a/Cascade/Models/RRGluonEmitter.h b/Cascade/Models/RRGluonEmitter.h --- a/Cascade/Models/RRGluonEmitter.h +++ b/Cascade/Models/RRGluonEmitter.h @@ -1,157 +1,157 @@ // -*- C++ -*- #ifndef ARIADNE5_RRGluonEmitter_H #define ARIADNE5_RRGluonEmitter_H // // This is the declaration of the RRGluonEmitter class. // #include "Ariadne/Cascade/EmitterBase.h" #include "RRGluonEmission.h" #include "ISGtoQEmitter.h" namespace Ariadne5 { using namespace ThePEG; /** * The RRGluonEmitter class implements the emission of gluons from a * remnant-remnant dipole. * * @see \ref RRGluonEmitterInterfaces "The interfaces" * defined for RRGluonEmitter. */ class RRGluonEmitter: public ISGtoQEmitter { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ RRGluonEmitter(); /** * The destructor. */ virtual ~RRGluonEmitter(); //@} /** @name Virtual functions to be overridden by sub-classes. */ //@{ /** * Return true if and only if this model can handle the given * Emitter. */ virtual bool canHandle(const DipoleBase &) const; /** * If the given EmissionModel overlaps with this model for the given * Emitter, return true if this model should take precedence. Must * only be called for Emitters for which canHandle() is true. */ virtual bool overrides(const EmitterBase &, DipoleBase &) const; /** * Generate the a phase space point for an emission corresponding to * this model. Must only be called for Emitters for which * canHandle() is true. */ virtual EmPtr generate(const DipoleBase &, Energy rhomin, Energy rhomax) const; /** * Perform an emission previously generated for this Emitter. Must * only be called for Emitters for which canHandle() is true. * @return true if the emission was successful */ virtual bool perform(const Emission &) const; /** * Reverse a previously performed emission. Sub-classes which has * signalled that they can revert an emission but fails to do so, * must throw a Exception::runerror. */ virtual void revert(const Emission & emission) const; //@} public: /** * Generate the a phase space point for a gluon emission. */ static double gluonEngineRR(RRGluonEmission & e, Energy rhomin, Energy rhomax, Energy W, double C, double yint, int n1, int n3); /** * Perform an emission previously generated by generateG. */ static bool performRRG(const RRGluonEmission & e); /** * Undo an emission previously generated by performG. */ static void revertRRG(const RRGluonEmission & e); public: 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - RRGluonEmitter & operator=(const RRGluonEmitter &); + RRGluonEmitter & operator=(const RRGluonEmitter &) = delete; }; } #endif /* ARIADNE5_RRGluonEmitter_H */ diff --git a/Cascade/Models/RecoilGluonEmitter.h b/Cascade/Models/RecoilGluonEmitter.h --- a/Cascade/Models/RecoilGluonEmitter.h +++ b/Cascade/Models/RecoilGluonEmitter.h @@ -1,157 +1,157 @@ // -*- C++ -*- #ifndef ARIADNE5_RecoilGluonEmitter_H #define ARIADNE5_RecoilGluonEmitter_H // // This is the declaration of the RecoilGluonEmitter class. // #include "FSGluonEmitter.h" #include "RemnantGluonEmission.h" namespace Ariadne5 { using namespace ThePEG; /** * The RecoilGluonEmitter class implements the emission of recoil * gluons from a remnant dipoles. * * @see \ref RecoilGluonEmitterInterfaces "The interfaces" * defined for RecoilGluonEmitter. */ class RecoilGluonEmitter: public EmitterBase { public: /** * Convenient typedef. */ ThePEG_DECLARE_POINTERS(Ariadne5::RemnantGluonEmission,RemGEmPtr); public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ RecoilGluonEmitter(); /** * The destructor. */ virtual ~RecoilGluonEmitter(); //@} /** @name Virtual functions to be overridden by sub-classes. */ //@{ /** * Return true if and only if this model can handle the given * Emitter. */ virtual bool canHandle(const DipoleBase &) const; /** * If the given EmissionModel overlaps with this model for the given * Emitter, return true if this model should take precedence. Must * only be called for Emitters for which canHandle() is true. */ virtual bool overrides(const EmitterBase &, DipoleBase &) const; /** * Generate the a phase space point for an emission corresponding to * this model. Must only be called for Emitters for which * canHandle() is true. */ virtual EmPtr generate(const DipoleBase &, Energy rhomin, Energy rhomax) const; /** * Perform an emission previously generated for this Emitter. Must * only be called for Emitters for which canHandle() is true. * @return true if the emission was successful */ virtual bool perform(const Emission &) const; /** * Reverse a previously performed emission. Sub-classes which has * signalled that they can revert an emission but fails to do so, * must throw a Exception::runerror. */ virtual void revert(const Emission & emission) 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); //@} /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). public: /** * Indicate that something goes wrong with the recoil gluon. */ struct InconsistentReoilGluon: public Exception {}; /** * Exception class indicating no model could be found for special * parton. */ struct MissingModel: public Exception {}; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - RecoilGluonEmitter & operator=(const RecoilGluonEmitter &); + RecoilGluonEmitter & operator=(const RecoilGluonEmitter &) = delete; }; } #endif /* ARIADNE5_RecoilGluonEmitter_H */ diff --git a/Cascade/Models/RemnantGluonEmission.h b/Cascade/Models/RemnantGluonEmission.h --- a/Cascade/Models/RemnantGluonEmission.h +++ b/Cascade/Models/RemnantGluonEmission.h @@ -1,121 +1,121 @@ // -*- C++ -*- #ifndef ARIADNE5_RemnantGluonEmission_H #define ARIADNE5_RemnantGluonEmission_H // // This is the declaration of the RemnantGluonEmission class. // #include "FSGluonEmission.h" #include "Ariadne/Cascade/EmitterBase.h" namespace Ariadne5 { using namespace ThePEG; /** * The RemnantGluonEmission class contains all information about a * generated and performed final state gluon emission from a remnant * parton. */ class RemnantGluonEmission: public FSGluonEmission { public: /** @name Standard constructors and destructors. */ //@{ /** * The constructor relevant for real emissions. */ RemnantGluonEmission(const EmitterBase & inmodel, const DipoleBase & indipole, double iny1, double iny3) : FSGluonEmission(inmodel, indipole, iny1, iny3), isRecoil(false) {} /** * The constructor relevant for recoil emissions. */ RemnantGluonEmission(const EmitterBase & inmodel, const DipoleBase & indipole) : FSGluonEmission(inmodel, indipole, 0.0, 0.0), isRecoil(true) {} /** * The deault constructor should not normally be used. */ RemnantGluonEmission() {} /** * The destructor. */ virtual ~RemnantGluonEmission(); //@} protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual ClonePtr 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 ClonePtr fullclone() const; //@} public: /** * True if this corresponds to the emission of a remnant gluon. */ bool isRecoil; /** * The rotation of the hard sub-system */ mutable LorentzRotation Rh; 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(); private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - RemnantGluonEmission & operator=(const RemnantGluonEmission &); + RemnantGluonEmission & operator=(const RemnantGluonEmission &) = delete; }; } #endif /* ARIADNE_RemnantGluonEmission_H */ diff --git a/Cascade/Models/RemnantGluonEmitter.h b/Cascade/Models/RemnantGluonEmitter.h --- a/Cascade/Models/RemnantGluonEmitter.h +++ b/Cascade/Models/RemnantGluonEmitter.h @@ -1,177 +1,177 @@ // -*- C++ -*- #ifndef ARIADNE5_RemnantGluonEmitter_H #define ARIADNE5_RemnantGluonEmitter_H // // This is the declaration of the RemnantGluonEmitter class. // #include "FSGluonEmitter.h" #include "RemnantGluonEmission.h" namespace Ariadne5 { using namespace ThePEG; /** * The RemnantGluonEmitter class implements the soft gluon radiation * from a remnant dipole. * * @see \ref RemnantGluonEmitterInterfaces "The interfaces" * defined for RemnantGluonEmitter. */ class RemnantGluonEmitter: public EmitterBase { public: /** * Convenient typedef. */ ThePEG_DECLARE_POINTERS(Ariadne5::RemnantGluonEmission,RemGEmPtr); public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ RemnantGluonEmitter(); /** * The destructor. */ virtual ~RemnantGluonEmitter(); //@} /** @name Virtual functions to be overridden by sub-classes. */ //@{ /** * Return true if and only if this model can handle the given * Emitter. */ virtual bool canHandle(const DipoleBase &) const; /** * If the given EmissionModel overlaps with this model for the given * Emitter, return true if this model should take precedence. Must * only be called for Emitters for which canHandle() is true. */ virtual bool overrides(const EmitterBase &, DipoleBase &) const; /** * Generate the a phase space point for an emission corresponding to * this model. Must only be called for Emitters for which * canHandle() is true. */ virtual EmPtr generate(const DipoleBase &, Energy rhomin, Energy rhomax) const; /** * Perform an emission previously generated for this Emitter. Must * only be called for Emitters for which canHandle() is true. * @return true if the emission was successful */ virtual bool perform(const Emission &) const; /** * Reverse a previously performed emission. Sub-classes which has * signalled that they can revert an emission but fails to do so, * must throw a Exception::runerror. */ virtual void revert(const Emission & emission) const; //@} public: /** * Generate an initial-state type gluon emission. If \a iside is * true this is the iPart() of the emitting dipole. */ virtual EmPtr generateInitialStateGluon(const QCDDipole & dip, tRemParPtr rem, Energy rhomin, Energy rhomax) const; /** * Perform an emission previously generated by generateInitialStateGluon(). */ bool performInitialStateGluon(const RemnantGluonEmission & e) const; /** * Revert an emission previously done by performInitialStateGluon(). */ void revertInitialStateGluon(const RemnantGluonEmission & e) 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); //@} /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). public: /** * Indicate that something goes wrong with the recoil gluon. */ struct InconsistentReoilGluon: public Exception {}; /** * Exception class indicating no model could be found for special * parton. */ struct MissingModel: public Exception {}; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - RemnantGluonEmitter & operator=(const RemnantGluonEmitter &); + RemnantGluonEmitter & operator=(const RemnantGluonEmitter &) = delete; }; } #endif /* ARIADNE5_RemnantGluonEmitter_H */ diff --git a/Cascade/Models/RemnantModel.h b/Cascade/Models/RemnantModel.h --- a/Cascade/Models/RemnantModel.h +++ b/Cascade/Models/RemnantModel.h @@ -1,363 +1,363 @@ // -*- C++ -*- #ifndef Ariadne5_RemnantModel_H #define Ariadne5_RemnantModel_H // // This is the declaration of the RemnantModel class. // #include "RemnantModel.fh" #include "RemnantGluonEmission.h" #include "ISGtoQEmission.h" #include "ThePEG/Handlers/HandlerBase.h" #include "Ariadne/Cascade/Emission.h" #include "Ariadne/Cascade/RemnantParton.h" #include "Ariadne/Cascade/QCDDipole.h" #include "PseudoParton.h" #include "ThePEG/EventRecord/ParticleTraits.h" #include "ThePEG/Utilities/SimplePhaseSpace.h" namespace Ariadne5 { using namespace ThePEG; /** * RemnantModel is a helper class for emission models dealing with * RemnantParton objects. This base class implements the default model * for emitting a recoil gluon from a remnant that has received a * transverse momentum kick. Furhter more it can emit initial-state * type radiation between the hard sub-system and a remnant as well as * vetoing or reweighting any other emission from a dipole connected * to the remnant. * * @see \ref RemnantModelInterfaces "The interfaces" * defined for RemnantModel. */ class RemnantModel: public HandlerBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ RemnantModel(); /** * The destructor. */ virtual ~RemnantModel(); //@} public: /** * Return a pseudo-parton to be used in Emitter class for * quasi-standard emissions. */ virtual PseudoParton getPseudoParton(tRemParPtr rem) const; /** * Calculate a weight of an emission is generated from a dipole with * remnant \a rem giving a parton with momentum \a pem. \a prem is * the momentum of the remnant after the emission. Veto if it is not * considered a final-state splitting, otherwise reweight if too * much momentum is taken from the remnant. Optionally an \a * extracted flavour may be supplied if the emission was an initial * state g->q or q->g splitting. */ virtual double reweightFS(tcRemParPtr rem, Energy rho, LorentzMomentum pem, LorentzMomentum prem, tcPDPtr extracted = tcPDPtr()) const; /** * Return the effective mass of the given remnant to ensure that * there is sufficient energy to create relevant hadrons. Optionally * supply a new parton to be \a extracted. For hardon remnants this * version will return twice the mass of the incoming particle plus * the mass of the extracted parton. Otherwise returns zero. */ virtual Energy effectiveMass(tcRemParPtr rem, tcPDPtr extracted = tcPDPtr()) const; public: /** * Return the soft suppression weight for an emission at scale \a * rho, taking a fraction xplus of the positive momentum of the * incoming particle. \a x is the previous extracted momentum * fraction. */ double softSuppression(Energy rho, double xplus, double x, Energy mu, double alpha, double spow) const; /** * If an emission from a remnant dipole results in a remnant with * large transverse momentum, return a weight corresponding to the * penalty. The arguments are the momentum of the \a hard subsystem, * the momentum of the \a remnant with a large transverse momentum, * and the pointer to the remnant, \a rem. Optionally an \a * extracted flavour may be supplied if the emission was an initial * state g->q or q->g splitting. Note that the momenta must be given * in the system corresponding to rem->getBoost(). */ double recoilWeight(const LorentzMomentum & hard, const LorentzMomentum & remnant, tcRemParPtr rem, tcPDPtr extracted = tcPDPtr()) const; /** * If an emission from a remnant dipole results in a remnat with * large transverse momentum, return minimm and maximum allowed * positive light-cone momenta for a recoil gluon to be emitted to * put the remnant along +z-axis. Arguments are the momentum, \a ph, * of the hard sub-system, the momentum \a pr, of the remnant and * the effective mass of the remnant, \a effMr. */ pair recoilPlusLimit(const LorentzMomentum & ph, const LorentzMomentum & pr, Energy effMr) const; /** * If the remnant \a rem of the dipole \a dip previously has * received a transverse momentum kick, generator the emission of a * recoil gluon to get rid of the kick. */ virtual EmPtr generateRecoilGluon(const EmitterBase & em, const QCDDipole & dip, tRemParPtr rem, Energy rhomin, Energy rhomax) const; /** * Perform an emission previously generated by generateRecoilGluon(). */ virtual bool performRecoilGluon(const RemnantGluonEmission & e) const; /** * Revert an emission previously done by performRecoilGluon(). */ virtual void revertRecoilGluon(const RemnantGluonEmission & e) const; /** * If the remnant \a rem of the dipole \a dip previously an * extracted heavy quark (with mass above the cutoff) generate a * forced emission of that quark with the scale given by tits mass.. */ virtual EmPtr generateForcedHeavyQuark(const EmitterBase & em, const QCDDipole & dip, tRemParPtr rem, Energy rhomin, Energy rhomax) const; /** * Perform a ISGtoQEmitter. */ virtual bool performGtoQ(const ISGtoQEmission & e) const; /** * Revert a ISGtoQEmitter. */ virtual void revertGtoQ(const ISGtoQEmission & e) const; /** * Set the positive and negative light-cone components of the two * given momenta so that their sum is given by \a plus and \a * minus. The first momenta is given the largest positive * component. The transverse momenta and the masses are left * untouched. */ template static void setLightCones(PType & p1in, PType & p2in, Energy plus, Energy minus) { typedef ParticleTraits Traits; Lorentz5Momentum p1 = Traits::momentum(p1in); Lorentz5Momentum p2 = Traits::momentum(p2in); Energy2 mt12 = p1.mt2(); Energy2 mt22 = p2.mt2(); Energy4 squarg = sqr(plus*minus + mt12 - mt22) - 4.0*mt12*plus*minus; if ( squarg < ZERO ) throw ImpossibleKinematics(); Energy pp1 = 0.5*(sqrt(squarg) + plus*minus + mt12 - mt22)/minus; p1 = lightCone5(pp1, mt12/pp1, p1.x(), p1.y()); Energy pm2 = minus - mt12/pp1; p2 = lightCone5(mt22/pm2, pm2, p2.x(), p2.y()); Traits::set5Momentum(p1in, p1); Traits::set5Momentum(p2in, p2); } /** * Return the minimum shat of the new hard subsystem when emitting in * the initial state a particle with transverse mass squared, \a mt2, a * mass squared, \a mq2, where the original hard subsystem has * invariant mass, \a mh2. */ static Energy2 shmin(Energy2 mt2, Energy2 mq2, Energy2 mh2) { return sqr(sqrt(mt2) + sqrt(mt2 - mq2 + mh2)); } /** * Return the maximum z of the new hard subsystem when emitting in * the initial state a particle with transverse mass squared, \a * mt2, a mass squared, \a mq2, where the original hard subsystem * has invariant mass, \a mh2, and, optionally, there is a * virtuality, \a Q2 on the other side. */ static double zmax(Energy2 mt2, Energy2 mq2, Energy2 mh2, Energy2 Q2 = ZERO) { return (mh2 + Q2)/(shmin(mt2, mq2, mh2) + Q2); } /** * Return the maximum rapidity of a particle emitted in the initial * state with transverse mass squared, \a mt2, a mass squared, \a * mq2, where the original hard subsystem has invariant mass, \a * mh2, and the total available invariant mass squared is \a * S. Returns a negativ number if kinematically impossible. */ static double ymax(Energy2 mt2, Energy2 mq2, Energy2 mh2, Energy2 S) { double arg = (S + mq2 - mh2)/sqrt(mt2*S); return arg >= 1.0? acosh(arg/2.0): -1.0; } /** * Return the Jacobian for transforming from the (mass corrected) * logarithmic virtuality, |\a k2| + \a mq2, and energy fraction \a * z to rapidity and logarithmic transverse mass squared. \a mh2 is * the mass squared of the hard sub-system, \a mq2 is the mass of * the particle emitten in the initial state, and \a Q2 is the * virtuality of the opposing side. The value of this is always * below 1/4 + mq2/(mh2 + Q2). */ static double Jk2z(double z, Energy2 mq2, Energy2 mh2, Energy2 Q2 = ZERO) { return z*((mh2 + Q2)*(1.0 - z) + mq2*z)/(mh2 + Q2); } /** * Return the Jacobian for transforming from the energy fractions, * \a xi and \a z to rapidity and logarithmic transverse mass * squared. \a mh2 is the mass squared of the hard sub-system, \a * mq2 is the mass of the particle emitten in the initial state, and * \a Q2 is the virtuality of the opposing side. The value of this * is always below 1/4 + mq2/(mh2 + Q2). */ static double Jxiz(double xi, double z, Energy2 mq2, Energy2 mh2, Energy2 Q2 = ZERO) { return (1.0 - xi)*z*((mh2 + Q2)*(1.0 - z) + mq2*z)/(mh2 + Q2); } /** * Calculate the value of xi. */ static double xiFn(Energy2 mt2, double y, Energy2 S) { return 1.0 - sqrt(mt2/S)*exp(-y); } /** * Calculate the value of z. */ static double zFn(Energy2 mt2, double xi, Energy2 mq2, Energy2 mh2, Energy2 Q2 = ZERO) { return xi*(mh2 + Q2)*(1.0 - xi)/ (mt2 + (mh2 - mq2)*(1.0 - xi) + Q2*xi*(1.0 - xi)); } /** * Return the momenta corresponding to the emission in the initial * state from a remnant with momentum \a pr and the hard sub-system * with momentum \a ph and invariant mass squared \a mh2. \a kt2 is * the squared transverse momentum, \a phi is the azimuth angle and * \a mq2 is the mass of the emitted parton. \a xi is the fraction * of the sub-system light-cone momenta retained after the * emission. \a S is the total invariant mass squared. */ static Triplet getMomenta(Energy2 S, Energy2 kt2, double xi, double phi, Energy2 mq2, Energy2 mh2, const Lorentz5Momentum & pr, const Lorentz5Momentum & ph); /** * Set momenta of the \a remnant and the hard sub-system according * to the given \a emission, where \a qex is extracted from the * remnant. */ static void setMom(QCDDipole & d, const ISQEmission & e, tRemParPtr rem, tcPDPtr qex); /** * Revert what was done by setMom. */ static void revertMom(QCDDipole & d, const ISQEmission & e, tRemParPtr rem); public: /** @name Functions used bythe 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). public: /** * Indicate that something goes wrong with the recoil gluon. */ struct InconsistentRecoilGluon: public Exception {}; /** * Indicate that something goes wrong with the forced heavy quark emission. */ struct KinematicsException: public Exception {}; /** * Indicate that something goes wrong with the weights in the forced * heavy quark emission. */ struct WeightException: public Exception {}; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - RemnantModel & operator=(const RemnantModel &); + RemnantModel & operator=(const RemnantModel &) = delete; }; } #endif /* Ariadne5_RemnantModel_H */ diff --git a/Cascade/Models/SpecialGluonEmission.h b/Cascade/Models/SpecialGluonEmission.h --- a/Cascade/Models/SpecialGluonEmission.h +++ b/Cascade/Models/SpecialGluonEmission.h @@ -1,129 +1,129 @@ // -*- C++ -*- #ifndef ARIADNE5_SpecialGluonEmission_H #define ARIADNE5_SpecialGluonEmission_H // // This is the declaration of the SpecialGluonEmission class. // #include "FSGluonEmission.h" #include "PseudoParton.h" #include "Ariadne/Cascade/EmitterBase.h" namespace Ariadne5 { using namespace ThePEG; /** *The SpecialGluonEmission class contains all information about a * generated and performed final state gluon emission from special * partons. */ class SpecialGluonEmission: public FSGluonEmission { public: /** @name Standard constructors and destructors. */ //@{ /** * The only relevant constructor. */ SpecialGluonEmission(const EmitterBase & inmodel, const DipoleBase & indipole, double iny1, double iny3, Energy2 Sin, const PseudoParton & inip, const PseudoParton & inop) : FSGluonEmission(inmodel, indipole, iny1, iny3), S(Sin), pip(inip), pop(inop), wrem1(1.0), wrem3(1.0) {} /** * The deault constructor should not normally be used. */ SpecialGluonEmission() {} /** * The destructor. */ virtual ~SpecialGluonEmission(); //@} protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual ClonePtr 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 ClonePtr fullclone() const; //@} public: /** * The total squared invariant mass */ Energy2 S; /** * Pseudo parton 1 */ PseudoParton pip; /** * Pseudo parton 3 */ PseudoParton pop; /** * The remnant weight for parton 1 */ double wrem1; /** * The remnant weight for parton 3 */ double wrem3; 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(); private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - SpecialGluonEmission & operator=(const SpecialGluonEmission &); + SpecialGluonEmission & operator=(const SpecialGluonEmission &) = delete; }; } #endif /* ARIADNE_SpecialGluonEmission_H */ diff --git a/Cascade/Models/SpecialGluonEmitter.h b/Cascade/Models/SpecialGluonEmitter.h --- a/Cascade/Models/SpecialGluonEmitter.h +++ b/Cascade/Models/SpecialGluonEmitter.h @@ -1,152 +1,152 @@ // -*- C++ -*- #ifndef ARIADNE5_SpecialGluonEmitter_H #define ARIADNE5_SpecialGluonEmitter_H // // This is the declaration of the SpecialGluonEmitter class. // #include "FSGluonEmitter.h" #include "SpecialGluonEmission.h" namespace Ariadne5 { using namespace ThePEG; /** * The SpecialGluonEmitter class implements the standard classical * gluon emission from a colour dipole between special partons * (junctions, remnants or coloured resonance products). * * @see \ref SpecialGluonEmitterInterfaces "The interfaces" * defined for SpecialGluonEmitter. */ class SpecialGluonEmitter: public EmitterBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ SpecialGluonEmitter(); /** * The destructor. */ virtual ~SpecialGluonEmitter(); //@} /** @name Virtual functions to be overridden by sub-classes. */ //@{ /** * Return true if and only if this model can handle the given * Emitter. */ virtual bool canHandle(const DipoleBase &) const; /** * If the given EmissionModel overlaps with this model for the given * Emitter, return true if this model should take precedence. Must * only be called for Emitters for which canHandle() is true. */ virtual bool overrides(const EmitterBase &, DipoleBase &) const; /** * Generate the a phase space point for an emission corresponding to * this model. Must only be called for Emitters for which * canHandle() is true. */ virtual EmPtr generate(const DipoleBase &, Energy rhomin, Energy rhomax) const; /** * Perform an emission previously generated for this Emitter. Must * only be called for Emitters for which canHandle() is true. * @return true if the emission was successful */ virtual bool perform(const Emission &) const; /** * Reverse a previously performed emission. Sub-classes which has * signalled that they can revert an emission but fails to do so, * must throw a Exception::runerror. */ virtual void revert(const Emission & emission) const; /** * Check if objects related to the given \a dipole have been touched * in a way such that emissions must be regenerated. Must only be * called for Emitters for which canHandle() is true. */ virtual bool touched(const DipoleBase & dipole) 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); //@} /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). public: /** * Exception class indicating no model could be found for special * parton. */ struct MissingModel: public Exception {}; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - SpecialGluonEmitter & operator=(const SpecialGluonEmitter &); + SpecialGluonEmitter & operator=(const SpecialGluonEmitter &) = delete; }; } #endif /* ARIADNE5_SpecialGluonEmitter_H */ diff --git a/Cascade/Models/SpecialQQEmission.h b/Cascade/Models/SpecialQQEmission.h --- a/Cascade/Models/SpecialQQEmission.h +++ b/Cascade/Models/SpecialQQEmission.h @@ -1,129 +1,129 @@ // -*- C++ -*- #ifndef ARIADNE5_SpecialQQEmission_H #define ARIADNE5_SpecialQQEmission_H // // This is the declaration of the SpecialQQEmission class. // #include "FSQQEmission.h" #include "PseudoParton.h" #include "Ariadne/Cascade/EmitterBase.h" namespace Ariadne5 { using namespace ThePEG; /** *The SpecialQQEmission class contains all information about a * generated and performed final state gluon emission from special * partons. */ class SpecialQQEmission: public FSQQEmission { public: /** @name Standard constructors and destructors. */ //@{ /** * The only relevant constructor. */ SpecialQQEmission(const EmitterBase & inmodel, const DipoleBase & indipole, int infl, Energy inmq, Energy2 Sin, const PseudoParton & inip, const PseudoParton & inop) : FSQQEmission(inmodel, indipole, infl, inmq), S(Sin), pip(inip), pop(inop), wrem1(1.0), wrem3(1.0) {} /** * The deault constructor should not normally be used. */ SpecialQQEmission() {} /** * The destructor. */ virtual ~SpecialQQEmission(); //@} protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual ClonePtr 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 ClonePtr fullclone() const; //@} public: /** * The total squared invariant mass */ Energy2 S; /** * Pseudo parton 1 */ PseudoParton pip; /** * Pseudo parton 3 */ PseudoParton pop; /** * The remnant weight for parton 1 */ double wrem1; /** * The remnant weight for parton 3 */ double wrem3; 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(); private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - SpecialQQEmission & operator=(const SpecialQQEmission &); + SpecialQQEmission & operator=(const SpecialQQEmission &) = delete; }; } #endif /* ARIADNE_SpecialQQEmission_H */ diff --git a/Cascade/Models/SpecialQQEmitter.h b/Cascade/Models/SpecialQQEmitter.h --- a/Cascade/Models/SpecialQQEmitter.h +++ b/Cascade/Models/SpecialQQEmitter.h @@ -1,152 +1,152 @@ // -*- C++ -*- #ifndef ARIADNE5_SpecialQQEmitter_H #define ARIADNE5_SpecialQQEmitter_H // // This is the declaration of the SpecialQQEmitter class. // #include "FSGluonEmitter.h" #include "SpecialQQEmission.h" namespace Ariadne5 { using namespace ThePEG; /** * The SpecialQQEmitter class implements the standard classical * gluon emission from a colour dipole between special partons * (junctions, remnants or coloured resonance products). * * @see \ref SpecialQQEmitterInterfaces "The interfaces" * defined for SpecialQQEmitter. */ class SpecialQQEmitter: public EmitterBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ SpecialQQEmitter(); /** * The destructor. */ virtual ~SpecialQQEmitter(); //@} /** @name Virtual functions to be overridden by sub-classes. */ //@{ /** * Return true if and only if this model can handle the given * Emitter. */ virtual bool canHandle(const DipoleBase &) const; /** * If the given EmissionModel overlaps with this model for the given * Emitter, return true if this model should take precedence. Must * only be called for Emitters for which canHandle() is true. */ virtual bool overrides(const EmitterBase &, DipoleBase &) const; /** * Generate the a phase space point for an emission corresponding to * this model. Must only be called for Emitters for which * canHandle() is true. */ virtual EmPtr generate(const DipoleBase &, Energy rhomin, Energy rhomax) const; /** * Perform an emission previously generated for this Emitter. Must * only be called for Emitters for which canHandle() is true. * @return true if the emission was successful */ virtual bool perform(const Emission &) const; /** * Reverse a previously performed emission. Sub-classes which has * signalled that they can revert an emission but fails to do so, * must throw a Exception::runerror. */ virtual void revert(const Emission & emission) const; /** * Check if objects related to the given \a dipole have been touched * in a way such that emissions must be regenerated. Must only be * called for Emitters for which canHandle() is true. */ virtual bool touched(const DipoleBase & dipole) 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); //@} /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). public: /** * Exception class indicating no model could be found for special * parton. */ struct MissingModel: public Exception {}; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - SpecialQQEmitter & operator=(const SpecialQQEmitter &); + SpecialQQEmitter & operator=(const SpecialQQEmitter &) = delete; }; } #endif /* ARIADNE5_SpecialQQEmitter_H */ diff --git a/Cascade/Parton.h b/Cascade/Parton.h --- a/Cascade/Parton.h +++ b/Cascade/Parton.h @@ -1,513 +1,513 @@ // -*- C++ -*- #ifndef Ariadne5_Parton_H #define Ariadne5_Parton_H // // This is the declaration of the Parton class. // #include "CascadeBase.h" #include "Parton.fh" #include "QCDDipole.fh" #include "Emission.h" #include "ThePEG/Vectors/Lorentz5Vector.h" #include "ThePEG/PDT/ParticleData.h" #include "ThePEG/EventRecord/Particle.h" #include "ThePEG/EventRecord/ParticleTraits.h" namespace Ariadne5 { using namespace ThePEG; /** * The Parton class represents partons which are able to cascade * according to the Dipole Cascade Model. */ class Parton: public CascadeBase { public: /** * The DipoleState is a friend. */ friend class DipoleState; /** * A pair of partons. */ typedef pair tParPair; /** * Typedef for position in transverse coordinate space. */ typedef Transverse BPos; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. Derived classes which are complex * partons must set the \a spec argument to true. */ Parton(bool spec = false); /** * The destructor. */ virtual ~Parton(); //@} public: /** @name Simple access functions. */ //@{ /** * If this was an original parton, this points to the corresponding * Particle object. */ inline tPPtr orig() const { return theOrig; } /** * The Emission that produced this parton, or null if original. */ inline tcEmPtr emission() const { return theEmission; } /** * The final ThePEG::Particle produced for this parton with the * produceParticle() function. */ inline tPPtr particle() const { return theParticle; } /** * Fill the given iterator with the original Particle objects * corresponding to the ultimate parents. */ template void getOriginalParents(OIterator it) const { for ( int i = 0, N = adoptedOriginals.size(); i < N; ++i ) *it++ = adoptedOriginals[i]; if ( orig() ) *it++ = orig(); else { if ( emission()->colourParent ) emission()->colourParent->getOriginalParents(it); if ( emission()->antiColourParent ) emission()->antiColourParent->getOriginalParents(it); } } /** * If this parton was created during the cascade, return the * pointers to the parent partons. The first parent is the coloured * parent and the second is the anti-colour one. */ tParPair parents() const; /** * The corresponding ParticleData object. */ inline tcPDPtr dataPtr() const { return theDataPtr; } /** * The corresponding ParticleData object. */ inline const ParticleData & data() const { return *theDataPtr; } /** * Return the colour charge of this parton. */ inline bool hasColour() const { return dataPtr() && data().iColour() != PDT::Colour0; } /** * Return the colour charge of this parton. */ inline PDT::Colour iColour() const { return dataPtr()? data().iColour(): PDT::Colour0; } /** * The original incoming anti-colour line corresponding to this * parton. */ tColinePtr origICol() const { return theICol; } /** * The original outgoing colour line corresponding to this * parton. */ tColinePtr origOCol() const { return theOCol; } /** * The original incoming anti-colour line corresponding to this * parton. */ void origICol(tColinePtr cl) { theICol = cl; } /** * The original outgoing colour line corresponding to this * parton. */ void origOCol(tColinePtr cl) { theOCol = cl; } /** * Return the charge of this parton in umits of e. */ inline double charge() const { return dataPtr()? double(data().charge()/Units::eplus): 0.0; } /** * Return the charge of this parton in umits of e. */ inline bool hasCharge() const { return dataPtr() && data().iCharge() != PDT::Charge0; } /** * Return true if this parton is a gluon. */ inline bool isG() const { return iColour() == PDT::Colour8; } /** * Return true if this parton is coloured. */ inline bool coloured() const { return dataPtr() && data().coloured(); } /** * Return true if this is not a normal parton in a dipole together * with an \a other parton. */ virtual bool special(tcParPtr other = tcParPtr()) const { return isSpecial; } /** * Return true if this parton was emitted in a failsafe Emission. */ bool failsafe() const { return emission() && emission()->failsafe; } /** * Return true if this parton has information about neighboring * dipoles or partons and if any of these hwve been touched. */ virtual bool touchedNeighbours(tcQCDPtr d) const { return false; } /** * The momentum of this Parton. */ inline const Lorentz5Momentum & momentum() const { return theMomentum; } /** * The momentum of this Parton. */ inline Lorentz5Momentum & momentum() { return theMomentum; } /** * Set the momentum of this parton. */ virtual void setMomentum(const Lorentz5Momentum & p) { theMomentum = p; } /** * The production vertex position of this Parton. */ inline const LorentzPoint & vertex() const { return theVertex; } /** * The production vertex position of this Parton. */ inline LorentzPoint & vertex() { return theVertex; } /** * Set the production vertex position of this Parton. */ virtual void setVertex(const LorentzPoint p) { theVertex = p; } /** * Get the position in impact parameter space in inverse energy units */ BPos bPos() const { return BPos(vertex().x()/Constants::hbarc, vertex().y()/Constants::hbarc); } /** * Set the position in impact parameter space in inverse energy units */ const BPos & bPos(const BPos & p) { theVertex.setX(p.x()*hbarc); theVertex.setY(p.y()*hbarc); return p; } /** * If this was an original parton, set the pointer to the * corresponding Particle object. Also set the momentum and the * ParticleData pointer. */ void orig(tPPtr); /** * If this parton has absorbed a gluon, it may also adopt that gluons original parton. */ void adoptOriginals(tParPtr op); /** * Set the data pointer for this parton. */ void data(tcPDPtr); /** * Set the Emission which produced this parton, or null if original. */ void emission(tcEmPtr e); //@} /** * Produce a ThePEG::Particle corresponding to this parton. The * momentum of the produced particle is rotated with \a r w.r.t. the * parton. */ virtual tPPtr produceParticle(const LorentzRotation & r = LorentzRotation()); /** * Calculate the invatiant pt2 of the parton. */ Energy2 invPT2() const; /** * Some sub classes may need information about emissions which may * influence their state. */ virtual void notify(const Emission &); /** * Return true if this parton is present in the final state. */ bool finalState() const { return inFinalState; } /** * Set true if this parton is present in the final state. */ void setFinalState(bool yes = true) { inFinalState = yes; } /** * Return the dipole system to which this parton currently belongs. */ int system() const { return theSystem; } /** * Set the dipole system to which this parton currently belongs. */ void system(int s) { theSystem = s; } /** * Return the dipole system to which this parton originally belonged. */ int origSystem() const { return theOrigSystem; } /** * Return the dipole system to which this parton originally belonged. */ void origSystem(int s) { theOrigSystem = theSystem = s; } protected: /** @name Functions relating to the DipoleState to which this belongs. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual ClonePtr clone() const; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} 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(); private: /** * If this was an original parton, this points to the corresponding * Particle object. */ tPPtr theOrig; /** * The Emission which produced this parton, or null if original. */ cEmPtr theEmission; /** * The final ThePEG::Particle produced for this parton with the * produceParticle() function. */ PPtr theParticle; /** * The corresponding ParticleData object. */ tcPDPtr theDataPtr; /** * The momentum of this Parton. */ Lorentz5Momentum theMomentum; /** * The production vertex position of this parton. */ LorentzPoint theVertex; /** * The original incoming anti-colour line corresponding to this * parton. */ tColinePtr theICol; /** * The original outgoing colour line corresponding to this * parton. */ tColinePtr theOCol; /** * Set true if this parton need to be notified about other emission * which may influence its state. */ bool doNeedNotification; /** * Set true if this parton is present in the final state. */ bool inFinalState; /** * Is true if this is a derived complex class. */ bool isSpecial; /** * The dipole system to which this parton currently belongs. */ int theSystem; /** * The dipole system to which this parton originally belonged. */ int theOrigSystem; /** * If this parton has absorbed a gluon, it should also adopt that * gluons original parton. */ vector adoptedOriginals; public: /** * Print out debugging information on std::cerr. */ virtual void debugme() const; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - Parton & operator=(const Parton &); + Parton & operator=(const Parton &) = delete; }; } #endif /* Ariadne5_Parton_H */ diff --git a/Cascade/QCDDipole.h b/Cascade/QCDDipole.h --- a/Cascade/QCDDipole.h +++ b/Cascade/QCDDipole.h @@ -1,282 +1,282 @@ // -*- C++ -*- #ifndef Ariadne5_QCDDipole_H #define Ariadne5_QCDDipole_H // // This is the declaration of the QCDDipole class. // #include "DipoleBase.h" #include "QCDDipole.fh" #include "Parton.fh" #include "DipoleState.fh" #include "ColourIndex.h" namespace Ariadne5 { using namespace ThePEG; /** * *** TODO WARNING! *** The following is wrong! the incoming parton iPart() carries * colour and the outgoing (oPart()) carries anti-colour. * * The QCDDipole class represents QCD dipoles between * Partons. The QCDDipole also defines the colour flow * from the incoming to the outgoing Parton, where the incoming Parton * carries anti-colour and the outgoing Parton carries colour. * * NOTE! The dipole rest frame is defined such that the * anti-colour-carrying parton is along the positive z-axis. */ class QCDDipole: public DipoleBase { public: /** * The QCDDipoleState is a friend. */ friend class DipoleState; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ QCDDipole(); /** * The destructor. */ inline virtual ~QCDDipole() {}; //@} public: /** * Get (or create and return) the colour line corresponding * corresponding to this dipole, if present. Is only meaningful if * Parton::produceParticle() has been called for the connected * partons. The colour line should be properly connected to the * produced particle. */ virtual ColinePtr colourLine() const; /** @name Simple access functions. */ //@{ /** * The anti-colour-carrying parton in this dipole. */ inline tParPtr iPart() const { return theIPart; } /** * The previous dipole in the string. Returns the dipole whose * oPart() is this iPart() if any. */ tQCDPtr prev() const { return thePrev; } /** * Set the previous dipole in the string. */ void prev(tQCDPtr d) { thePrev = d; } /** * The colour-carrying parton in this dipole. */ inline tParPtr oPart() const { return theOPart; } /** * The next dipole in the string. Returns the dipole whose * iPart() is this oPart() if any. */ tQCDPtr next() const { return theNext; } /** * Set the next dipole in the string. */ void next(tQCDPtr d) { theNext = d; } /** * Return all partons in this string (or string piece if it is in a junction). */ vector string() const; /** * The colour index of this dipole. */ inline const ColourIndex & colourIndex() const { return theColourIndex; } /** * Set the anti-colour-carrying parton in this dipole. */ inline void iPart(tParPtr x) { theIPart = x; } /** * Set the colour-carrying parton in this dipole. */ inline void oPart(tParPtr x) { theOPart = x; } /** * Set the colour index of this dipole. */ inline void colourIndex(const ColourIndex & x) { theColourIndex = x; } /** * Generte a colour index of this dipole. */ void generateColourIndex(); /** * Return the squared invariant mass of this dipole. */ Energy2 sdip() const; // *** ATTENTION *** Do we need this? /** * The particle type if this dipole comes directly from a decay of a * resonance. If not, null is returned. */ inline tcPDPtr resonance() const { return theResonance; } /** * The particle type if this dipole comes directly from a decay of a * resonance. */ inline void resonance(tcPDPtr x) { theResonance = x; } //@} protected: /** @name Functions relating to the DipoleState to which this belongs. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual ClonePtr clone() const; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} 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(); private: /** * The anti-colour-carrying parton in this dipole. */ tParPtr theIPart; /** * The colour-carrying parton in this dipole. */ tParPtr theOPart; /** * The next dipole in the string. */ tQCDPtr theNext; /** * The previous dipole in the string. */ tQCDPtr thePrev; /** * The colour index of this dipole. 0 means no index has been assigned. */ ColourIndex theColourIndex; /** * The particle type if this dipole comes directly from a decay of a * resonance. */ tcPDPtr theResonance; public: /** * Print out debugging information on std::cerr. */ virtual void debugme() const; /** * Check integrity of the emitter. Return false if error is found. */ virtual bool checkIntegrity(); private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - QCDDipole & operator=(const QCDDipole &); + QCDDipole & operator=(const QCDDipole &) = delete; }; } #endif /* Ariadne5_QCDDipole_H */ diff --git a/Cascade/QCDDipoleFinder.h b/Cascade/QCDDipoleFinder.h --- a/Cascade/QCDDipoleFinder.h +++ b/Cascade/QCDDipoleFinder.h @@ -1,125 +1,125 @@ // -*- C++ -*- #ifndef Ariadne5_QCDDipoleFinder_H #define Ariadne5_QCDDipoleFinder_H // // This is the declaration of the QCDDipoleFinder class. // #include "ThePEG/Handlers/HandlerBase.h" #include "QCDDipoleFinder.fh" #include "QCDDipole.fh" #include "DipoleState.fh" #include "Parton.fh" namespace Ariadne5 { using namespace ThePEG; /** * The QCDDipoleFinder class and its sub-classes are responsible for * identifying and introducing of QCD dipoles in the setup phase of a * given DipoleState. * * @see \ref QCDDipoleFinderInterfaces "The interfaces" * defined for QCDDipoleFinder. */ class QCDDipoleFinder: public HandlerBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ QCDDipoleFinder(); /** * The destructor. */ virtual ~QCDDipoleFinder(); //@} public: /** * Find, create and return the QCD dipoles in the given * DipoleState. */ virtual vector findDipoles(DipoleState &) const; /** * Create a QCDDipole in the given DipoleState between the Parton * objects \a pi and \a po carrying the anti-colour and colour * respectively. */ tQCDPtr createDipole(tParPtr pi, tParPtr po, DipoleState & state) const; public: /** * Exception class used when no consistent set of dipoles can be found. */ struct QCDFinderException: public Exception {}; 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - QCDDipoleFinder & operator=(const QCDDipoleFinder &); + QCDDipoleFinder & operator=(const QCDDipoleFinder &) = delete; }; } #endif /* Ariadne5_QCDDipoleFinder_H */ diff --git a/Cascade/RemnantParton.h b/Cascade/RemnantParton.h --- a/Cascade/RemnantParton.h +++ b/Cascade/RemnantParton.h @@ -1,590 +1,590 @@ // -*- C++ -*- #ifndef Ariadne5_RemnantParton_H #define Ariadne5_RemnantParton_H // // This is the declaration of the RemnantParton class. // #include "Parton.h" #include "RemnantParton.fh" #include "Models/RemnantModel.fh" #include "ThePEG/PDF/PartonBinInstance.h" #include "ThePEG/PDF/PDF.h" namespace Ariadne5 { /** * The RemnantParton class represents the remnant left after a parton * has been extracted from an incoming particle. */ class RemnantParton: public Parton { public: /** * The DipoleState is a friend. */ friend class DipoleState; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ RemnantParton(); /** * The destructor. */ inline virtual ~RemnantParton() {} //@} public: /** @name Simple access functions. */ //@{ /** * The object responsible for modeling some aspects of the remnant. */ inline const RemnantModel & model() const { return *theModel; } /** * Return the inverse extension of this remant. */ inline Energy mu() const { return theMu; } /** * Return the dimensionality of the extension of this remnant. */ inline double alpha() const { return theAlpha; } /** * Return the supression power of emission scales above the maximum. */ inline double beta() const { return theBeta; } /** * The original incoming particle. May be null if no information was * available in the SubProcess. */ tPPtr parent() const { return theParent; } /** * The original incoming particle type. */ const ParticleData & parentData() const { return *theParentData; } /** * The incoming particle momentum. */ const Lorentz5Momentum & parentMomentum() const { return theParentMomentum; } /** * The original extracted parton. May be null if no information was * available in the SubProcess. */ tPPtr originalExtracted() const { return theOriginalExtracted; } /** * The extracted parton type. */ const ParticleData & extractedData() const { return *theExtractedData; } /** * The momentum of the extracted parton. */ const Lorentz5Momentum & extractedMomentum() const { return theExtractedMomentum; } /** * The current x-value. */ double x() const { return theX; } /** * Get the current factorization scale. */ Energy2 muF2() const { return theMuF2; } /** * Set a new x-value. If negative, use the information in * extractedMomentum() and the reference particle to calculate. */ void x(double xin); /** * Set the current factorization scale. */ void muF2(Energy2 Q2) { theMuF2 = Q2; } /** * For hard remnants, the energy fraction of the virtual boson in DIS. */ double y() const { return theY; } /** * The final extracted parton as produced by produceParticle() * incase this is a soft remnant. */ tPPtr extracted() const { return theExtracted; } /** * The PDF associated with the parent. May be empty for hard remnants. */ const PDF & pdf() const { return thePDF; } /** * Return the PDF value (momentum density) for the currently * extracted parton, given a scale). Return zero if not a soft * remnant. */ double xfx(Energy2 scale) const { return pdf().pdf()? pdf().xfx(theExtractedData, scale, x()): 0.0; } /** * Return the PDF value (momentum density) for the currently * extracted parton, given a a scale and momentum fraction, \a xx. Return * zero if not a soft remnant. */ double xfx(Energy2 scale, double xx) const { return pdf().pdf()? pdf().xfx(theExtractedData, scale, xx): 0.0; } /** * Return the PDF value (momentum density) for the given \a * extracted parton, given a a scale and momentum fraction, \a xx. Return * zero if not a soft remnant. */ double xfx(tcPDPtr extracted, Energy2 scale, double xx) const { return pdf().pdf()? pdf().xfx(extracted, scale, xx): 0.0; } /** * Return the ratio of pdfs when evolving backwards from the current * parton at the current x, to a \a newparton at x/\a z at the given * \a scale. * * @return 0 if no PDF object has been assigned, or a negative value * if the density for the current parton is zero. */ double xfratio(tcPDPtr newparton, Energy2 scale, double z) const; /** * Return the effective mass for this parton. Optionally supply * anothe parton to be extracted. */ Energy effectiveMass(tcPDPtr extracted = tcPDPtr()) const; /** * For an emission where this remnant would acquire a transverse * momentum recoil, use the RemnantModel in the controlling * AriadneHandler to calculate a weight related to the subsequent * emission of a recoil gluon. \a ph is the momentum of the hard * subsystem and \a pr is the momentum of the remnant after the * emission under consideration. If the emission is an initial state * g->q or q->g splitting, the new \a extracted parton should be given. */ double recoilWeight(const LorentzMomentum & ph, const LorentzMomentum & pr, tcPDPtr extracted = tcPDPtr()) const; /** * If this remnant has acquired a transverse momentum recoil in a * previous emission, calculate the weight related to the subsequent * emission of a recoil gluon. */ double recoilWeight() const; /** * Return the soft suppression weight for an emission at scale \a * rho, taking a fraction x of the positive momentum of the incoming * particle. */ double softSuppression(Energy rho, double xplus) const; /** * Calculate a weight of an emission generated from a dipole with * this remnant giving a parton with momentum \a pem. \a prem is the * momentum of the remnant after the emission. Veto if it is not * considered a final-state splitting, otherwise reweight if too * much momentum is taken from the remnant. Optionally an \a * extracted flavour may be supplied if the emission was an initial * state g->q or q->g splitting. */ double reweightFS(Energy rho, LorentzMomentum pem, LorentzMomentum prem, tcPDPtr extracted = tcPDPtr()) const; /** * Get the rotation to transform the momentum \a phold to \a * phnew. It is done in a way such that the momenta which are * opposite in direction from the remnant are left untouched. */ LorentzRotation getHardTransform(const LorentzMomentum & phold, const LorentzMomentum & phnew) const; /** * Return true if this is a hard remnant. */ bool hard() const { return !pdf().pdf(); } /** * Return the direction of this remnant. Negative means incoming * from the seconf beam, positive the first. */ int dir() const { return theDirection; } /** * Set the direction of this remnant. Negative means incoming * from the seconf beam, positive the first. */ void dir(int d) { theDirection = d; } /** * Set the transformation needed to go to the rest system of this * remnants incoming particle and the other incoming particle, with * this incoming particle along the positive z-axis. */ const LorentzRotation & setBoost(); /** * Return the transformation needed to go to the rest system of this * remnants incoming particle and the other incoming particle, with * this incoming particle along the positive z-axis. */ const LorentzRotation & getBoost() const { return theBoost; } /** * Return the inverse of getBoost(). */ const LorentzRotation & invBoost() const { return theInvBoost; } /** * Return the squared transverse momentum of the given momentum in * the frame specified by getBoost(). */ Energy2 getPT2Kick(const LorentzMomentum & p) const { return (getBoost()*p).perp2(); } /** * Return the squared transverse momentum of this remnant in the * frame specified by getBoost(). */ Energy2 getPT2Kick() const { return getPT2Kick(momentum()); } /** * Produce a ThePEG::Particle corresponding to this parton. The * momentum of the produced particle is rotated with \a r w.r.t. the * parton. If this is a hard remnant, the corresponding particle is * produced, while if this is a soft remnant, the corresponding * extracted particle is produced. */ virtual tPPtr produceParticle(const LorentzRotation & r = LorentzRotation()); //@} public: /** @name Setup functions. */ //@{ /** * Setup remnant from a PartonBinInstance. */ void setup(const PartonBinInstance & pb, int indir); /** * Setup parent. */ void setupParent(tPPtr p) { theParent = p; setupParent(p->dataPtr(), p->momentum()); } /** * Setup parent. */ void setupParent(tcPDPtr pd, const Lorentz5Momentum & p) { theParentData = pd; theParentMomentum = p; } /** * Set the particle type for this remnant. Is always taken to be the * anti-partner of the extracted parton. */ void setData() { data(extractedData().CC()? tcPDPtr(extractedData().CC()): theExtractedData); } /** * Setup extracted parton. */ void setupExtracted(tPPtr p) { theOriginalExtracted = p; setExtracted(p->dataPtr(), p->momentum()); } /** * Set extracted parton. */ void setExtracted(tcPDPtr pd, const Lorentz5Momentum & p) { theExtractedData = pd; setData(); theExtractedMomentum = p; x(-1.0); } void setExtracted(tcPDPtr pd = tcPDPtr()) { if ( !pd ) pd = theExtractedData; setExtracted(pd, parentMomentum() - momentum()); } virtual void setMomentum(const Lorentz5Momentum & p); void setMomentum(const Lorentz5Momentum & p, tcPDPtr pd) { momentum() = p; setExtracted(pd); } bool untouched() const { return originalExtracted() && theExtractedData == originalExtracted()->dataPtr() && theExtractedMomentum == originalExtracted()->momentum(); } /** * Set parameters for hard remnant. */ void setupHard(int indir); /** * Setup pdf. */ void setupPDF(const PDF & f) { thePDF = f; } //@} protected: /** @name Functions relating to the DipoleState to which this belongs. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual ClonePtr clone() const; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} 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: /** * The object modeling some aspects of remnants. */ tcRemnantModelPtr theModel; /** * The inverse extension of this remant. To be set by sub-classes. */ Energy theMu; /** * The dimensionality of the extension of this remnant. To be set by * sub-classes. */ double theAlpha; /** * The supression power of emission scales above the maximum. */ double theBeta; private: /** * The original incoming particle. May be null if no information was * available in the SubProcess. */ tPPtr theParent; /** * The original incoming particle type. */ tcPDPtr theParentData; /** * The incoming particle momentum. */ Lorentz5Momentum theParentMomentum; /** * The original extracted parton. May be null if no information was * available in the SubProcess. */ tPPtr theOriginalExtracted; /** * The extracted parton type. */ tcPDPtr theExtractedData; /** * The momentum of the extracted parton. */ Lorentz5Momentum theExtractedMomentum; /** * The final extracted parton produced in produceParticle() if this * was a soft remnant. */ PPtr theExtracted; /** * The PDF associated with the parent. May be empty for hard remnants. */ PDF thePDF; /** * The current x-value. */ double theX; /** * The current factorization scale. */ Energy2 theMuF2; /** * For hard remnants, the energy fraction of the virtual boson in DIS. */ double theY; /** * The direction of this remnant. Negative means incoming from the * seconf beam, positive the first. */ int theDirection; /** * The transformation needed to go to the rest system of this * remnants incoming particle and the other incoming particle, with * this incoming particle along the positive z-axis. */ LorentzRotation theBoost; /** * The inverse of theBoost. */ LorentzRotation theInvBoost; public: /** * Print out debugging information on std::cerr. */ virtual void debugme() const; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - RemnantParton & operator=(const RemnantParton &); + RemnantParton & operator=(const RemnantParton &) = delete; }; } #endif /* Ariadne5_RemnantParton_H */ diff --git a/Cascade/Resonance.h b/Cascade/Resonance.h --- a/Cascade/Resonance.h +++ b/Cascade/Resonance.h @@ -1,147 +1,147 @@ // -*- C++ -*- #ifndef Ariadne5_Resonance_H #define Ariadne5_Resonance_H // // This is the declaration of the Resonance class. // #include "Parton.h" #include "Resonance.fh" namespace Ariadne5 { using namespace ThePEG; /** * Here is the documentation of the Resonance class. */ class Resonance: public Parton { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ Resonance(); /** * The destructor. */ virtual ~Resonance(); //@} /** @name Simple access functions. */ //@{ /** * The sub system index for which the decay products of this * resonance belong. */ int decaySystem() const { return theDecaySystem; } /** * Return the parent resonance if it exists. */ tResPtr parentResonance() const { return theParentResonance; } /** * Set the parent resonance if it exists. */ void parentResonance(tResPtr r) { theParentResonance = r; origSystem(r->decaySystem()); } /** * Set the sub system index for which the decay products of this * resonance belong. */ void decaySystem(int isys) { theDecaySystem = isys; } //@} protected: /** @name Functions relating to the DipoleState to which this belongs. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual ClonePtr clone() const; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} 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(); private: /** * The parent resonance if it exists. */ tResPtr theParentResonance; /** * The sub system index for which the decay products of this * resonance belong. */ int theDecaySystem; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - Resonance & operator=(const Resonance &); + Resonance & operator=(const Resonance &) = delete; }; } #endif /* Ariadne5_Resonance_H */ diff --git a/Cascade/ResonanceFinder.h b/Cascade/ResonanceFinder.h --- a/Cascade/ResonanceFinder.h +++ b/Cascade/ResonanceFinder.h @@ -1,110 +1,110 @@ // -*- C++ -*- #ifndef Ariadne5_ResonanceFinder_H #define Ariadne5_ResonanceFinder_H // // This is the declaration of the ResonanceFinder class. // #include "ThePEG/Interface/Interfaced.h" #include "ResonanceFinder.fh" namespace Ariadne5 { using namespace ThePEG; /** * The ResonanceFinder class is used by the AriadneHandler to find * possible s-channel resonances in a given SubProcess. Normally this * is quite trivial, but in some cases the information about * resonances is not available in the SubProcess (eg. if the process * has been read in from an Les Houches event file). In this case the * user may inherit from this class to specify which of the final * state particles in the SubProcess was produced via a resonance. * * @see \ref ResonanceFinderInterfaces "The interfaces" * defined for ResonanceFinder. */ class ResonanceFinder: public Interfaced { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ ResonanceFinder(); /** * The destructor. */ virtual ~ResonanceFinder(); //@} public: /** * Return a list of intermediate s-channel resonances in the given * SubProcess. Sub-classes may insert resonances which they think * has been omitted in the event record. Resonances which have * decayed into further resonances must come before their children * in the list. */ virtual tPVector resonances(SubProcess &) const; /** * Helper function to be used by sub-classes when inserting * resonances in the SubProcess. The \a resonance should be a newly * created particle and will be inserted in the \a sub process (and * the corresponding \a step). Mother/daughter relationships will be * modified. The \a children must already be included in the \a sub * process. */ void insert(Step & step , SubProcess & sub, PPtr resonance, const tPVector & children) const; public: /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ResonanceFinder & operator=(const ResonanceFinder &); + ResonanceFinder & operator=(const ResonanceFinder &) = delete; }; } #endif /* Ariadne5_ResonanceFinder_H */ diff --git a/Cascade/ResonanceParton.h b/Cascade/ResonanceParton.h --- a/Cascade/ResonanceParton.h +++ b/Cascade/ResonanceParton.h @@ -1,176 +1,176 @@ // -*- C++ -*- #ifndef Ariadne5_ResonanceParton_H #define Ariadne5_ResonanceParton_H // // This is the declaration of the ResonanceParton class. // #include "ResonanceParton.fh" #include "Resonance.h" namespace Ariadne5 { using namespace ThePEG; /** * The ResonanceParton class inherits from Parton and represent a * final state parton which is a decay product of a resonance. */ class ResonanceParton: public Parton { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ ResonanceParton(); /** * The destructor. */ virtual ~ResonanceParton(); //@} public: /** * Set the parent resonance. */ void setResonance(tResPtr r) { theResonance = r; origSystem(r->decaySystem()); } /** * Add a new final state sibling. */ void addSibling(tParPtr s) { theSiblings.insert(s); } /** * Add a new intermediate sibling. If previously present, it will be * removed from the final state. */ void addOther(tParPtr o); /** * Get the parent resonance. */ tResPtr resonance() const { return theResonance; } /** * Get the final state siblings. */ const set & siblings() const { return theSiblings; } /** * Get intermediate siblings. */ const set & others() const { return theOthers; } /** * We need to know if an emission has been performed from a sibling. */ virtual void notify(const Emission &); /** * Return true if this is not a normal parton in a dipole together * with an \a other parton. */ virtual bool special(tcParPtr other = tcParPtr()) const { return !other || other->system() != system(); } protected: /** @name Functions relating to the DipoleState to which this belongs. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual ClonePtr clone() const; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} 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(); private: /** * The parent resonance. */ tResPtr theResonance; /** * The sibling final state partons from the same resonance decay * (including their emitted partons). */ set theSiblings; /** * Other decay products of the same resonance decay. */ set theOthers; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ResonanceParton & operator=(const ResonanceParton &); + ResonanceParton & operator=(const ResonanceParton &) = delete; }; } #endif /* Ariadne5_ResonanceParton_H */ diff --git a/Cascade/ReweightBase.h b/Cascade/ReweightBase.h --- a/Cascade/ReweightBase.h +++ b/Cascade/ReweightBase.h @@ -1,135 +1,135 @@ // -*- C++ -*- #ifndef Ariadne5_ReweightBase_H #define Ariadne5_ReweightBase_H // // This is the declaration of the ReweightBase class. // #include "ThePEG/Handlers/HandlerBase.h" #include "ReweightBase.fh" #include "DipoleBase.fh" #include "Parton.fh" #include "Emission.fh" namespace Ariadne5 { using namespace ThePEG; /** * ReweightBase is the base class for implementing different ways of * reweighting the dipole emissions in Ariadne. There are three * virtual functions which may be overridden in concrete sub-classes: * preweight() should return a factor multiplying the standard dipole * emission before reweighting and reweight() should return the actual * reweight. Alternatively the finalVeto() function can be used to * accept/reject an already performed dipole emission. Object of a * concrete sub-class can inserted to a list in * Ariadne5::CascadeHandler and will then be applied to all dipole * emissions. The object could possibly be used for several different * dipoles, and should therefore not store any information in the * preweigth() function to be used in the subsequent reweigth() and * finalVeto() calls. * * @see \ref ReweightBaseInterfaces "The interfaces" * defined for ReweightBase. */ class ReweightBase: public HandlerBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. \a mayveto must be set to true by * subclasses which implements the finalVeto function. */ ReweightBase(bool mayveto = false) : mayVeto(mayveto) {}; /** * The destructor. */ virtual ~ReweightBase(); //@} public: /** @name Virtual functions to be overridden in sub-classes. */ //@{ /** * Return a factor to multiply the basic emission emission * probability for a given \a emission to ensure that a subsequent * call to reweight() will give a number less than unity. */ virtual double preweight(const Emission & emission) const; /** * Return the weight associated with an \a emission. Must return a * number between zero and one. */ virtual double reweight(const Emission & emission) const; /** * In addition to the reweight function a final hit/miss veto may be * given after the \a emission has been performed. Will only be * called if hasFinalVeto() returns true. */ virtual bool finalVeto(const Emission & emission) const; /** * Indicate that this object may veto a performed emission. */ bool hasFinalVeto() const { return mayVeto; } //@} 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(); // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * Indicate that this object may veto a performed emission. */ bool mayVeto; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ReweightBase & operator=(const ReweightBase &); + ReweightBase & operator=(const ReweightBase &) = delete; }; } #endif /* Ariadne5_ReweightBase_H */ diff --git a/Cascade/ScaleSetter.h b/Cascade/ScaleSetter.h --- a/Cascade/ScaleSetter.h +++ b/Cascade/ScaleSetter.h @@ -1,97 +1,97 @@ // -*- C++ -*- #ifndef ARIADNE5_ScaleSetter_H #define ARIADNE5_ScaleSetter_H // // This is the declaration of the ScaleSetter class. // #include "ThePEG/Interface/Interfaced.h" #include "ScaleSetter.fh" #include "DipoleState.fh" namespace Ariadne5 { using namespace ThePEG; /** * The only task of the ScaleSetter class is to calculate a starting * scale for the dipole shower from a given DipoleState. This base * class only gives the total collision energy, but other strategies * can be implemented in sub-classes overriding the virtual scale() * function. * * @see \ref ScaleSetterInterfaces "The interfaces" * defined for ScaleSetter. */ class ScaleSetter: public Interfaced { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ ScaleSetter(); /** * The destructor. */ virtual ~ScaleSetter(); //@} public: /** * Return the starting scale for the dipole shower from the given * DipoleState. This base class simply return the total energy of * the event. More complicated alternatives must be implemented in * sub-classes. */ virtual Energy scale(const DipoleState &) const; public: /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ScaleSetter & operator=(const ScaleSetter &); + ScaleSetter & operator=(const ScaleSetter &) = delete; }; } #endif /* ARIADNE5_ScaleSetter_H */ diff --git a/Cascade/StateDipole.h b/Cascade/StateDipole.h --- a/Cascade/StateDipole.h +++ b/Cascade/StateDipole.h @@ -1,87 +1,87 @@ // -*- C++ -*- #ifndef Ariadne5_StateDipole_H #define Ariadne5_StateDipole_H // // This is the declaration of the StateDipole class. // #include "DipoleBase.h" #include "StateDipole.fh" #include "Parton.fh" namespace Ariadne5 { using namespace ThePEG; /** * The StateDipole class is a dummy class to be used by emission * models which works on the whole dipole state, rather than on * individual dipoles.. */ class StateDipole: public DipoleBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ StateDipole(); /** * The destructor. */ virtual ~StateDipole() {} //@} protected: /** @name Functions relating to the DipoleState to which this belongs. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual ClonePtr clone() const; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointer to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} public: /** * 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(); private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - StateDipole & operator=(const StateDipole &); + StateDipole & operator=(const StateDipole &) = delete; }; } #endif /* Ariadne5_StateDipole_H */ diff --git a/Config/CloneBase.h b/Config/CloneBase.h --- a/Config/CloneBase.h +++ b/Config/CloneBase.h @@ -1,133 +1,133 @@ // -*- C++ -*- #ifndef ARIADNE5_CloneBase_H #define ARIADNE5_CloneBase_H // // This is the declaration of the CloneBase class. // #include "Ariadne5.h" #include "ThePEG/Utilities/Rebinder.h" #include "ThePEG/Utilities/ClassDescription.h" #include "CloneBase.fh" #include "Ariadne/DIPSY/DipoleState.fh" #include "Ariadne/Cascade/DipoleState.fh" namespace Ariadne5 { /** * CloneBase is used as base class for most of the classes in the * Ariadne dipole cascade. It defines the basic clone and rebind * methods which are used when cloning a whole dipole state. Maybe * this class is general enough to be a part of ThePEG base * classes. */ class CloneBase: public PersistentBase { public: /** * A set of pointers to CloneBase objects. */ typedef set CloneSet; /** * The Rebinder class for CloneBase objects. */ typedef Rebinder TranslationMap; /** * */ friend class ::Ariadne5::DipoleState; friend class ::DIPSY::DipoleState; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline CloneBase() { // allocated[uniqueId] = this; } /** * The default constructor. */ inline CloneBase(const CloneBase & x): PersistentBase(x) { // allocated[uniqueId] = this; } /** * The destructor. */ virtual ~CloneBase(); //@} /** * 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 The virtual functions to be overridden in sub-classes. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual ClonePtr clone() const = 0; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} /** * For debugging purposes */ static map allocated; /** * For debugging purposes */ long allocount() const; /** * For debugging purposes */ void allocdebug() const; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - CloneBase & operator=(const CloneBase &); + CloneBase & operator=(const CloneBase &) = delete; }; } #include "ThePEG/Utilities/ClassTraits.h" #endif /* ARIADNE5_CloneBase_H */ diff --git a/Config/ColourInfo.h b/Config/ColourInfo.h --- a/Config/ColourInfo.h +++ b/Config/ColourInfo.h @@ -1,124 +1,124 @@ // -*- C++ -*- #ifndef Ariadne5_ColourInfo_H #define Ariadne5_ColourInfo_H // // This is the declaration of the ColourInfo class which is used to // convey colour indices of connecting dipoles for coloured particles. // #include "ThePEG/EventRecord/EventInfoBase.h" #include "ThePEG/EventRecord/Particle.h" namespace Ariadne5 { using namespace ThePEG; /** * Here is the documentation of the ColourInfo class. */ class ColourInfo: public ThePEG::EventInfoBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor, optionally taking indices on the colour * and anticolour side as arguments. */ ColourInfo(unsigned colindx = 0, unsigned acoindx = 0): theIndices(colindx, acoindx) {} /** * The destructor. */ virtual ~ColourInfo(); //@} public: /** * Set the colour indices of connecting dipoles on the colour and * anti-colour side. */ void indices(pair indxs) { theIndices = indxs; } /** * Return the colour indices of connecting dipoles on the colour and * anti-colour side. */ pair indices() const { return theIndices; } /** * Return the colour index of a dipole connecting the given * particle's colour. If no ColourInfo is present or no index * is defined, return -1. */ static int colIndex(const Particle & p); /** * Return the colour index of a dipole connecting the given * particle's anti colour. If no ColourInfo is present or no index * is defined, return -1. */ static int acoIndex(const Particle & p); /** @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(); /** * Return a possible EventInfoBase object in a particle. */ template static typename ThePEG::Ptr::transient_const_pointer get(const Particle & particle) { typedef typename ThePEG::Ptr::transient_const_pointer eiptr; for ( int i = 0, N = particle.getInfo().size(); i < N; ++i ) if ( eiptr ei = dynamic_ptr_cast(particle.getInfo()[i]) ) return ei; return eiptr(); } private: /** * The colour indices of connecting dipoles on the colour and * anti-colour side. */ pair theIndices; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ColourInfo & operator=(const ColourInfo &); + ColourInfo & operator=(const ColourInfo &) = delete; }; } #endif /* Ariadne5_ColourInfo_H */ diff --git a/Config/Settings.h b/Config/Settings.h --- a/Config/Settings.h +++ b/Config/Settings.h @@ -1,177 +1,177 @@ // -*- C++ -*- #ifndef ThePEG_Settings_H #define ThePEG_Settings_H // // This is the declaration of the Settings class. // #include "ThePEG/Handlers/HandlerBase.h" namespace ThePEG { /** * Here is the documentation of the Settings class. * * @see \ref SettingsInterfaces "The interfaces" * defined for Settings. */ class Settings: public HandlerBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ Settings(): verb(true) {} /** * The destructor. */ virtual ~Settings(); //@} 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; //@} public: /** * The function used for the set command. */ string setFunction(string); protected: /** @name Standard Interfaced functions. */ //@{ /** * This object needs to be initialized before all * other objects. */ virtual bool preInitialize() const; /** * Check sanity of the object during the setup phase. */ 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. */ virtual void doinit(); /** * 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(); /** * 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. */ virtual void rebind(const TranslationMap & trans); /** * Return a vector of all pointers to Interfaced objects used in this * object. * @return a vector of pointers. */ virtual IVector getReferences(); //@} private: /** * The objects that needs setting. */ IVector setObjects; /** * The interfaces that needs setting. */ vector setInterfaces; /** * The values to be set for the interfaces of the objects. */ vector setValues; /** * The references to be set for the interfaces of the objects. */ IVector setRefs; /** * Verbosity. Write out in log-file what is done. */ bool verb; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - Settings & operator=(const Settings &); + Settings & operator=(const Settings &) = delete; }; } #endif /* ThePEG_Settings_H */ diff --git a/DIPSY/AnalysisProgress.h b/DIPSY/AnalysisProgress.h --- a/DIPSY/AnalysisProgress.h +++ b/DIPSY/AnalysisProgress.h @@ -1,168 +1,168 @@ // -*- C++ -*- #ifndef DIPSY_AnalysisProgress_H #define DIPSY_AnalysisProgress_H // // This is the declaration of the AnalysisProgress class. // #include "Ariadne/DIPSY/DipoleAnalysisHandler.h" namespace DIPSY { using namespace ThePEG; /** * AnalysisProgress writes in the log file the progress of the * presampling phase of the DipoleEventHandler. * * @see \ref AnalysisProgressInterfaces "The interfaces" * defined for AnalysisProgress. */ class AnalysisProgress: public DIPSY::DipoleAnalysisHandler { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ AnalysisProgress(); /** * The destructor. */ virtual ~AnalysisProgress(); //@} public: /** @name Standard virtual functions inherited from the classes. */ //@{ /** * Initialize the analysis object. */ virtual void initialize(); /** * Just write out progress information */ virtual void analyze(const vector &, const vector &, const vector &, const DipoleXSec &, const Vec3D &, double); /** * Finalize the analysis, (compute statistics etc.). \a neve is the * number of times analyze() has been called since last * initialize(). */ virtual void finalize(long neve) {} //@} /** * Return the cpu clock in seconds. */ static double fclock(); /** * Check if it is time to write out a status line. */ bool statusTime(long i, long n) const; /** @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; //@} private: /** * The current event. */ int ieve; /** * If larger than 0, a status line will be written every secstep second. */ int secstep; /** * The clock when the run was started. */ time_t time0; /** * The cpu clock when the run was started. */ double fcpu0; /** * The clock the last time a status line was written out. */ time_t time1; /** * The cpu clock the last time a status line was written out. */ double fcpu1; /** * The host on which we are running. */ string host; /** * The pid of the current process. */ pid_t pid; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - AnalysisProgress & operator=(const AnalysisProgress &); + AnalysisProgress & operator=(const AnalysisProgress &) = delete; }; } #endif /* DIPSY_AnalysisProgress_H */ diff --git a/DIPSY/CPUTimer.h b/DIPSY/CPUTimer.h --- a/DIPSY/CPUTimer.h +++ b/DIPSY/CPUTimer.h @@ -1,245 +1,245 @@ // -*- C++ -*- #ifndef ThePEG_CPUClock_H #define ThePEG_CPUClock_H // // This is the declaration of the CPUClock class. // #include "ThePEG/Config/ThePEG.h" #include "ThePEG/Utilities/Named.h" #include "ThePEG/Utilities/DebugItem.h" #include namespace ThePEG { /** * The CPUClock class can be used to measure the time spent in a * certain function. Somewhere a long lasting object of the CPUClock * class should be created giving a name as argument. Typically this * is done my a static variable in the function of interest. Then in * the beginning of the function, a CPUTimer object is created with * the CPUClock as argument, and the time during which the CPUTimer * object is alive will be accumulated. Note that the inclusive time * spent in the function is measured - also calls to other functions - * is counted. If time spent in called functions is not wanted, the * timer can be stopped and stated by creating a PauseCPUTimer * object. If the function calls itself recursively, the time will not * be double-counted. At any time the current values of all CPUClock * objects can be dumped to a file with the static dump() function. * * Note that the call to access the CPU clock takes some time, so the * CPUClock class should not be used in very short functions. This * time affect the system CPU usage, but this is incluced in the time * reported by the CPU clock. * * For this reason, the cals to the CPU clock is only switched on if * the DebugItem ThePEG::CPUTimer is switched on (debug level 2). If * not, only the number of calls to the function is recorded. */ class CPUClock: public Named { public: /** * Everybody needs a friend. */ friend class CPUTimer; /** * Or two. */ friend class PauseCPUTimer; public: /** @name Standard constructors and destructors. */ //@{ /** * The only relevant constructor. The string should typically be on * the form "namspace::class::function". */ CPUClock(string clockname) : Named(clockname), theNCalls(0), startClock(0), totTime(0), loop(0) { clocks().push_back(this); } //@} private: /** * Call this when entring a function, starting the clock. */ void enter() { ++theNCalls; start(); } /** * Start the clock. */ void start() { if ( !loop++ ) startClock = clock(); } /** * Stop the clock. */ void stop() { if ( !--loop ) totTime += clock() - startClock; } public: static clock_t clock() { static DebugItem on("ThePEG::CPUTimer", 2); return on? std::clock(): 0; } int nCalls() const { return theNCalls; } double timeTot() const { return double(totTime)/double(CLOCKS_PER_SEC); } double timePer() const { return timeTot()/double(max(nCalls(), 1)); } static void dump(ostream & os) { os << "CPUTimer results:" << endl; for ( int i = 0, N = clocks().size(); i < N; ++i ) os << " " << clocks()[i]->name() << ": " << clocks()[i]->nCalls() << " calls totalling " << clocks()[i]->timeTot() << "s (" << clocks()[i]->timePer() << "s/call)" << endl; } private: static vector & clocks() { static vector theClocks; return theClocks; } unsigned long theNCalls; // The number of calls made to the corresponding timer. clock_t startClock; // The clock at the last call to start. unsigned long totTime; // The total time spent in the corresponding timer. unsigned int loop; // The loop level private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - CPUClock & operator=(const CPUClock &); + CPUClock & operator=(const CPUClock &) = delete; /** * The copy constructor is private and must never be called. * In fact, it should not even be implemented. */ CPUClock(const CPUClock &); /** * The default constructor is private and must never be called. * In fact, it should not even be implemented. */ CPUClock(); }; class CPUTimer { public: /** * The only relevant constructor starts the given CPUClock. */ CPUTimer(CPUClock & c): theClock(&c) { c.enter(); } /** * The destructor stops the clock. */ ~CPUTimer() { theClock->stop(); } private: /** * The clock under controll. */ CPUClock * theClock; /** * No default constructor */ CPUTimer(); /** * No copy constructor; */ CPUTimer(const CPUTimer &); /** * No assignment */ - CPUTimer & operator=(const CPUTimer &); + CPUTimer & operator=(const CPUTimer &) = delete; }; class PauseCPUTimer { public: /** * The only relevant constructor starts the given CPUClock. */ PauseCPUTimer(CPUClock & c): theClock(&c) { c.stop(); } /** * The destructor stops the clock. */ ~PauseCPUTimer() { theClock->start(); } private: /** * The clock under controll. */ CPUClock * theClock; /** * No default constructor */ PauseCPUTimer(); /** * No copy constructor; */ PauseCPUTimer(const PauseCPUTimer &); /** * No assignment */ - PauseCPUTimer & operator=(const PauseCPUTimer &); + PauseCPUTimer & operator=(const PauseCPUTimer &) = delete; }; } #endif /* ThePEG_CPUClock_H */ diff --git a/DIPSY/DiffractiveEventFiller.h b/DIPSY/DiffractiveEventFiller.h --- a/DIPSY/DiffractiveEventFiller.h +++ b/DIPSY/DiffractiveEventFiller.h @@ -1,486 +1,486 @@ // -*- C++ -*- #ifndef DIPSY_DiffractiveEventFiller_H #define DIPSY_DiffractiveEventFiller_H // // This is the declaration of the DiffractiveEventFiller class. // #include "EventFiller.h" #ifndef LWH_AIAnalysisFactory_H #ifndef LWH #define LWH ThePEGLWH #endif #include "ThePEG/Analysis/LWH/AnalysisFactory.h" #endif namespace DIPSY { using namespace ThePEG; /** * The EventFiller class is able to produce an initial * ThePEG::Collision from two colliding DipoleStates. * * @see \ref EventFillerInterfaces "The interfaces" * defined for EventFiller. */ class DiffractiveEventFiller: public EventFiller { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ DiffractiveEventFiller(); /** * The destructor. */ virtual ~DiffractiveEventFiller(); //@} public: /** * Exception class for errors in the combinators in the diffractive cascades. */ struct DiffractiveCombinatorics: public Exception {}; /** * Exception class for incorrect cascade structures. */ struct CascadeStructure: public Exception {}; public: /** @name Virtual functions which can be overridden in subclasses. */ //@{ /** * Fill the current collision object in the given DipoleEventHandler * with the final state gluons produced when dipole states \a dl and * \a dr collides with impact parameters \a b. * @return the total interaction probability. */ /** * Fill the current collision object in the given DipoleEventHandler * with the final state gluons produced when the dipole state \a dl * diffractively scatters of the virtual states stored in the eventfiller. * @return the total interaction probability. */ virtual double fill(Step & step, DipoleEventHandler & eh, tPPair inc, DipoleState & dl, DipoleState & dr, const ImpactParameters & b) const; /** * transfer p_minus and p_plus from the elastic state to set the excited state on shell. **/ virtual bool balanceMomenta(DipoleStatePtr excited, DipoleStatePtr elastic) const; /** * calculates and logs the contribution to the total diffractive cross section. **/ virtual void calculateInclusive(DipoleStatePtr real, CrossSection weight, const ImpactParameters & b) const; /** * prepares the virtual cascades that all the real states will collide against. **/ virtual void initialiseVirtualCascades(DipoleEventHandler & eh, WaveFunction & WFL, Energy E, double ymax); /** * randomly selects one of the subcascades of dr with a certain probability for each subcascade * and turns dl into that subcascade. * returns the weight to be given to the event (0 if no subcascade is chosen) **/ virtual double selectSubcascade(DipoleState & dr, double selectionProbability) const; /** * randomly selects one of the partons that is not on-shell * and puts that parton and its parents on shell in the state. **/ virtual double addRandomChain(DipoleState & dr) const; /** * randomly selects one of the single-interaction subcascades of dr with * a certain probability for each subcascade * and turns dl into that subcascade. * returns the weight to be given to the event (0 if no subcascade is chosen) **/ virtual double selectSingleSubcascade(DipoleState & dr) const; /** * randomly selects one of the subcascades of dr with N interactions * and turns dl into that subcascade. * returns an approximation of the number of possible choices **/ virtual double selectNSubcascade(DipoleState & dr, int N) const; /** * coutns the number of subcacscades with exactly one interaction **/ virtual int countSingleStates(DipoleState & dr) const; /** * counts and returns the number of subcascades of the state **/ virtual int nSubcascades(DipoleState & dr) const; /** * changes the state to its substate of choice. **/ virtual double pickSubcascade(DipoleState & dr, int choice) const; /** * changes the state to its substate o. **/ virtual void pickSubcascadeFromInteraction(DipoleState & dr, PartonPtr p) const; /** * adds a parton and its parents to the on-shell state. **/ // virtual void addChainFromInteraction(DipoleState & dr, PartonPtr p) const; /** * adds the two partons of the dipole to the set x. **/ virtual void addPartonsToSet(DipolePtr d, set x) const; /** * Set the parton and all its ancestors on shell. **/ virtual void recursiveSetOnShell(PartonPtr p) const; /** * return more likely cascades and removes(return 0.0) less likely ones. * A state with small dipole will probably get removed, but the ones that doesnt are returned with * a larger weight. **/ double reweightCascade(DipoleState & dr, vector chainCaps) const; /** * return more likely cascades and removes(return 0.0) less likely ones. * A state with small dipole will probably get removed, but the ones that doesnt are returned with * a larger weight. **/ double estimateF(DipoleStatePtr dr) const; /** * sets all the partons in the state to off-shell **/ virtual void setOffShell(DipoleState & dr) const; /** * sets all the valence partons in the state on-shell. **/ virtual void setValenceOnShell(DipoleState & dr) const; /** * sets the two partons in the dipole on shell. **/ virtual void setPartonsOnShell(DipolePtr dip) const; /** * changes the subcascade from the dipole to its substate of choice. **/ virtual double pickSubcascade(DipolePtr dip, int choice) const; /** * checks and fixes the parent structure so that the on shell partons only * are connected to each other. The others are bypassed. * This may leave some partons without children if the swing is present. **/ virtual void updateParentStructure(DipoleStatePtr dr) const; /** * finds the nonvalence partons that does not have any children. * These are at the end of the chains, and can loosely be interpreted as the interactions. **/ virtual vector childlessChildren(DipoleStatePtr dr) const; /** * removes all valence partons from the provided vector **/ virtual void removeValence(vector partons) const; /** * counts and returns the number of subcascades from this dipole **/ virtual int nSubcascades(DipolePtr dip) const; /** * makes dl real and on-shell and does all the reweighting and ordering bussiness. * p- (and pt) is balances by dr, but dr is otherwise not touched. **/ virtual void makeReal(DipoleState & dl, vector chainCaps, DipoleState & dr) const; /** * Calculates the amplitude for the real state dr to diffractively scatter on * the virtual cascades stored in the eventfiller. **/ virtual double amplitude(DipoleState & dr, vector chainCaps, const ImpactParameters & b) const; /** * Calculates the elastic amplitude for dr on the virtual cascades stored in the eventfiller. **/ virtual double elasticAmplitude(DipoleState & dr, const ImpactParameters & b) const; /** * removes the chain caps from the state dr. * Returns true if there is still at least one dipole left. **/ virtual DipoleStatePtr steriliseCaps(DipoleStatePtr dr) const; /** * returns a DipoleState with the two neighbouring dipoles to each parton in the vector. **/ virtual vector extractI(vector chainCaps) const; /** * returns a DipoleState with the dipole that emitted each parton in the vector. **/ virtual vector extractH(vector chainCaps) const; /** * returns the original emission rapidity for each parton in the vector. **/ virtual vector extractIntY(vector chainCaps) const; /** * returns a string with a single proton with the 3-momentum of the original state **/ virtual DipoleState::String makeProton(DipoleStatePtr) const; //inline functions /** * get the mode. */ inline int nElasticCascades() const { return theNElasticCascades; } /** * set the mode. */ inline void nElasticCascades(int x) { theNElasticCascades = x; } /** * get the minimum rapidity gap. */ inline double minRapGap() const { return theMinRapGap; } /** * set the minimum rapidity gap. */ inline void minRapGap(double x) { theMinRapGap = x; } /** * get the number of interactions. */ inline int nInteractions() const { return theNInteractions; } /** * set the number of interactions. */ inline void nInteractions(int x) { theNInteractions = x; } /** * get the maximum rapidity gap. */ inline double maxRapGap() const { return theMaxRapGap; } /** * set the maximum rapidity gap. */ inline void maxRapGap(double x) { theMaxRapGap = x; } /** * get the minimum rapidity. */ inline double minY() const { return theMinY; } /** * set the minimum rapidity. */ inline void minY(double x) { theMinY = x; } /** * get the maximum rapidity. */ inline double maxY() const { return theMaxY; } /** * set the maximum rapidity. */ inline void maxY(double x) { theMaxY = x; } /** * reset the number of subcascades. */ inline void resetNSubCascades() { theNSubCascades = 0.0; } /** * increase the number of subcascades. */ inline void increaseNSubCascades(double x) const { theNSubCascades += x; } /** * reset the number of subcascades. */ inline double nSubCascades() { return theNSubCascades; } //@} 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). protected: /** @name Standard Interfaced functions. */ //@{ /** * Initialize this object after the setup phase before saving an * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ virtual void doinit(); /** * Initialize this object. Called in the run phase just before * a run begins. */ virtual void doinitrun(); /** * Is this where this should be declared?? :o */ virtual void dofinish(); private: mutable CrossSection totalXSec; mutable DipoleAnalysisHandler::CrossSection2 totalSqr; mutable int neve; private: //The linera combination of virtual cascades from the elastic particle vector virtualCascades; //the number of pregenerated elstic cascades int theNElasticCascades; //the minimum rapidity gap double theMinRapGap; //the number of interactions int theNInteractions; //the total number of subcascades encountered mutable double theNSubCascades; //the maximum rapidity gap double theMaxRapGap; //the minimum rapidity that every excited state cross. double theMinY; //the maximum rapidity that no excited state cross. double theMaxY; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - DiffractiveEventFiller & operator=(const DiffractiveEventFiller &); + DiffractiveEventFiller & operator=(const DiffractiveEventFiller &) = delete; }; } #endif /* DIPSY_DiffractiveEventFiller_H */ diff --git a/DIPSY/Dipole.h b/DIPSY/Dipole.h --- a/DIPSY/Dipole.h +++ b/DIPSY/Dipole.h @@ -1,745 +1,745 @@ // -*- C++ -*- #ifndef DIPSY_Dipole_H #define DIPSY_Dipole_H // // This is the declaration of the Dipole class. // #include "ThePEG/Config/ThePEG.h" #include "Ariadne/Config/CloneBase.h" #include "Dipole.fh" #include "Parton.h" #include "EffectiveParton.h" #include "DipoleState.fh" namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the Dipole class. */ class Dipole: public Ariadne5::CloneBase { public: /** * A pair of dipoles */ typedef pair tDipolePair; /** * A pair of partons. */ typedef pair PartonPair; /** * The DipoleState is a friend. */ friend class DipoleState; /** * A map for stoing effective partons. */ typedef vector< pair > EffMap; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline Dipole() : theDipoleState(tDipoleStatePtr()), thePartons(PartonPair()), theShadows(pair()), theNeighbors(tDipolePair()), theChildren(tDipolePair()), theGeneratedGluon(PartonPtr()), theSwingDipole(tDipolePtr()), theGeneratedY(Constants::MaxRapidity), theProducedY(-Constants::MaxRapidity), theColour(-1), theInteracted(tDipolePtr()), theParent(tDipolePtr()), theGLAPsafe(false), isParticipating(true), isRecoilSwing(false), isTouched(true), isOn(true), swingCache(-1.0/GeV2), effmap(0) {} /** * The copy constructor. */ inline Dipole(const Dipole & x) : theDipoleState(x.theDipoleState), thePartons(x.thePartons), theShadows(x.theShadows), theNeighbors(x.theNeighbors), theChildren(x.theChildren), theGeneratedGluon(x.theGeneratedGluon), theSwingDipole(x.theSwingDipole), theGeneratedY(x.theGeneratedY), theProducedY(x.theProducedY), theColour(x.theColour), theInteracted(x.theInteracted), theParent(x.theParent), theGLAPsafe(x.theGLAPsafe), isParticipating(x.isParticipating), isRecoilSwing(x.isRecoilSwing), isTouched(true), isOn(x.isOn), swingCache(x.swingCache), effmap(0) {} /** * The destructor. */ virtual ~Dipole(); //@} protected: /** @name The virtual functions to be overridden in sub-classes. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual Ariadne5::ClonePtr clone() const; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} public: /** @name Simple access functions. */ //@{ /** * rMax for the dipoles handler. */ InvEnergy rMax() const; /** * The DipoleState to which this Dipole belongs. */ inline DipoleState & dipoleState() const { return *theDipoleState; } /** * Set the DipoleState to which this Dipole belongs. * added by CF to access from emitter. */ inline void dipoleState(tDipoleStatePtr dipst) { theDipoleState = dipst; } /** * Return the connecting partons. */ inline const PartonPair & partons() const { return thePartons; } /** * Return the shadows of the connecting partons. */ inline const pair & shadows() const { return theShadows; } /** * Get the effective parton. */ inline const pair< EffectivePartonPtr, EffectivePartonPtr > & effectivePartons() const { return theEffectivePartons; } /** * Get an effective parton corresponding to one of the partons in * the original dipole given a range. */ tEffectivePartonPtr getEff(tcPartonPtr p, InvEnergy range) const; /** * Set the effective parton. */ inline void effectivePartons(tEffectivePartonPtr g1, tEffectivePartonPtr g2) { theEffectivePartons = make_pair( g1, g2 ); } /** * controls if any of the effective partons have been changed by emissions. */ inline const bool effectivePartonsChanged() const { return (effectivePartons().first->changed() || effectivePartons().second->changed()); } /** * Set the neighboring dipoles. */ inline const tDipolePair & neighbors() const { return theNeighbors; } /** * Get the child dipoles. */ inline const tDipolePair & children() const { return theChildren; } /** * Get the child dipoles. */ inline tDipolePair & children() { return theChildren; } /** * Get the generated gluon to be emitted. Returns null if none has * been generated. */ inline tPartonPtr generatedGluon() const { return theGeneratedGluon; } /** * Set the generated gluon to be emitted. * Added by CF to get access from emitter. */ inline void generatedGluon(tPartonPtr p) { theGeneratedGluon = p; } /** * Get the dipole to swing with. Return null if no swing has been * generated. */ inline tDipolePtr swingDipole() const { return theSwingDipole; } /** * Set the dipole to swing with. * Aded by CF */ inline void swingDipole(tDipolePtr d) { theSwingDipole = d; } /** * Return true if this dipole has generated an emission or a swing. */ inline bool hasGen() { return (generatedGluon() || swingDipole()) && !(swingDipole() && swingDipole()->children().first); } /** * The rapidity at which this dipole was formed. */ inline double producedY() const { return theProducedY; } /** * Set the rapidity at which this dipole was formed. */ inline void producedY(double y) { theProducedY = y; } /** * The rapidity of the generated emission or swing. */ inline double generatedY() const { return theGeneratedY; } /** * Set the rapidity of the generated emission or swing. * Added by CF to access from emitter. */ inline void generatedY(double y) { theGeneratedY = y; } /** * Get a pointer to a Dipole in another DipoleState with which this * Dipole has interacted. @return null if Dipole has not interacted. */ inline tDipolePtr interacted() const { return theInteracted; } /** * Get a pointer to the parent Dipole which produced this through * emission or swing. @return null if initial dipole. */ inline tDipolePtr parent() const { return theParent; } /** * Return this dipole if it was produced before the given rapidity, * otherwise, if the parent dipole has the same colour, return this * (recursively). */ tDipolePtr resolve(double ymax); /** * Set a pointer to the parent Dipole which produced this through * emission or swing. Also set the rapidity where this Dipole is * produced. */ inline void parent(tDipolePtr d, double py) { theParent = d; theProducedY = py; } /** * Set a pointer to the parent Dipole which produced this through * emission or swing. Also set the rapidity where this Dipole is * produced. */ inline void parent(tDipolePtr d) { theParent = d; theProducedY = d->generatedY(); } /** * Returns the lengths that the new dipoles will have when it has * swinged with the interacted() dipole. returns 0 if not interacting. */ pair interactionLengths() const; /** * Set the partons. */ inline void partons(PartonPair x) { thePartons = x; } /** * Set the current shadows of the conected partons. */ inline void setShadows() { theShadows.first = thePartons.first->shadow(); theShadows.second = thePartons.second->shadow(); } /** * Set the neighboring dipoles. */ inline void neighbors(tDipolePair x) { theNeighbors = x; } /** * Set the neighboring dipole. */ inline void firstNeighbor(tDipolePtr d) { theNeighbors.first = d; } /** * Set the neighboring dipole. */ inline void secondNeighbor(tDipolePtr d) { theNeighbors.second = d; } /** * Get the colour. */ inline int colour() const { return theColour; } /** * Set the colour. */ inline void colour(int c, int sys = 0) { theColour = c; if ( sys > 0 ) colourSystem(sys); } /** * Get the colour system. */ int colourSystem() const; /** * Set the colour system. */ void colourSystem(int sys); /** * says if the dipole is part of a DGLAP chain, and thus should not be absorbed. */ inline bool DGLAPsafe() { return theGLAPsafe; } /** * Sets if the dipole is part of a DGLAP chain or not. */ inline void DGLAPsafe(bool safe) { theGLAPsafe = safe; } /** * says if the (initial) dipole is participating in the interaction. */ inline bool participating() { return isParticipating; } /** * Sets if the (initial) dipole is participating in the interaction. */ inline void participating(bool b) { isParticipating = b; } /** * gets if the generated swing is a gluon exchange. */ inline bool recoilSwing() const { return isRecoilSwing; } /** * sets if the generated swing is a gluon exchange. */ inline void recoilSwing(bool recoil) { isRecoilSwing = recoil; } /** * Indicate that the Dipole has interacted with the given Dipole in * another DipoleState. If \a onegluon is true, only one of the * gluons in this dipole is flagged as interacted. */ void interact(Dipole &, bool onegluon = false); /** * Set the pointer to the dipole with which this dipole has * interacted. Do not mark partons as interacted. */ void interacted(tDipolePtr d) { theInteracted = d; } /** * Get the squared transverse size of this Dipole. */ inline InvEnergy2 size2() const { return partons().first->dist2(*partons().second); } /** * Get the transverse size of this Dipole. */ inline InvEnergy size() const { return sqrt(size2()); } /** * Get the direction and size of this dipole. */ inline Parton::Point vSize() const { return partons().first->position() - partons().second->position(); } //@} /** @name Functions for extracting final dipoles. */ //@{ /** * Given an output iterator fill the corresponding container with * final, undecayed dipoles. This is done recursively, ie. if this * dipole has decayed, the extract methods of the two children are * called instead. */ template void extract(OutputIterator it) { //an absorbed (dead end) dipole has only second child if ( !children().first && children().second ) return; if ( children().first ) children().first->extract(it); if ( children().second ) children().second->extract(it); if ( !children().first && !children().second ) *it++ = this; } /** * Extract all undecayed dipoles into the vector according to colour * index. */ void colExtract(vector< vector > &); //@} /** * Recursively find the dipole which is next to swing in final state. */ tDipolePtr getFSSwinger(double miny, double maxy); /** * Generate a possible emission or a swing from this Dipole in the * given rapidity interval [\a miny,\a maxy]. */ void generateFSRec(double miny, double maxy); /** @name Functions for shower generation. */ //@{ /** * Recursively find the dipole which is next to emit or swing in the * given rapidity interval [\a miny,\a maxy]. */ tDipolePtr getEmitter(double miny, double maxy); /** * Generate a possible emission or a swing from this Dipole in the * given rapidity interval [\a miny,\a maxy]. */ void generate(double miny, double maxy); /** * Generate a swing for this Dipole in the given rapidity interval * [\a miny,\a maxy]. If \a force is true, always generate a swing, * otherwise only check if a swing is possible with dipoles which * are new or has changed. */ void generateRec(double miny, double maxy, bool force); /** * Try really hard to generates a swing, but not with higher rapdity step * than /a ymax. /a ymax = 0 means no limit. * If no swing found, return false. */ bool forceGenerateRec(double ymax); /** * Perform a recombination previously generated by generateRec(). */ void recombine(); /** * absorb the dipole, replacing it with a single parton. */ void absorb(); /** * Perform the emission previously generated for this \a dipole. If * no emission has been generated a runtime_error is thrown. */ void emit(); //@} public: /** * Split this dipole by emitting the generated gluon. \a colsel * gives the probability that the first child dipole inherits the * colour index of the mother. */ void splitDipole(double colsel); /** * Reset any emission or swong generated for this dipole. */ void reset(); /** * Check if conditions for this dipole has changed since last * generated emission or swing. */ bool touched() const { return isTouched; } /** * Flag that conditions for this dipole has changed since last * generated emission or swing. */ void touch() { isTouched = true; } /** * Flag that this dipole no has generated emission or swing. */ void untouch() { isTouched = false; } /** * Flag that this dipole should no longer emit. */ void turnOff() { isOn = false; } protected: struct NothingGenerated: public Exception {}; 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(); private: /** * The DipoleState to which this Dipole belongs. */ tDipoleStatePtr theDipoleState; /** * The partons. */ PartonPair thePartons; /** * The current shadows of the connecting partons. */ pair theShadows; /** * The neighboring dipoles. */ tDipolePair theNeighbors; /** * The child dipoles. */ tDipolePair theChildren; /** * The generated gluon to be emitted. Null if none has been generated. */ PartonPtr theGeneratedGluon; /** * the effective partons. */ pair< EffectivePartonPtr, EffectivePartonPtr > theEffectivePartons; /** * The dipole to swing with. Null if no swing has been generated. */ tDipolePtr theSwingDipole; /** * The rapidity of the generated emission or swing. */ double theGeneratedY; /** * The rapidity at which this dipole was formed. */ double theProducedY; /** * The colour index of this Dipole. */ int theColour; /** * If non-null, pointer to a Dipole in another DipoleState with which * this Dipole has interacted. */ tDipolePtr theInteracted; /** * The parent which created this dipole through emission or swing. */ tDipolePtr theParent; /** * If the dipole is part of a DGLAP chain or not in the final state. */ bool theGLAPsafe; /** * if the (initial) dipole is part of a participating nucleon in a * heavy ion collision. */ bool isParticipating; /** * If the generated swing is gluon exchange or quadrupole swing. */ bool isRecoilSwing; /** * Indicate if conditions for this dipole has changed since last * generated emission or swing. */ bool isTouched; /** * This can be set to false to manually turn a dipole of, ie disallow * emissions or swings. **/ bool isOn; public: /** * Cache values needed for (FS) swing. */ mutable InvEnergy2 swingCache; /** * A pair of maps where the effective partons are stored. */ mutable pair * effmap; /** * Build the map of effective partons. */ void buildEffMap() const; /** * Return a tag identifying this dipole. */ string tag() const; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - Dipole & operator=(const Dipole &); + Dipole & operator=(const Dipole &) = delete; }; } #endif /* DIPSY_Dipole_H */ diff --git a/DIPSY/DipoleAbsorber.h b/DIPSY/DipoleAbsorber.h --- a/DIPSY/DipoleAbsorber.h +++ b/DIPSY/DipoleAbsorber.h @@ -1,120 +1,120 @@ // -*- C++ -*- #ifndef DIPSY_DipoleAbsorber_H #define DIPSY_DipoleAbsorber_H // // This is the declaration of the DipoleAbsorber class. // #include "DipoleAbsorber.fh" #include "ThePEG/Handlers/HandlerBase.h" #include "Ariadne/DIPSY/DipoleState.fh" #include "Ariadne/DIPSY/Parton.fh" #include "Ariadne/DIPSY/Dipole.fh" namespace DIPSY { using namespace ThePEG; /** * DipoleAbsorber is a base class to be used for models describing how * non-interacted dipoles will be reabsorbed. The only function to be * overridden by sub-classes is called reabsorb. * * @see \ref DipoleAbsorberInterfaces "The interfaces" * defined for DipoleAbsorber. */ class DipoleAbsorber: public HandlerBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ DipoleAbsorber(); /** * The destructor. */ virtual ~DipoleAbsorber(); //@} public: /** @name Virtual functions to be overridden in sub-classes. */ //@{ /** * Reabsorb dipoles in the given state. */ virtual void reabsorb( DipoleState &) const = 0; /** * Swing so that all non participating nucleons are just the original triangle. */ virtual void isolateNonParticipating ( DipoleState & ) const; /** * Adds recoils from dipoles that has emitted, trying to account * for emission history. */ virtual void hiddenRecoil(DipoleState & ) const = 0; /** * Absorb the provided parton, sharing p_mu according to distance. * swing determines if a swing should be forced if the parton is in a loop. */ virtual void absorbParton ( tPartonPtr p, DipoleState & ) const = 0; /** * Removes the parton and recouples the colow flow, * without transfering its momentum to other partons. * Does not swing loops, that has to be handled before calling this. */ virtual void removeParton ( tPartonPtr p ) const; /** * Absorb the virtual partons that has no interacting children. */ virtual void absorbVirtualPartons ( DipoleState & ) const; /** * Swings the loop that the dipole /a d is part of. */ virtual void swingLoop( DipolePtr d, DipoleState &) const; /** * Swings the two dipoles. */ virtual bool swing ( DipolePtr, DipolePtr ) const; //@} public: /** * 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(); // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - DipoleAbsorber & operator=(const DipoleAbsorber &); + DipoleAbsorber & operator=(const DipoleAbsorber &) = delete; }; } #endif /* DIPSY_DipoleAbsorber_H */ diff --git a/DIPSY/DipoleAnalysisHandler.h b/DIPSY/DipoleAnalysisHandler.h --- a/DIPSY/DipoleAnalysisHandler.h +++ b/DIPSY/DipoleAnalysisHandler.h @@ -1,142 +1,142 @@ // -*- C++ -*- #ifndef DIPSY_DipoleAnalysisHandler_H #define DIPSY_DipoleAnalysisHandler_H // // This is the declaration of the DipoleAnalysisHandler class. // #include "ThePEG/Handlers/HandlerBase.h" #include "ThePEG/Analysis/FactoryBase.h" #include "DipoleAnalysisHandler.fh" #include "Ariadne/DIPSY/DipoleState.fh" #include "Ariadne/DIPSY/ImpactParameters.h" #include "Ariadne/DIPSY/DipoleXSec.fh" namespace DIPSY { using namespace ThePEG; /** * The DipoleAnalysisHandler class can be used as a base class for * sub-classes which can be used in the initialization of a * DipoleEventHandler, where statistics on, eg. total and elastic * cross sections, can be collected during the presampling phase. * * @see \ref DipoleAnalysisHandlerInterfaces "The interfaces" * defined for DipoleAnalysisHandler. */ class DipoleAnalysisHandler: public HandlerBase { public: /** * Convenient typedef */ typedef vector< vector< vector > > Vec3D; /** * Convenient typedef. */ typedef decltype(CrossSection()*CrossSection()) CrossSection2; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ DipoleAnalysisHandler(); /** * The destructor. */ virtual ~DipoleAnalysisHandler(); //@} public: /** @name Standard virtual functions to be overridden in sub-classes. */ //@{ /** * Initialize the analysis object. */ virtual void initialize() = 0; /** * Analyze a given collision given left- and right-moving dipole * states, \a dl and \a dr, an ImpactParameters object, \a b, a * cross section object, \a xsec, the total summed dipole-dipole * scattering probabilities, \a fsum, and the total \a weight * associated with the generated states. */ virtual void analyze(const DipoleState & dr, const DipoleState & dl, const ImpactParameters & b, const DipoleXSec & xsec, double fsum, CrossSection weight); /** * Analyze a given set of collision given a set of left- and * right-moving dipole states in \a vl and \a vr, an a set of * ImpactParameters object in \a vb, and a cross section object, \a * xsec, and the total summed dipole-dipole scattering * probabilities, \a probs. Also a jacobian, \a jac, is supplied in * case of varying total energy. */ virtual void analyze(const vector & vr, const vector & vl, const vector & vb, const DipoleXSec & xsec, const Vec3D & probs, double jac); /** * Finalize the analysis, (compute statistics etc.). \a neve is the * number of times analyze() has been called since last * initialize(). */ virtual void finalize(long neve) = 0; //@} /** * Return a pointer to the FactoryBase object of this run */ inline tHistFacPtr factory() const { return generator()->histogramFactory(); } /** * Return a pointer to the FactoryBase object of this run */ inline AIDA::IHistogramFactory & histogramFactory() const { return generator()->histogramFactory()->histogramFactory(); } /** * Write out stub for output line. */ ostream & stub(string) const; /** * 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(); // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - DipoleAnalysisHandler & operator=(const DipoleAnalysisHandler &); + DipoleAnalysisHandler & operator=(const DipoleAnalysisHandler &) = delete; }; } #endif /* DIPSY_DipoleAnalysisHandler_H */ diff --git a/DIPSY/DipoleDensityAnalysis.h b/DIPSY/DipoleDensityAnalysis.h --- a/DIPSY/DipoleDensityAnalysis.h +++ b/DIPSY/DipoleDensityAnalysis.h @@ -1,152 +1,152 @@ // -*- C++ -*- #ifndef DIPSY_DipoleDensityAnalysis_H #define DIPSY_DipoleDensityAnalysis_H // // This is the declaration of the DipoleDensityAnalysis class. // #include "DipoleAnalysisHandler.h" #include "ThePEG/Analysis/FactoryBase.h" #include "ThePEG/Analysis/LWH/AnalysisFactory.h" namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the DipoleDensityAnalysis class. * * @see \ref DipoleDensityAnalysisInterfaces "The interfaces" * defined for DipoleDensityAnalysis. */ class DipoleDensityAnalysis: public DIPSY::DipoleAnalysisHandler { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ DipoleDensityAnalysis(); /** * The destructor. */ virtual ~DipoleDensityAnalysis(); //@} public: /** @name Standard virtual functions inherited from the classes. */ //@{ /** * Initialize the analysis object. */ virtual void initialize(); /** * Analyze a given collision. Given left- and right-moving dipole * states, \a dl and \a dr, an ImpactParameters object, \a b, a * cross section object, \a xsec, and the total summed dipole-dipole * scattering probabilities, \a fsum, and the total \a weight * associated with the generated states. */ virtual void analyze(const DipoleState & dl, const DipoleState & dr, const ImpactParameters & b, const DipoleXSec & xsec, double fsum, CrossSection weight); /** * Finalize the analysis, (compute statistics etc.). \a neve is the * number of times analyze() has been called since last * initialize(). */ virtual void finalize(long neve); //@} /** * Fill dipoles from a state. */ void fill(const DipoleState & ds); 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; //@} private: /** * Sum of weights. */ double sumw; /** * The bare distribution in dipole sizes. */ FactoryBase::tH1DPtr dipsizes; FactoryBase::tH1DPtr dipsizesl; /** * The bare distribution in gluon transverse momenta. */ FactoryBase::tH1DPtr gluonpts; FactoryBase::tH1DPtr gluonptsl; FactoryBase::tH1DPtr gluonptsll; FactoryBase::tH1DPtr gluonptsh; FactoryBase::tH1DPtr gluonptsy; FactoryBase::tH1DPtr gluonptav; FactoryBase::tH1DPtr gluonptavn; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - DipoleDensityAnalysis & operator=(const DipoleDensityAnalysis &); + DipoleDensityAnalysis & operator=(const DipoleDensityAnalysis &) = delete; }; } #endif /* DIPSY_DipoleDensityAnalysis_H */ diff --git a/DIPSY/DipoleEventHandler.h b/DIPSY/DipoleEventHandler.h --- a/DIPSY/DipoleEventHandler.h +++ b/DIPSY/DipoleEventHandler.h @@ -1,674 +1,674 @@ // -*- C++ -*- #ifndef DIPSY_DipoleEventHandler_H #define DIPSY_DipoleEventHandler_H // // This is the declaration of the DipoleEventHandler class. // #include "ThePEG/Handlers/EventHandler.h" #include "DipoleEventHandler.fh" #include "WaveFunction.h" #include "DipoleXSec.h" #include "Emitter.h" #include "Swinger.h" #include "EventFiller.h" // #include "DiffractiveEventFiller.h" #include "ImpactParameterGenerator.h" #include "DipoleAnalysisHandler.h" #include "ThePEG/StandardModel/AlphaSBase.h" #include "ThePEG/StandardModel/StandardModelBase.h" #include "ThePEG/Utilities/XSecStat.h" namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the DipoleEventHandler class. * * @see \ref DipoleEventHandlerInterfaces "The interfaces" * defined for DipoleEventHandler. */ class DipoleEventHandler: public EventHandler { public: /** Declare a pointer to an AlphaSBase object. */ typedef Ptr::pointer ASPtr; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ DipoleEventHandler(); /** * The destructor. */ virtual ~DipoleEventHandler(); //@} public: /** * Initialize this event handler and all related objects needed to * generate events. */ virtual void initialize(); /** * Pre-sample the cross section before generating events. * This does inclusive cross section for non-diffractive collisions. * Diffractive inclusive cross sections are redirected. */ void presample(); /** * Pre-sample the single diffractive cross section before * generating events. This requires a different method, as it * needs a double loop over events. */ void diffractivePresample(); /** * Generate an event. */ virtual EventPtr generateEvent(); /** * Generate a diffractive event. */ virtual EventPtr generateDiffractiveEvent(); /** * Write out statistics. */ virtual void statistics(ostream &) const; /** * The total integrated cross section of the processes generated in * this run. * @return 0 if no integrated cross section could be estimated. */ virtual CrossSection integratedXSec() const; /** * The error total integrated cross section of the processes * generated in this run. * @return 0 if no integrated cross section could be estimated. */ virtual CrossSection integratedXSecErr() const; /** * The overestimated cross section ised in the generation. */ CrossSection maxXSec() const; /** * Histogram scale. A histogram bin which has been filled with the * weights associated with the Event objects should be scaled by * this factor to give the correct cross section. */ virtual CrossSection histogramScale() const; /** * Return the running coupling for the given scale. */ double alphaS(Energy mu) const; /** * Return the running coupling for the given size. */ inline double alphaSr(InvEnergy r) const { return alphaS(pTScale()/r); } /** @name Simple access functions. */ //@{ /** * The number of different colour indices. */ inline int nColours() const { return theNColours; } /** * The general hadronic size. */ inline InvEnergy rMax() const { return theM0 <= ZERO? theRMax: pTScale()/theM0; } /** * The non-perturbative scale. */ inline Energy m0() const { return theM0 > ZERO? theM0: pTScale()/theRMax; } /** * Get the typical size of a baryon to be used by wave functions not * defining their own. */ inline InvEnergy baryonSize() const { return theBaryonSize > ZERO? theBaryonSize: rMax(); } /** * The maximum range at which coherent emissions are allowed. */ inline InvEnergy coherenceRange() const { return theCoherenceRange; } /** * Return the effective parton mode. */ inline int effectivePartonMode() const { return theEffectivePartonMode; } /** * Return the collision type. */ inline int collisionType() const { return theCollisionType; } /** * The value of \f$\Lambda_{QCD}\f$ to be used in the running coupling. */ inline Energy LambdaQCD() const { return theLambdaQCD; } /** * The number of flavours to be used in the running coupling. */ inline int nF() const { return theNF; } /** * The value of the constant coupling. If zero, a running coupling is assumed. */ inline double fixedAlphaS() const { return theFixedAlphaS; } /** * An external \f$\alpha_S\f$ object to be used if LambdaQCD() is zero. */ inline ASPtr externalAlphaS() const { return theExternalAlphaS; } /** * Alpha bar = alphas*Nc/pi */ inline double alphaBarr(InvEnergy r) const { return alphaSr(r)*3.0/M_PI; } /** * Alpha bar = alphas*Nc/pi */ inline double alphaBar(Energy mu) const { return alphaS(mu)*3.0/M_PI; } /** * Get the wave function of the incoming particle along the positive z-axis. */ inline WaveFunction & WFR() const { return *theWFR; } /** * Get the wave function of the incoming particle along the negative z-axis. */ inline WaveFunction & WFL() const { return *theWFL; } /** * Get the object responsible for generating the impact parameters. */ inline const ImpactParameterGenerator & bGen() const { return *theBGen; } /** * Indicate whether a fudge factor should be included to tame the * high-pt tail according to an approximate matrix element * correction. */ inline int fudgeME() const { return theFudgeME; } /** * Indicate whether an additional fudge factor should be included to tame the * high-pt tail in the interactions. */ inline double fudgeFactorME() const { return theFudgeFactorME; } /** * Indicate in which frame the dipole systems should collide. */ inline double yFrame() const { return theYFrame; } /** * Options related to using the full rapidity range for both * cascades and decide interaction fram on a dipole-dipole basis. */ inline int noFrame() const { return theNoFrame; } /** * Return the rapidity to use for the interaction frame. */ double interactionFrame(double ymin, double ymax) const; /** * Get the number of collisions to analyze in the presampling. */ inline int preSamples() const { return thePreSamples; } /** * The number of left-moving systems to generate for each presample. */ inline int preSampleL() const { return thePreSampleL; } /** * The number of right-moving systems to generate for each presample. */ inline int preSampleR() const { return thePreSampleR; } /** * The number of impact parameters to generate for each presample. */ inline int preSampleB() const { return thePreSampleB; } /** * Get the object responsible for calculating the cross section for * two colliding dipole systems. */ inline const DipoleXSec & xSecFn() const { return *theXSecFn; } /** * Get the object responsible for generating and performing dipole * emissions of gluons. */ inline const Emitter & emitter() const { return *theEmitter; } /** * Get the scale used to convert between impact parameters and * transverse momenta. */ double pTScale() const { return thePTScale > 0? thePTScale: emitter().pTScale(); } /** * Set the object responsible for generating and performing dipole * emissions of gluons. * Added by CF to access from emitter. */ inline void emitter(EmitterPtr em) { theEmitter = em; } /** * Set the object responsible for generating and performing dipole * swings. * Added by CF to access from emitter. */ inline void swinger(SwingerPtr sw) { theSwinger = sw; } /** * Get the object responsible for generating and performing dipole swings. */ inline const Swinger & swinger() const { return *theSwinger; } /** * Get the object responsible for generating and performing dipole swings. */ inline tSwingerPtr swingPtr() const { return theSwinger; } /** * Get the object responsible for filling an event with final state gluons. */ inline const EventFiller & eventFiller() const { return *theEventFiller; } // /** // * Get the object responsible for filling an event with final state gluons. // */ // inline const DiffractiveEventFiller & diffractiveEventFiller() const { // return *theDiffractiveEventFiller; // }; /** * adds an error to the counter **/ inline void err() const { theNErr++; }; /** * returns teh number of errors so far. **/ inline const long nErr() const { return theNErr; }; //@} 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The number of different colour indices. */ int theNColours; /** * The general hadronic size. */ InvEnergy theRMax; /** * The Non-perturbative scale correponding to a small gluon mass. If * zero or less it is instead given by thePTScale/theRMax. */ Energy theM0; /** * The scale used to relate impactparameter distances and transverse * momenta. */ double thePTScale; /** * The typical size of a baryon to be used by wave functions not * defining their own. If zero, theRMax or theM0 will be used instead. */ InvEnergy theBaryonSize; /** * The maximum range at which partons can emit coherently as effective partons. */ InvEnergy theCoherenceRange; /** * The way the partons are grouped into effective partons. */ int theEffectivePartonMode; /** * The type of collison. 0: non diffractive, 1: single diffractive */ int theCollisionType; /** * if the history of every event should be studied manually. */ bool doShowHistory; /** * The value of \f$\Lambda_{QCD}\f$ to be used in the running coupling. */ Energy theLambdaQCD; /** * The number of flavours to be used in the running coupling. */ int theNF; /** * The value of the constant coupling. If zero, a running coupling is assumed. */ double theFixedAlphaS; /** * An external \f$\alpha_S\f$ object to be used if LambdaQCD() is zero. */ ASPtr theExternalAlphaS; /** * The wave function of the incoming particle along the positive z-axis. */ WaveFunctionPtr theWFR; /** * The wave function of the incoming particle along the negative z-axis. */ WaveFunctionPtr theWFL; /** * The object responsible for generating the impact parameters. */ ImpactParameterGeneratorPtr theBGen; /** * Indicate in which frame the dipole systems should collide. */ double theYFrame; /** * Options related to using the full rapidity range for both * cascades and decide interaction fram on a dipole-dipole basis. */ int theNoFrame; /** * Indicate whether a fudge factor should be included to tame the * high-pt tail according to an approximate matrix element correction, * and, if so, should the dipole colours be taken into account. */ int theFudgeME; /** * Indicate whether an extra fudge factor should be included to tame * the high-pt tail in the interactions according to an approximate * matrix element correction. */ double theFudgeFactorME; /** * The number of collisions to analyze in the presampling. */ int thePreSamples; /** * The number of left-moving systems generated for each presample. */ int thePreSampleL; /** * The number of right-moving systems generated for each presample. */ int thePreSampleR; /** * The number of impact parameters generated for each presample. */ int thePreSampleB; /** * The object responsible for calculating the cross section for two * colliding dipole systems. */ DipoleXSecPtr theXSecFn; /** * The object responsible for generating and performing dipole * emissions of gluons. */ EmitterPtr theEmitter; /** * The object responsible for generating and performing dipole swings. */ SwingerPtr theSwinger; /** * The object responsible for filling an event with final state gluons. */ EventFillerPtr theEventFiller; // /** // * The object responsible for filling an event with diffractive final state gluons. // */ // DiffractiveEventFillerPtr theDiffractiveEventFiller; /** * A list of analysis objects to be applied in the presample phase. */ vector analyses; /** * Collect statistics. */ XSecStat stats; /** * The number of error messages. **/ mutable long theNErr; protected: /** @name Standard Interfaced functions. */ //@{ /** * Initialize this object after the setup phase before saving an * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ virtual void doinit(); /** * 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(); /** * 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. */ virtual void rebind(const TranslationMap & trans); /** * Return a vector of all pointers to Interfaced objects used in this * object. * @return a vector of pointers. */ virtual IVector getReferences(); //@} public: /** Return the elapsed number of seconds since lat call. */ static double elapsed(); private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - DipoleEventHandler & operator=(const DipoleEventHandler &); + DipoleEventHandler & operator=(const DipoleEventHandler &) = delete; }; } #endif /* DIPSY_DipoleEventHandler_H */ diff --git a/DIPSY/DipoleState.h b/DIPSY/DipoleState.h --- a/DIPSY/DipoleState.h +++ b/DIPSY/DipoleState.h @@ -1,699 +1,699 @@ // -*- C++ -*- #ifndef DIPSY_DipoleState_H #define DIPSY_DipoleState_H // // This is the declaration of the DipoleState class. // #include "ThePEG/Config/ThePEG.h" #include "DipoleState.fh" #include "Dipole.h" #include "DipoleEventHandler.fh" #include "WFInfo.h" #include "DipoleXSec.h" #include "ThePEG/EventRecord/Particle.h" #include "ShadowParton.h" #include "ThePEG/Analysis/FactoryBase.h" #ifndef LWH_AIAnalysisFactory_H #ifndef LWH #define LWH ThePEGLWH #endif #include "ThePEG/Analysis/LWH/AnalysisFactory.h" #endif namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the DipoleState class. */ class DipoleState: public PersistentBase { public: /** * Copy FList typedef from DipoleXSec. */ typedef DipoleXSec::FList FList; /** * A String is simply a vector of colour-connected partons. */ typedef vector String; public: /** @name Standard constructors and destructors. */ //@{ /** * The standard constructor taking the controlling * DipoleEventHandler as argument. */ inline DipoleState(const DipoleEventHandler & h, WFInfoPtr wf = WFInfoPtr()) : thePlus(ZERO), theMinus(ZERO), theMinusDeficit(ZERO), theHandler(&h), theWFInfo(wf), theWeight(1.0), doTakeHistory(false), theYmax(0.0), theCollidingEnergy(ZERO) {} /** * The default constructor. */ inline DipoleState() : thePlus(ZERO), theMinus(ZERO), theMinusDeficit(ZERO), theWeight(1.0), doTakeHistory(false), theYmax(0.0), theCollidingEnergy(ZERO) {} /** * The copy constructor. */ DipoleState(const DipoleState &); /** * The destructor. */ virtual ~DipoleState(); //@} public: /** * Runs through a final state evolution checking for swings only. */ void swingFS(double ymin, double ymax); /** * Does some colour recconection for the valence partons to account for * original 3 colour colour structure of a proton. */ void normaliseValenceCharge(int mode); /** * Makes sure the non-participating nucleons of an AA collision have the * colour flow of the original triangles. */ void restoreNonparticipants(); /** * counts and returns the number of spectating nucleons. */ int numberOfSpectators() const; /** * Makes sure the the two partons are conected by a dipole with p1 as first parton. * returns false if it fails, and they are left not connected. */ bool restoreDipole(PartonPtr p1, PartonPtr p2); /** * Evolve this state from the given minimum to the given maximum * rapidity, assuming there will be p- coming from the other state. */ void evolve(double ymin, double ymax); /** * Makes the state merge with another colliding state. */ DipoleStatePtr collide(DipoleStatePtr otherState, const vector & sel, const ImpactParameters & b); /** * Makes the state merge with another colliding state. */ DipoleStatePtr merge(DipoleStatePtr otherState); /** * mirrors the state in rapidity around y0. */ void mirror(double y0); /** * moves all partons and their pT according to the imparctparameter b. */ void translate(const ImpactParameters & b ); /** * Fix up valens partons if they were not of the correct flavour or * if they should collapse into a hadron. */ virtual void fixValence(Step & step) const; /** * returns the positions of all partons in the state, * together with the size of the largest neighbouring dipole. */ vector > points(); /** * Checks through all partons and reabsorbs the ones which are * considered enough gain in some kind of virtuality. */ void absorbSmallDipoles(); /** * Removes all the parents of the dipoles, and sets the currently * active dipoles as the initial ones. **/ void makeOriginal(); /** * returns teh average distance in rapidity of the interacting dipoles. */ double avYInInt() const; /** * Controls and couts various info about the state. Returns false * if something is too wrong. */ bool diagnosis(bool print) const; /** * Check parton consistency */ static void checkPartonConsistency(tcPartonPtr p); /** * Check dipole consistency */ static void checkDipoleConsistency(tcDipolePtr p); /** * Check energy-momentum conservation. */ void checkFSMomentum() const; /** * Check energy-momentum conservation. */ void checkFSMomentum(const Step & step) const; /** * Prints the state to file. */ void saveGluonsToFile(double weight) const; /** * Returns the partons sorted in Strings. */ vector strings(); /** * Returns the active partons. */ list getPartons() const; /** * Returns the active dipoles. */ list getDipoles() const; /** * Returns all dipoles. */ set getAllDipoles() const { return allDipoles; } /** * Makes the state reabsorb a parton. */ void reabsorb(PartonPtr p); /** * Makes the state reabsorb a parton, and continues to absorb as * long as the dipoles gets smaller along the colour chain. */ void recursiveReabsorb(PartonPtr p); /** * Forces one of the dipoles connected to the parton * to immediately swing. But not with higher rapdity * step than /a ymax1 of same colour, or /a ymax2 of * another colour if same colour cant be found. * /a ymax = 0 mean no limit. */ bool forceSwing(PartonPtr d, double ymax1, double ymax2); /** * Shuffles p+ and p- between the left and right part of the state * so that the particles are really on shell. Assumes m=0 atm. */ void balanceMomenta(); /** * Check if shadows has been setup. */ bool hasShadows() const { return !theIncomingShadows.empty(); } /** * Set up shadow partons for all valence partons, thus initializing * the shadow parton procedure. */ void setupShadows(); /** * Reset all interaction flags and interactions in all shadows. */ void resetShadows(); /** * Reset all interaction flags in all shadows. */ void resetInteractedShadows(); /** * Return the incoming momentum of the given valens shadow parton. */ ShadowParton::Propagator incomingMomentum(tcSPartonPtr valence, int mode); /** * Get the weight associated with the generation of this dipole state. */ inline double weight() const { return theWeight; } /** * Set the weight associated with the generation of this dipole state. */ inline void weight(double x) { theWeight = x; } /** * Get the p+ that the original particle brought. */ inline Energy plus() const { return thePlus; } /** * Set the p+ that the original particle brought. */ inline void plus(Energy E) { thePlus = E; } /** * Get the p- that the original particle brought. */ inline Energy minus() const { return theMinus; } /** * Set the p- that the original particle brought. */ inline void minus(Energy E) { theMinus = E; } /** * Get the p- that the original particle was missing. */ inline Energy minusDeficit() const { return theMinusDeficit; } /** * Set if the state should save its history or not. */ inline void takeHistory(bool b) { doTakeHistory = b; } /** * saves the current state into the states history, but only if * doTakeHistory is true. */ inline void save() { if ( doTakeHistory ) theHistory.push_back( clone() ); } /** * The list of initial dipoles. */ inline const vector & initialDipoles() const { return theInitialDipoles; } /** * Adds a dipole to the initial Dipoles. * Mainly for testing purposes. */ inline void addDipole(Dipole & dip) { theInitialDipoles.push_back(& dip); } /** * Get additional info about the wavefunction used to create this state. */ inline WFInfoPtr WFInfo() const { return theWFInfo; } /** * Get additional info about the wavefunction used to create this state. */ inline const WaveFunction & wf() const { return WFInfo()->wf(); } /** * Set additional info about the wavefunction used to create this state. */ inline void WFInfo(WFInfoPtr x) { theWFInfo = x; } /** * The controlling DipoleEventHandler. */ inline const DipoleEventHandler & handler() const { return *theHandler; } /** * Set the controlling DipoleEventHandler. * added by CF to access from emitter. */ inline void handler(tcDipoleEventHandlerPtr hdl) { theHandler = hdl; } /** * Erase a Dipole from this state. */ inline void eraseDipole(tDipolePtr d) { allDipoles.erase(d); } /** * Create a Dipole belonging to this state. */ inline tDipolePtr createDipole() { DipolePtr d = new_ptr(Dipole()); d->theDipoleState = this; allDipoles.insert(d); return d; } /** * Generate a consistent colour index for the given Dipole. */ void generateColourIndex(tDipolePtr); /** * Make all colours belong to the same system. */ void unifyColourSystems(int isys = 0); /** * Returns all active dipoles of a certain colour. Optionally only * return dipoles which have been touched since the last emission. */ inline const vector & swingCandidates(int c, bool touched = false) const { static vector dummy; if ( !touched ) return theSwingCandidates[c]; if ( c >= int(theTouchedSwingCandidates.size()) ) return dummy; return theTouchedSwingCandidates[c]; } /** * adds the dipole, and all its children, to theSwingCandidates list. * includes interacting dipoles. */ void sortDipoleFS(Dipole &); /** * Sort in colour all the dipoles originating from initialDipoles. * includes interacting dipoles. */ void sortDipolesFS(); /** * Sort in colour all the dipoles originating from initialDipoles. * includes interacting dipoles. */ void sortFSDipoles(); /** * Return the total lambda measure for all final state dipoles. */ pair lambdaMeasure(Energy2 scale = 1.0*GeV2, FactoryBase::tH1DPtr histlength = 0, FactoryBase::tH1DPtr histmass = 0) const; /** * adds the dipole, and all its children, to theSwingCandidates list. */ void sortDipole(Dipole &); /** * Sort in colour all the dipoles originating from initialDipoles. */ void sortDipoles(); /** * Returns a list of all the active nonvalence partons that has not interacted. */ const list virtualPartons() const; /** * Calculates and returns the set of the loops in the state. */ const set< list > loops() const; /** * Returns the highest rapidity in any parton in the state. */ const double highestY() const; /** * Returns the highest rapidity in any parton in the state. */ const double lowestY() const; /** * Returns the rapidity the state has been evolved to. */ const double ymax() const; /** * Gets the energy the colliding state will supply. */ const Energy collidingEnergy() const; /** * Sets the energy the colliding state will supply. */ void collidingEnergy(Energy); /** * Return the incoming particle(s) mapped to the corresponding valence particles. */ inline const map > & incoming() const { return theIncoming; } /** * Return a ThePEG::Particle produced from the given * DIPSY::Parton. I nocreate is true, only return a particle which * has previously been created, do not create any new ones. */ tPPtr getParticle(tcPartonPtr parton, bool nocreate = false) const; /** * Given an output iterator fill the corresponding container with * final, undecayed dipoles. This is done recursively, ie. if this * dipole has decayed, the extract methods of the two children are * called instead. */ template inline void extract(OutputIterator it) const { for ( int i = 0, N = initialDipoles().size(); i < N; ++i ) initialDipoles()[i]->extract(it); } 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(); public: /** * Clone this state and all the dipoles and partons in it. */ DipoleStatePtr clone(); protected: /** * The p+ and p- that the original particle had. */ Energy thePlus; Energy theMinus; /** * Keeps track of extra missing p- that is not reflected in the * valence partons. */ Energy theMinusDeficit; /** * The controlling DipoleEventHandler. */ tcDipoleEventHandlerPtr theHandler; /** * The list of initial dipoles. */ vector theInitialDipoles; /** * The active dipoles sorted by colour. /CF */ vector< vector > theSwingCandidates; /** * The active dipoles which have been touched since the last * emission, sorted by colour */ vector< vector > theTouchedSwingCandidates; /** * Additional info about the wavefunction used to create this state. */ WFInfoPtr theWFInfo; /** * The weight associated with the generation of this dipole state. */ double theWeight; /** * If the history should be saved and displayed or not. */ bool doTakeHistory; /** * The rapidity the state has been evolved to. */ double theYmax; /** * How much energy the meeting particle have. */ Energy theCollidingEnergy; /** * The history of this state. */ vector theHistory; /** * The set of all dipoles belonging to this state. */ set allDipoles; /** * A map relating incoming particles with the valens partons. */ map > theIncoming; /** * A map relating a produced ThePEG::Particle to its DIPSY::Parton. */ mutable map theProducedParticles; /** * The shadowing incoming partons. */ vector theIncomingShadows; /** * The propagator momenta of each valence shadow. Set once and for * all as the total momentum of the state minus all other valence * shadows. */ map theShadowPropagators; protected: /** * Exception class for badly connected dipoles. */ struct DipoleConnectionException: public Exception {}; /** * Exception class for bad kinematics. */ struct DipoleKinematicsException: public Exception {}; /** * Exception class for bad DGLAP checks. */ struct DipoleDGLAPSafeException: public Exception {}; public: /** * Helper function for fixValence implementation. Take the momentum * \a p and return a new momentum with the mass \a m, such that the * total rest massof the system when combined with a fererence * momentum, \a ref, and the reference momentum itself is * preserved. Note that this will change the total momentum of the * system, but this is fixed in the end by a simple global boost in * the fixValence method. If \a Rshift is non-null, the * corresponding object is set to the boost from the old total frame * to the current one. */ static LorentzMomentum changeMass(LorentzMomentum p, Energy m, LorentzMomentum ref, LorentzRotation * Rshift = 0); /** * Printout the shadow structure if available. */ void debugShadowTree() const; void checkShadowMomentum(Sum20Momentum & sum20, const ImpactParameters * b = 0) const; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - DipoleState & operator=(const DipoleState &); + DipoleState & operator=(const DipoleState &) = delete; }; } #endif /* DIPSY_DipoleState_H */ diff --git a/DIPSY/DipoleXSec.h b/DIPSY/DipoleXSec.h --- a/DIPSY/DipoleXSec.h +++ b/DIPSY/DipoleXSec.h @@ -1,754 +1,754 @@ // -*- C++ -*- #ifndef DIPSY_DipoleXSec_H #define DIPSY_DipoleXSec_H // // This is the declaration of the DipoleXSec class. // #include "ThePEG/Handlers/HandlerBase.h" #include "DipoleXSec.fh" #include "Dipole.h" #include "DipoleState.fh" #include "ImpactParameters.h" #include "RealPartonState.fh" #include "RealParton.fh" #include "EffectiveParton.h" #include "ShadowParton.h" namespace DIPSY { using namespace ThePEG; /** * A dipole-dipole interaction used for book keeping. */ struct DipoleInteraction { /** * Enumerate the resons for an interaction not working. */ enum Status { UNKNOWN = -1, /**< Not yet checked. */ ACCEPTED = 0, /**< Interaction is OK */ PROPFAIL = 1, /**< Kinematics of incoming propagators failed. */ KINEFAIL = 2, /**< Kinematics of interaction failed. */ ORDERING = 3 /**< Ordering of interation failed. */ }; /** * Constructor taking two dipoles. */ DipoleInteraction(Dipole & dlin, Dipole & drin, const ImpactParameters & bin, int ordering); /** * Prepare an interactions to be checked for the first time. */ void prepare() const; /** * Check that the interaction can be performed. If \a mode >= 0 also * flag shadow partons on-shell. If \a mode > 0 also propagate * momenta to original partons. */ Status check(int mode) const; /** * Accept the interaction. */ void accept() const; /** * Reject this interaction. */ void reject() const; /** * The two dipoles. */ pair dips; /** * The two dipoles next to these. */ pair dnext; /** * The two dipoles previous to these. */ pair dprev; /** * A pointer to the impact parameter object. */ const ImpactParameters * b; /** * Which partons are actually interacting? */ pair ints; /** * Which partons are merely spectators */ pair spec; /** * Which partons are actually interacting? */ mutable pair sints; /** * The distance between the interacting partons. */ InvEnergy2 d2; /** * The interaction strength (times two for total xsec). */ double f2; /** * The unitarized interaction strength. */ double uf2; /** * The transverse momentum recoil associated with the interaction. */ mutable TransverseMomentum rec; /** * Set to true if the two partons which interacts has already received a recoil. */ mutable bool norec; /** * The transverse momentum scale associated with the interactions. */ mutable Energy kt; /** * The renormalized interaction probability initially the same as * uf2, but changed as other interactions are added to an event. */ mutable double prob; /** * The number of this interaction in the order of tried interactions. */ mutable int id; /** * Current status of this interaction. */ mutable Status status; /** * Ordering scheme for interactions */ int intOrdering; /** * Check if the given parton is ordered wrt. the given light-cone * momenta. */ bool disorder(bool doit, tcSPartonPtr p, Energy plus, Energy minus) const { return ( doit && ( p->plus() < plus || p->minus() > minus ) ); } bool disorder(bool doit, Energy plus, Energy minus, tcSPartonPtr p) const { return ( doit && ( plus < p->plus() || minus > p->minus() ) ); } /** * Check that the two scattered partons are ordered. */ bool disorder(bool doit) const { return disorder(doit, sints.first, sints.second->minus(), sints.second->plus()); } /** * Return true if the given scales are ascending of decanding. */ bool cending(Energy2 ptl, Energy2 ptm, Energy2 ptr) const { return ( ( ptl > ptm && ptm > ptr ) || ( ptl < ptm && ptm < ptr )); } /** * Return true if the interaction fails any of the ordering requirements. */ bool orderfail(const ShadowParton::Propagator & ppl, const ShadowParton::Propagator & ppr) const; void checkShadowMomentum(const LorentzMomentum & pin = LorentzMomentum()) const; /** * Print out sum of on-shell momenta. */ void debug() const; /** Struct for ordering by dipoles. */ struct DipoleOrder { /** Main operator */ bool operator()(const DipoleInteraction & i1, const DipoleInteraction & i2) const { return i1.dips.first < i2.dips.first || ( i1.dips.first == i2.dips.first && i1.dips.second < i2.dips.second ); } }; /** Struct for ordering by dipoles. */ struct StrengthOrder { /** Main operator */ bool operator()(const DipoleInteraction & i1, const DipoleInteraction & i2) const { return i1.f2 > i2.f2; } }; /** * A settype used to store an ordered list of potential interactions * between dipoles in colliding dipole systems. Ordered in * decreasing interaction strength. */ typedef multiset List; /** Struct for ordering by scale. */ struct PTOrder { /** Main operator */ bool operator()(const List::const_iterator & i1, const List::const_iterator & i2) const { return i1->kt > i2->kt; } }; /** * A settype used to store an ordered list of potential interactions * between dipoles in colliding dipole systems. Ordered in * decreasing interaction strength. */ typedef multiset PTSet; /** * A settype used to store a list of potential interactions * between dipoles in colliding dipole systems. */ typedef set DipList; /** * Check which orderings fail the most (for debugging). */ static vector ofail, o1fail; void fail(int i ) const; /** * Exception class to signal bad kinematics. */ struct InteractionKinematicException: public Exception {}; }; /** * DipoleXSec is the base class of all objects capable of calculating * the scattering probability for two colliding dipoles. The main * virtual functions to be overridden are called fij, sumf and flist. * * @see \ref DipoleXSecInterfaces "The interfaces" * defined for DipoleXSec. */ class DipoleXSec: public HandlerBase { public: /** * A maptype used to store an ordered list of scattering * probabilities (the bare one paired with the unitarized one) * between dipoles in colliding dipole systems. */ typedef multimap, pair, std::greater< pair > > FList; /** * Interaction pT of the four partons involved in an interaction. Default order is * the first and second parton in colour order from the left state first, * then the first and second parton from right state. */ typedef pair< pair, pair > InteractionRecoil; /** * A vector of dipole pairs represented as iterators into an FList. */ typedef vector DipolePairVector; /** * An ordered map of dipole pairs represented as iterators into an * FList. */ typedef multimap > DipolePairMap; /** * A interaction of RealPartons, with all needed information about the interaction. */ struct RealInteraction { RealPartonStatePtr lrs, rrs; DipolePtr d1, d2; RealPartonPtr p11, p12, p21, p22; InvEnergy range11, range12, range21, range22; Energy effectivePlus11, effectivePlus12, effectivePlus21, effectivePlus22; Energy effectiveMinus11, effectiveMinus12, effectiveMinus21, effectiveMinus22; bool max11, max12, max21, max22; double P11, P12, P21, P22; }; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline DipoleXSec() : theRMax(0.0*InvGeV), theInteraction(0), sinFunction(0), usePartonicInteraction(false), theIntOrdering(0), theRecoilReduction(0), thePTScale(0.0), kt0(5.0*GeV), ktpow(0.0), checkOffShell(true) {} /** * The copy constructor. */ inline DipoleXSec(const DipoleXSec & x) : HandlerBase(x), theRMax(x.theRMax), theInteraction(x.theInteraction), sinFunction(x.sinFunction), usePartonicInteraction(x.usePartonicInteraction), theIntOrdering(x.theIntOrdering),theRecoilReduction(x.theRecoilReduction), thePTScale(x.thePTScale), kt0(x.kt0), ktpow(x.ktpow), checkOffShell(x.checkOffShell) {} /** * The destructor. */ virtual ~DipoleXSec(); //@} public: /** @name Virtual functions to be overridden by subclasses. */ //@{ /** * Calculate the scattering probability for the two given dipoles * using the given ImpactParameters. */ virtual double fij(const pair, const pair, const ImpactParameters & b, bool veto = true) const; /** * Calculate the scattering probability for the two given dipoles * using the given ImpactParameters. */ virtual double fij(const Dipole &, const Dipole &, const ImpactParameters & b, bool veto = true) const; /** * Calculate the scattering probability for the two given dipoles * using the given ImpactParameters. */ virtual DipoleInteraction fij(const ImpactParameters & b, Dipole &, Dipole &, bool veto = true) const; /** * Return false if an interaction would be kinematically forbidden. */ virtual bool kinematicsVeto(const pair, const pair, const ImpactParameters & b) const; /** * Return false if an interaction would be kinematically forbidden. */ virtual bool kinematicsVeto(const Dipole &, const Dipole &, const ImpactParameters & b, const pair & ints) const; /** * Return false if an interaction would be kinematically forbidden. */ virtual bool kinematicsVeto(const DipoleInteraction &) const; /** * Calculate the total scattering probability for the two given * dipole systems using the given ImpactParameters. */ virtual double sumf(const DipoleState &, const DipoleState &, const ImpactParameters &) const; /** * Calculate the total scattering probability for the two given * dipole systems using the given ImpactParameters. */ virtual double sumf(const ImpactParameters &, const DipoleState &, const DipoleState &) const; /** * Calculate the total scattering probability all dipole pairs * the two given dipole systems using the given ImpactParameters. */ virtual FList flist(const DipoleState &, const DipoleState &, const ImpactParameters &) const; /** * Calculate the total scattering probability all dipole pairs * the two given dipole systems using the given ImpactParameters. */ virtual DipoleInteraction::List flist(const ImpactParameters &, const DipoleState &, const DipoleState &) const; /** * Return a unitarized scattering probability, given the * ununitarized one. */ virtual double unitarize(double f) const; /** * Returns the recoils the interaction would like to give the 4 involved partons. * Assumes the states are not yet rotated. */ virtual InteractionRecoil recoil(const pair left, const pair right, const ImpactParameters & b, pair, pair > doesInt, pair ints0) const; /** * Returns the recoils the interaction would like to give the 4 involved partons. * Assumes the states are not yet rotated. */ virtual InteractionRecoil recoil(const pair left, const pair right, const ImpactParameters & b, pair, pair > doesInt = make_pair(make_pair(true, true), make_pair(true, true))) const; /** * Returns the recoils the interaction would like to give the 4 involved partons. * Assumes the states are not yet rotated. */ virtual InteractionRecoil recoil(const DipoleInteraction &) const; /** * Does the transverse recoil on the four partons. */ void doTransverseRecoils(RealInteraction i, InteractionRecoil recs) const; /** * creates and initialises a RealInteraction with realpartons, ranges and max. */ virtual RealInteraction initialiseInteraction(const pair inter, RealPartonStatePtr lrs, RealPartonStatePtr rrs, pair, pair > doesInt, const ImpactParameters & b) const; /** * creates and initialises a RealInteraction with realpartons, ranges and max. */ virtual RealInteraction initialiseInteraction(const DipoleInteraction & di, RealPartonStatePtr lrs, RealPartonStatePtr rrs) const; /** * Decides which of the four partons actually interact. */ virtual pair, pair > doesInt(const pair left, const pair right, const ImpactParameters & b) const; /** * Selects the two partons (out of the four) that are used in theInteraction == 0. */ virtual pair int0Partons(tcPartonPtr p11, tcPartonPtr p12, tcPartonPtr p21, tcPartonPtr p22, const ImpactParameters & b) const; /** * calculates and sets the effective plus and minus of the partons of the interaction **/ virtual void updateMomenta(RealInteraction * interaction) const; // /** // * undoes the last recoil for each of the four partons. // */ // virtual void undoLastRecoil(RealPartonPtr p11, RealPartonPtr p12, // RealPartonPtr p21, RealPartonPtr p22) const; /** * Does the transverse recoil on the real partons with the pT supplied in recs. * Does the p+ alt. p- transfer of neededPlus nad neededMinus to put the * other state on shell. If not consistent, return false. * Also updates p_mu for the 4 effective partons. Assumes all are rightmoving. */ virtual bool doInteraction(InteractionRecoil recs, const FList::const_iterator inter, RealPartonStatePtr lrs, RealPartonStatePtr rrs, pair, pair > doesInt, const ImpactParameters & b) const; /** * Does the transverse recoil on the real partons with the pT supplied in recs. * Does the p+ alt. p- transfer of neededPlus nad neededMinus to put the * other state on shell. If not consistent, return false. * Also updates p_mu for the 4 effective partons. Assumes all are rightmoving. */ virtual bool doInteraction(InteractionRecoil recs, const DipoleInteraction::List::const_iterator inter, RealPartonStatePtr lrs, RealPartonStatePtr rrs, pair, pair > doesInt) const; /** * reconnects the colour flow in an interaction, taking care that rescatterings are * treated properly. */ bool reconnect(const DipoleInteraction &di) const { return reconnect(di.dips.first, di.dips.second); } /** * reconnects the colour flow in an interaction, taking care that rescatterings are * treated properly. */ virtual bool reconnect(tDipolePtr d1, tDipolePtr d2) const; /** * checks the interactions in the two real states, ans picks out the ones that * did non-colour singlet exchanges. */ virtual vector > getColourExchanges(tRealPartonStatePtr lrs, tRealPartonStatePtr rrs) const; /** * Mark two dipoles as having interacted with eachother. */ virtual void interact(Dipole & d1, Dipole & d2) const; //@} /** * Return the value of the sine-interaction strength. */ double fSinFn(const Parton::Point & rho1, const Parton::Point & rho2, const TransverseMomentum & pt) const; /** * Return the interaction **/ inline int interaction() const { return theInteraction; } /** * Flag determining if only one parton in each dipole is considered * interacting or both. */ inline bool partonicInteraction() const { return usePartonicInteraction; } /** * The confinement scale. */ InvEnergy rMax() const; /** * The scale relating distances and transverse momenta. */ double pTScale() const; /** * for debugging */ mutable int Nfij; mutable int nIAccepted; mutable int nIBelowCut; mutable int nIPropFail; mutable int nIKineFail; mutable int nIOrdering; mutable int NScalVeto; mutable int NBVeto; mutable double scalVeto; mutable double bVeto; private: /** * return the fractions of p+ and p- to be transfered to put everything on shell. */ pair findBoosts(Energy intPlus1, Energy intPlus2, Energy intMinus1, Energy intMinus2, Energy evoPlus2, Energy evoMinus1) const; /** * return the fractions of p+ and p- to be transfered to put everything on shell. **/ pair findBoosts(RealInteraction i) const; /** * boosts the interacting particles with the scales provided **/ void doBoosts(RealInteraction i, pair boosts) const; /** * boosts the affective partons with the scale x. */ void doBoost(tRealPartonPtr p1, InvEnergy range1, tRealPartonPtr p2, InvEnergy range2, double x) const; /** * reduce the recoil until the interacting partons are ordered in rapidity. **/ void reduceRecoil(RealInteraction RI, InteractionRecoil recs) const; /** * checks if the interaction is ordered or not **/ bool ordered(RealInteraction i, InteractionRecoil recs, const ImpactParameters & b) const; /** * sets all particles in the backwards cone on shell **/ void setOnShell(RealInteraction i) 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); //@} /** * 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. */ inline virtual IBPtr clone() const { return new_ptr(*this); } /** 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 { return new_ptr(*this); } //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). protected: /** * Exception class to signal bad kinematics. */ struct InteractionKinematicException: public Exception {}; private: /** * The confinement scale. */ InvEnergy theRMax; /** * Flag determining which interaction to be used. */ int theInteraction; /** * Flag determining which approximation to the sine-functions in the * interaction strength to use. */ int sinFunction; /** * Flag determining if only one parton in each dipole is considered * interacting or both. */ bool usePartonicInteraction; /** * What kind of kinematical ordering is requeired in the interaction. */ int theIntOrdering; /** * What to do with large recoils, if anything. */ int theRecoilReduction; /** * The scale relating distances and transverse momenta. If zero, the * corresponding value of the current Emitter is used. */ double thePTScale; /** * Artificially suppress large transverse momenta in the interaction * by a factor kt0/(kt0 + kt)^ktpow. */ Energy kt0; double ktpow; /** * Check for off-shell incoming particles. */ bool checkOffShell; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - DipoleXSec & operator=(const DipoleXSec &); + DipoleXSec & operator=(const DipoleXSec &) = delete; }; } #endif /* DIPSY_DipoleXSec_H */ diff --git a/DIPSY/EffectiveParton.h b/DIPSY/EffectiveParton.h --- a/DIPSY/EffectiveParton.h +++ b/DIPSY/EffectiveParton.h @@ -1,288 +1,288 @@ // -*- C++ -*- #ifndef DIPSY_EffectiveParton_H #define DIPSY_EffectiveParton_H // // This is the declaration of the EffectiveParton class. // #include "Ariadne/DIPSY/Parton.h" #include "Ariadne/DIPSY/EffectiveParton.fh" namespace DIPSY { using namespace ThePEG; /** * An effective parton is a colour chain of partons that are close * enough to each other so that the neighbouring dipole can't really * resolve them. */ class EffectiveParton: public Parton { public: /** * Caching info for Partons. */ struct RangeInfo { /** * The range at which the number of partons included changes. */ InvEnergy2 range; /** * The effective transverse momentum at this range; */ TransverseMomentum pT; /** * The effective positive light-cone momentum at this range. */ Energy plus; /** * The effective negative light-cone momentum at this range. */ Energy minus; /** * The effective rapidity for this range. */ double y; /** * Included partons. */ vector partons; /** * Included dipoles. */ vector dipoles; /** * The external connecting dipoles. */ pair dipair; }; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ EffectiveParton(); /** * Constructs an effective parton for \a p. */ EffectiveParton(Parton & p); /** * Static creation method that also performs * initialization. Constructs an effective parton around p, * including other partons within range. */ static EffectivePartonPtr create(Parton & p, InvEnergy range); /** * The destructor. */ virtual ~EffectiveParton(); //@} protected: /** * Setup the and access cache of range information. */ void setupCache(InvEnergy maxrange); void uncache(); void recache(); /** @name The virtual functions to be overridden in sub-classes. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual Ariadne5::ClonePtr clone() const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} public: /** * Returns the internal dipoles in the nonresolved chain. */ inline const vector & internalDipoles() { return cache.empty()? theInternalDipoles: cache[currange].dipoles; } /** * Returns the internal dipoles in the nonresolved chain. */ inline tPartonPtr originalParton() { return theOriginalParton; } /** * recalculates the partons and dipoles within the range, and updates * theInternalDipoles and momenta accordingly. */ void printData(); /** * recalculates the partons and dipoles within the range, and updates * theInternalDipoles and momenta accordingly. */ void setRange( InvEnergy range ); /** * returns true if any of the internal dipoles, or their neighbours, * has emitted. */ bool changed(); /** * Finds and returns the partons belonging to the internal dipoles. */ const set & internalPartons() const { return theInternalPartons; }; /** * Finds and returns the partons belonging to the internal dipoles. */ const vector & cachedPartons() const { return cache.back().partons; }; /** * Check if a recoil of pT and plus will push any of the internal partons above * rapidity ymax. */ bool recoilsOverYMax(TransverseMomentum pT, Energy plus, double ymax) const; /** * recoils the effective parton from providing an emission with * pT transverse momentum, and plus p+. Goes with the pT definition * where every recoil in every emission is remembered. */ void recoil( TransverseMomentum pT, Energy plus ); /** * recoils the effective parton from providing an emission with * plus p+. pT is decided from each partons two dipole neighbours. * Goes with the pT determined only from the two current * colour neighbours, without history dependence. */ void newRecoil( Energy plus ); protected: /** * recursively add partons within range. */ void addPartons( InvEnergy range ); /** * recursively add partons within range. USes the "Relatives" mode of adding partons. */ void addRelatives( InvEnergy range, tPartonPtr p ); /** * Adds p to the internal partons, and updates the momentum of the effective parton. */ void merge(tPartonPtr p); /** * checks that the sum ofh the partons momenta is the momenta of the effective parton. */ bool checkSums() 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); //@} /** * 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: /** * Exception class used when effective parton gets (almost) zero pt) */ struct EffectivePartonPTException: public Exception {}; private: /** * The original parton. */ PartonPtr theOriginalParton; /** * The internal dipoles in the nonresolved chain. */ vector theInternalDipoles; /** * The internal partons in the nonresolved effective parton. */ set theInternalPartons; /** * Cache informations about different ranges. */ vector cache; /** * The current range */ int currange; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - EffectiveParton & operator=(const EffectiveParton &); + EffectiveParton & operator=(const EffectiveParton &) = delete; }; } #endif /* DIPSY_EffectiveParton_H */ diff --git a/DIPSY/ElasticXSecAnalysis.h b/DIPSY/ElasticXSecAnalysis.h --- a/DIPSY/ElasticXSecAnalysis.h +++ b/DIPSY/ElasticXSecAnalysis.h @@ -1,209 +1,209 @@ // -*- C++ -*- #ifndef DIPSY_ElasticXSecAnalysis_H #define DIPSY_ElasticXSecAnalysis_H // // This is the declaration of the ElasticXSecAnalysis class. // #include "DipoleAnalysisHandler.h" #include "ThePEG/Analysis/FactoryBase.h" #include "ThePEG/Analysis/LWH/AnalysisFactory.h" namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the ElasticXSecAnalysis class. * * @see \ref ElasticXSecAnalysisInterfaces "The interfaces" * defined for ElasticXSecAnalysis. */ class ElasticXSecAnalysis: public DIPSY::DipoleAnalysisHandler { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ ElasticXSecAnalysis(); /** * The destructor. */ virtual ~ElasticXSecAnalysis(); //@} public: /** @name Standard virtual functions inherited from the classes. */ //@{ /** * Initialize the analysis object. */ virtual void initialize(); /** * Analyze a given collision. Given left- and right-moving dipole * states, \a dl and \a dr, an ImpactParameters object, \a b, a * cross section object, \a xsec, and the total summed dipole-dipole * scattering probabilities, \a fsum, and the total \a weight * associated with the generated states. */ virtual void analyze(const DipoleState & dl, const DipoleState & dr, const ImpactParameters & b, const DipoleXSec & xsec, double fsum, CrossSection weight); /** * Finalize the analysis, (compute statistics etc.). \a neve is the * number of times analyze() has been called since last * initialize(). */ virtual void finalize(long neve); //@} 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; //@} private: /** * Number of bins in impact parameter. */ int nb; /** * Size of interval in impact parameter. */ InvEnergy db; /** * The weighted sum of the interaction probability, binned in b. */ vector sumTw; /** * The weighted sum of the square of * the interaction probability, binned in b. */ vector sumT2w; /** * The weighted sum of the 4:th power of * the interaction probability, binned in b. */ vector sumT4w; /** * The weighted sum of the elastic interaction amplitude, binned in b. */ vector sumElAw; /** * The weighted sum of the square of * the elastic interaction amplitude, binned in b. */ vector sumElA2w; /** * The sum of the real weights, binned in b. */ vector sumw; /** * The sum of the real elastic weights, binned in b. */ vector sumElw; /** * The sum of the number of collisions seen so far. */ vector sumn; /** * Number of bins in q. */ int nq; /** * Size of interval in q. */ Energy dq; /** * The weighted sum of the differential elastic amplitude in q. */ vector sumDEw; /** * The weighted sum of the square of the differential elastic amplitude in q. */ vector sumDE2w; /** * The differential elastic cross section in q. */ FactoryBase::tH1DPtr dSigmadq; // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). map > bmap; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ElasticXSecAnalysis & operator=(const ElasticXSecAnalysis &); + ElasticXSecAnalysis & operator=(const ElasticXSecAnalysis &) = delete; }; } #endif /* DIPSY_ElasticXSecAnalysis_H */ diff --git a/DIPSY/Emitter.h b/DIPSY/Emitter.h --- a/DIPSY/Emitter.h +++ b/DIPSY/Emitter.h @@ -1,442 +1,442 @@ // -*- C++ -*- #ifndef DIPSY_Emitter_H #define DIPSY_Emitter_H // // This is the declaration of the Emitter class. // #define THEPEG_NEW_CLASS_DESCRIPTION #include "ThePEG/Handlers/HandlerBase.h" #include "Emitter.fh" #include "Dipole.fh" #include "Parton.h" namespace DIPSY { using namespace ThePEG; /** * The Emitter class is responsible for generating and performing * emissions from dipoles. This base class does the standard thing. Any * non-standard thing must be implemented in a sub-class overriding * the generate() and/or emit() functions. * * @see \ref EmitterInterfaces "The interfaces" * defined for Emitter. */ class Emitter: public HandlerBase { public: /** Convenietn typedef. */ typedef Parton::Point Point; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline Emitter() : testingPS(false), fixY(0.0), thePSInflation(1.0), thePMinusOrdering(1.0), thePTScale(1.0), theRScale(1.0*InvGeV), theRMax(0.0*InvGeV), theBothOrderedEvo(true), theBothOrderedInt(true), theBothOrderedFS(true), theRangeMode(0),theMinusOrderingMode(0), splitF(0), thestMode(false), thePlusInflation(1.0), sizeFactor(2.0) {} /** * The destructor. */ virtual ~Emitter(); //@} public: /** @name Virtual functions which may be overridden by sub-classes. */ //@{ /** * Return the running coupling for the given size (scale). /CF */ double alphaSr(InvEnergy r) const; /** * Return the running coupling for the given size (scale). /CF */ double alphaS(Energy mu) const; /** * if pT is 1/r or 2/r. */ inline double pTScale() const { return thePTScale; } /** * Alpha bar = alphas*Nc/pi /CF */ inline double alphaBar(Energy mu) const { return alphaS(mu)*3.0/M_PI; } /** * Alpha bar = alphas*Nc/pi /CF */ inline double alphaBarr(InvEnergy r) const { return alphaSr(r)*3.0/M_PI; } /** * Sets the shape of the overestimate in the genreation. * The cross section does not (should not) depend on rScale. /CF */ inline void rScale(InvEnergy rScale) { theRScale = rScale; } /** * Get bothordered. */ inline bool bothOrderedEvo() const { return theBothOrderedEvo; }; inline bool bothOrderedInt() const { return theBothOrderedInt; }; inline bool bothOrderedFS() const { return theBothOrderedFS; }; /** * Set PSInfaltion */ inline void PSInflation(double PSInflation) { thePSInflation = PSInflation; } /** * Get PSInfaltion */ inline double PSInflation() const { return thePSInflation; } /** * Set PMinusOrdering */ inline void PMinusOrdering(double x) { thePMinusOrdering = x; } /** * Get PMinusOrdering */ inline double PMinusOrdering() const { return thePMinusOrdering; } /** * get the rangeMode **/ inline int rangeMode() const { return theRangeMode; } /** * get the minusOrderingMode **/ inline int minusOrderingMode() const { return theMinusOrderingMode; } /** * The confinement scale. */ InvEnergy rMax() const; /** * The resolution size of an emitting dipole or its EffectiveParton * range. */ InvEnergy2 size2(InvEnergy2 r2) const { return r2/sqr(sizeFactor); } InvEnergy size(InvEnergy r) const { return r/sizeFactor; } InvEnergy2 size2(const Dipole & d) const; InvEnergy size(const Dipole & d) const; /** * Generate a possible emission or a swing from a given dipole in the * given rapidity interval [\a miny,\a maxy]. */ virtual void generate(Dipole & dipole, double miny, double maxy) const; /** * Generate a possible emission or a swing from a given dipole using * shadows in the given rapidity interval [\a miny,\a maxy]. */ virtual void generateWithShadows(Dipole & dipole, double miny, double maxy) const; virtual void generateWithShadowsAgain(Dipole & dipole, double miny, double maxy) const; virtual void generateWithShadowsYetAgain(Dipole & dipole, double miny, double maxy) const; /** * Perform the emission previously generated for the given \a * dipole. If no emission has been generated a runtime_error is * thrown. */ virtual void emit(Dipole & dipole) const; /** * Perform the emission previously generated for the given \a * dipole using shadows. If no emission has been generated a runtime_error is * thrown. */ virtual void emitWithShadows(Dipole & dipole) const; //@} protected: /** * Internal function. */ virtual InvEnergy rCut(DipolePtr dip, double y) const; /** * Internal function. */ virtual bool OEVeto(DipolePtr dip, double y0, Point p) const; /** * Internal function. */ virtual InvEnergy rCut(DipolePtr dip, tSPartonPtr sp1, tSPartonPtr sp2, double y) const; /** * Internal function. */ virtual bool OEVeto(DipolePtr dip, tSPartonPtr sp1, tSPartonPtr sp2, double y0, Point p) const; /** * Internal function. */ virtual bool YVeto(double y, DipolePtr dip, double Coe, double rateOE) const; /** * Internal function. */ virtual bool YVeto(double y, DipolePtr dip, tSPartonPtr sp1, tSPartonPtr sp2, double Coe, double rateOE) const; /** * Internal function. */ virtual double generateY(DipolePtr dip, double ymin, double ymax) const; /** * Internal function. */ virtual double generateY(DipolePtr dip, tSPartonPtr sp1, tSPartonPtr sp2, double ymin, double ymax) const; /** * Internal function. */ virtual Point generateXT(DipolePtr dip, double y0) const; /** * Internal function. */ virtual Point generateXT(DipolePtr dip, tSPartonPtr sp1, tSPartonPtr sp2, double y0) const; public: /** * Debugging and testing */ mutable bool testingPS; mutable double fixY; 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. */ inline virtual IBPtr clone() const { return new_ptr(*this); } /** 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 { return new_ptr(*this); } //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). protected: /** * How much P+- ordering should be required. 1 is nomral ordering * high values are no ordering, low number are strong ordering. */ double thePSInflation; /** * Controls the strength of the p- ordering in the evolution. */ double thePMinusOrdering; /** * if pt is 1/r or 2/r. */ double thePTScale; /** * the scale in the distribution of transverse r. /CF */ InvEnergy theRScale; /** * The confinement scale. */ InvEnergy theRMax; /** * If the plus/minus ordering should be full strenght * for both parents in teh cascade, interaction and final state. */ bool theBothOrderedEvo; bool theBothOrderedInt; bool theBothOrderedFS; /** * How the range is determined. **/ int theRangeMode; /** * How the minus ordering is made in the cascade. **/ int theMinusOrderingMode; /** * Determines which splitting function to use. */ int splitF; /** * If test-modification to evolution should be on. /CF */ bool thestMode; /** * Allow extra room for plus momenta in generation. */ double thePlusInflation; /** * The factor dividing the emitting dipole size when determining the * resolution of previous emissions or EffectiveParton range. */ double sizeFactor; public: /** * Exception class. */ struct EmitterException: public Exception {}; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - Emitter & operator=(const Emitter &); + Emitter & operator=(const Emitter &) = delete; }; } #ifndef THEPEG_NEW_CLASS_DESCRIPTION #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of Emitter. */ template <> struct BaseClassTrait { /** Typedef of the first base class of Emitter. */ typedef HandlerBase NthBase; }; /** This template specialization informs ThePEG about the name of * the Emitter class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "DIPSY::Emitter"; } /** * The name of a file containing the dynamic library where the class * Emitter is implemented. It may also include several, space-separated, * libraries if the class Emitter depends on other classes (base classes * excepted). In this case the listed libraries will be dynamically * linked in the order they are specified. */ static string library() { return "libAriadne5.so libDIPSY.so"; } }; /** @endcond */ } #endif #endif /* DIPSY_Emitter_H */ diff --git a/DIPSY/EventFiller.h b/DIPSY/EventFiller.h --- a/DIPSY/EventFiller.h +++ b/DIPSY/EventFiller.h @@ -1,594 +1,594 @@ // -*- C++ -*- #ifndef DIPSY_EventFiller_H #define DIPSY_EventFiller_H // // This is the declaration of the EventFiller class. // #include "EventFiller.fh" #include "ThePEG/Handlers/HandlerBase.h" #include "DipoleEventHandler.fh" #include "RealPartonState.fh" #include "RealParton.fh" #include "DipoleState.h" #include "ImpactParameters.h" #include "DipoleXSec.h" #include "DipoleAbsorber.h" #include "ThePEG/Utilities/Current.h" #include "ThePEG/Analysis/FactoryBase.h" #ifndef LWH_AIAnalysisFactory_H #ifndef LWH #define LWH ThePEGLWH #endif #include "ThePEG/Analysis/LWH/AnalysisFactory.h" #endif namespace DIPSY { using namespace ThePEG; /** * The EventFiller class is able to produce an initial * ThePEG::Collision from two colliding DipoleStates. * * @see \ref EventFillerInterfaces "The interfaces" * defined for EventFiller. */ class EventFiller: public HandlerBase { public: /** * Copy FList typedef from DipoleXSec. */ typedef DipoleXSec::FList FList; /** * Copy InteractionList typedef from DipoleXSec. */ typedef DipoleInteraction::List InteractionList; /** * Copy InteractionList typedef from DipoleXSec. */ typedef DipoleInteraction::PTSet InteractionPTSet; /** * A String is simply a vector of colour-connected partons. */ typedef DipoleState::String String; /** * A vector of dipole pairs represented as iterators into an FList. */ typedef DipoleXSec::DipolePairVector DipolePairVector; /** * An ordered map of dipole pairs represented as iterators into an * FList. */ typedef DipoleXSec::DipolePairMap DipolePairMap; /** * Simple vector of interactions. */ typedef vector InteractionVector; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ EventFiller(); /** * The destructor. */ virtual ~EventFiller(); //@} public: /** @name Virtual functions which can be overridden in subclasses. */ //@{ /** * Fill the current collision object in the given DipoleEventHandler * with the final state gluons produced when dipole states \a dl and * \a dr collides with impact parameters \a b. * @return the total interaction probability. */ virtual double fill(Step & step, DipoleEventHandler & eh, tPPair inc, DipoleState & dl, DipoleState & dr, const ImpactParameters & b) const; /** * Fill the current collision object in the given DipoleEventHandler * with the final state gluons produced when dipole states \a dl and * \a dr collides with impact parameters \a b. * @return the total interaction probability. */ virtual double fill(Step & step, DipoleEventHandler & eh, tPPair inc, const ImpactParameters & b, DipoleState & dl, DipoleState & dr) const; /** * Fill the current collision object in the given DipoleEventHandler * with the final state gluons produced when dipole states \a dl and * \a dr collides with impact parameters \a b. * @return the total interaction probability. */ virtual double fillWithShadows(Step & step, DipoleEventHandler & eh, tPPair inc, const ImpactParameters & b, DipoleState & dl, DipoleState & dr) const; /** * Select which dipole pairs should interact, and return them in the * order in which they should be processed. */ virtual pair selectInteractions(const FList & fl, const ImpactParameters & b, const DipoleXSec & xSec) const; /** * Select which dipole pairs should interact, and return them in the * order in which they should be processed. */ virtual pair selectInteractions(const InteractionList & intl, const DipoleXSec & xSec) const; /** * Select which dipole pairs should interact, and return them in the * order in which they should be processed. (shadow parton version) */ virtual InteractionVector selectShadowInteractions(const InteractionList & intl, const DipoleXSec & xSec) const; virtual InteractionVector selectShadowInteractions2(const InteractionList & intl, const DipoleXSec & xSec) const; /** * Tries to do the interaction between the real states lrs and rrs with the two dipoles * pointed to by inter, assuming that the interactions in inters already has been tested * and accepted. States collide at impact paramter b and using the recoils in xSec. */ bool addInteraction(FList::const_iterator inter, RealPartonStatePtr lrs, RealPartonStatePtr rrs, DipolePairVector & inters, const ImpactParameters & b, const DipoleXSec & xSec) const ; /** * Tries to do the interaction between the real states lrs and rrs with the two dipoles * pointed to by inter, assuming that the interactions in inters already has been tested * and accepted. States collide at impact paramter b and using the recoils in xSec. */ bool addInteraction(InteractionList::const_iterator inter, RealPartonStatePtr lrs, RealPartonStatePtr rrs, const TransverseMomentum & recoil, InteractionVector & inters, const DipoleXSec & xSec) const ; /** * Go through all previously accepted interactions and check that * they can still be performed. If \a mode > 0, this is the last check * and partons are set on-shell. */ bool recheckInteractions(const InteractionVector & interactions, int mode) const; /** * Extract all strings after according to the given interactions. */ virtual vector extractStrings(DipoleState & dl, DipoleState & dr, pair, const ImpactParameters & b) const; /** * Extract all strings after according to the given interactions. */ virtual vector extractShadowStrings(DipoleState & dl, DipoleState & dr, const InteractionVector & interactions, const ImpactParameters & b) const; /** * Fill the given Step with a SubProcess object using the given * incoming particles and list of strings. */ virtual bool fillStep(Step & step, tPPair incoming, const vector & strings) const; /** * Fix up valens partons if they were not of the correct flavour or * if they should collapse into a hadron. */ // virtual void fixValence(Step & step, DipoleState & dl, DipoleState & dr) const; /** * get the recoil scheme. */ inline int recoilScheme() const { return theRecoilScheme; } /** * set the recoil scheme. */ inline void recoilScheme(int x) { theRecoilScheme = x; } /** * get the mode. */ inline int mode() const { return theMode; } /** * set the mode. */ inline void mode(int x) { theMode = x; } /** * get the singleMother. */ inline int singleMother() const { return theSingleMother; } /** * set the singleMother. */ inline void singleMother(int x) { theSingleMother = x; } /** * get the DGLAPinPT. */ inline int DGLAPinPT() const { return theDGLAPinPT; } /** * set the DGLAPinPT. */ inline void DGLAPinPT(int x) { theDGLAPinPT = x; } /** * get the ValenceChargeNormalisation **/ inline int valenceChargeNormalisation() const { return theValenceChargeNormalisation; } /** * The minimum squared invariant transverse momentum allowed for a * gluon in a string. */ Energy2 pT2Cut() const { return sqr(thePTCut); } /** * Return the squared invariant transverse momentum of gluon \a i2 * in a string given its colour-neighbours \a i1 and \a i3. */ static Energy2 invPT2(const String & str, int i1, int i2, int i3); /** * Remove a gluon \a i2 in a string shuffling its momenum to its * colour-neighbours \a i1 and \a i3. */ static bool removeGluon(const String & str, int i1, int i2, int i3); /** * get the effectiveWeights. */ inline int effectiveWeights() const { return theEffectiveWeights; } /** * get the FS swing time. */ inline double FSSwingTime() const { return theFSSwingTime; } /** * get the step size for the FS swing time. */ inline double FSSwingTimeStep() const { return theFSSwingTimeStep; } //@} public: /** * Get the object used to absorb non-interacting dipoles. */ inline DipoleAbsorberPtr absorber() const { return theAbsorber; } 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). protected: /** * The weight which will be used for the event being generated. */ mutable double currentWeight; mutable bool fail; /** * Debug/testing */ protected: mutable double nInt; mutable double nInt1; mutable double nTried; mutable double nEvents; mutable double nTestedInts; mutable double foundInt; mutable double failedEvo; mutable double failedRec; mutable double rescatter; mutable double overTenEvents; mutable double rejectedEvents; mutable double nLoops; mutable double nYes; mutable double nNo; mutable double avYInEvo; mutable double avYInInt; protected: /** @name Standard Interfaced functions. */ //@{ /** * Initialize this object after the setup phase before saving an * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ virtual void doinit(); /** * Initialize this object. Called in the run phase just before * a run begins. */ virtual void doinitrun(); /** * Is this where this should be declared?? :o */ virtual void dofinish(); private: protected: /** * balances p+/p- by moving the entire state in rapidity. Assumed to be * UNMIRRORED states, ie, plus and minus are flipped for the right state. **/ void fixBoost(RealPartonStatePtr lrs, RealPartonStatePtr rrs) const; /** * Checks through the final state and tries to fix the most blatant errors. * Specially tries to catch bad momenta that can cause crashes. **/ void dodgeErrors(DipoleStatePtr finalState) const; /** * Checks if the interacting partons in the current states have enough * p+- to set the other state on shell. */ bool controlRecoils(DipolePairVector & sel, RealPartonStatePtr rrs, RealPartonStatePtr lrs, const ImpactParameters & b, const DipoleXSec & xSec, pair, pair > doesInt) const; /** * Checks if the interacting partons in the current states have enough * p+- to set the other state on shell. */ bool controlRecoils(InteractionVector & sel, RealPartonStatePtr rrs, RealPartonStatePtr lrs, const DipoleXSec & xSec) const; /** * Removes the off shell partons and recouples colour flow. p_mu unchanged. */ void removeVirtuals(DipoleStatePtr state) const; /** * Removes the parton and recouples colour flow. p_mu unchanegd. */ void removeParton(tPartonPtr p) const; /** * find the pT scale through the dipolestates eventhandlers emitter object. */ double pTScale(DipoleState &) const; /** * Takes statistics on the number of participants * in a heavy ion collision. */ void countParticipants(const DipoleState & dl, const DipoleState & dr, const InvEnergy b) const; /** * The object used to absorb non-interacting dipoles. */ DipoleAbsorberPtr theAbsorber; /** * What scheme to use when doing recoils. */ int theRecoilScheme; /** * In what mode to create the real state. Fast vs consistent. */ int theMode; /** * If partons have one or two mothers. */ int theSingleMother; /** * If DGLAP supression is made in terms of pt rather than r. */ int theDGLAPinPT; /** * How to distribute recoil among the members of an effective parton. */ int theEffectiveWeights; /** * How long time (in GeV-1) the FS get's to do colour reconnections. */ double theFSSwingTime; /** * How large time steps (in GeV-1) used in the FS colour * reconnections. */ double theFSSwingTimeStep; /** * How the valence charge is handled. **/ int theValenceChargeNormalisation; /** * The minimum invariant transverse momentum allowed for a gluon in a string. */ Energy thePTCut; /** * Options for removing gluons with too small invariant transverse * momentum. */ int theSoftRemove; /** * Do not allow a dipole to interact more than once. */ bool onlyOnce; public: /** * Compatibility mode for debugging differences between FList and * InteractionList. */ int compat; /** * Emit histograms for debugging */ int debughistos; // *** TO REMOVE *** Temporary analysis mutable FactoryBase::tH1DPtr histptmax, histptmaxi, histptfi, histptf, histdd0, histddi, histdda, histddp, histddff, histddfp, histddfk, histddfo, histddra, histddrf, histddrp, histddrk, histddro, histdc0, histdcfp0, histdcfk0, histdcfo0, histdcfp, histdcfk, histdcfo, histdca, histf0, histfa, histff, histfp, histfk, histfo; mutable double sumwmaxpt; public: /** * Exception class for space-like gluon momenta. */ struct SpaceLikeGluons: public Exception {}; /** * Exception class for space-like gluon momenta. */ struct ConsistencyException: public Exception {}; /** * Exception class for failed gluon removal. */ struct RemoveGluonException: public Exception {}; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - EventFiller & operator=(const EventFiller &); + EventFiller & operator=(const EventFiller &) = delete; }; } #endif /* DIPSY_EventFiller_H */ diff --git a/DIPSY/FSAnalysis.h b/DIPSY/FSAnalysis.h --- a/DIPSY/FSAnalysis.h +++ b/DIPSY/FSAnalysis.h @@ -1,740 +1,740 @@ // -*- C++ -*- #ifndef DIPSY_FSAnalysis_H #define DIPSY_FSAnalysis_H // // This is the declaration of the FSAnalysis class. // #include "ThePEG/Handlers/AnalysisHandler.h" #include #include namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the FSAnalysis class. * * @see \ref FSAnalysisInterfaces "The interfaces" * defined for FSAnalysis. */ class FSAnalysis: public AnalysisHandler { public: /** * Internal class to define the rapidity ordering of particles */ struct POrder { /** The actual ordering function. */ bool operator()(tPPtr a, tPPtr b) const { double eta1 = a->eta(); if ( abs(a->eta()) > 1000.0 ) { if ( a->momentum().z() > ZERO ) eta1 = 10.0; else eta1 = -10.0; } double eta2 = b->eta(); if ( abs(b->eta()) > 1000.0 ) { if ( b->momentum().z() > ZERO ) eta2 = 10.0; else eta2 = -10.0; } return eta1 < eta2; } }; /** * A rapidity-ordered set of particles. */ typedef set PSet; /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ FSAnalysis(); /** * The destructor. */ virtual ~FSAnalysis(); //@} public: /** @name Virtual functions required by the AnalysisHandler class. */ //@{ /** * Analyze a given Event. Note that a fully generated event * may be presented several times, if it has been manipulated in * between. The default version of this function will call transform * to make a lorentz transformation of the whole event, then extract * all final state particles and call analyze(tPVector) of this * analysis object and those of all associated analysis objects. The * default version will not, however, do anything on events which * have not been fully generated, or have been manipulated in any * way. * @param event pointer to the Event to be analyzed. * @param ieve the event number. * @param loop the number of times this event has been presented. * If negative the event is now fully generated. * @param state a number different from zero if the event has been * manipulated in some way since it was last presented. */ virtual void analyze(tEventPtr event, long ieve, int loop, int state); /** * Transform the event to the desired Lorentz frame and return the * corresponding LorentzRotation. * @param event a pointer to the Event to be transformed. * @return the LorentzRotation used in the transformation. */ virtual LorentzRotation transform(tEventPtr event) const; /** * 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 */ virtual void analyze(const tPVector & particles); /** * Analyze the given particle. * @param particle pointer to the particle to be analyzed. */ virtual void analyze(tPPtr particle); //@} protected: /** * The definition of the reaction-plane eccentricity parameter. * PLB641 (2006) 260, Eq. 6. */ double reactionPlaneEccentricity(const vector partons); /** * The definition of the participant eccentricity parameter. * PLB641 (2006) 260, Eq. 2. */ double participantEccentricity(const vector partons); /** * The definition of the average overlap area. * PRC81, 024901 (2010), Eq. 11. */ Area averageOverlapArea(const vector partons); Area averageOverlapArea(vector < vector > gluons); /** * Analyses the transverse position of the t = 0 gluons. (v_2 pp paper) */ void v2GluonAnalyze(tEventPtr event); /** * Finds the eccentricities. (v_n AA paper) */ void eccentricities(tEventPtr event); /** * Reads the event from a file with the provided filename (full path to file). * Returns a vector of vectors, each subvector being the gluon information on the * format * particle_number, transverse_position_x(fm), transverse_position_y(fm), * transverse_momentum_x(GeV), transverse_momentum_y(GeV), * rapidity, colour_neighbour_number, anticolour_neighbour_number * */ vector < vector > extractEvent(string filename); /** * extracts information from an input file of the above format. */ pair extractB(string filename); double extractWeight(string filename); int extractNSpectators(string filename); /** * changes the weight in the file by a factor. */ void changeWeight(string filename, double factor); /** * extracts information from a line of the format of the file above. */ pair getB(char line[256]); double getWeight(char line[256]); int getNSpectators(char line[256]); /** * takes a char line from a file as above, and converts it to a vector of doubles. */ vector getValues(char line[256]); /** * Finds and returns the centre of gravity. */ pair findCoG(vector < vector > gluons); /** * Finds and returns the eccentricity for moment n for the provided * participants and centre of gravity. * the first version use , the second . * The third weights gluons according to max(1,ln(p_T)+1) in the averages. * the last takes the two options as argument. */ double eccentricity(int n, vector < vector > gluons, pair CoG); double eccentricityN(int n, vector < vector > gluons, pair CoG); double eccentricityW(int n, vector < vector > gluons, pair CoG); double eccentricity(int n, vector < vector > gluons, pair CoG, bool always2, bool weighted); /** * Finds and returns the participant plane for moment n for the provided * participants and centre of gravity. * the first version use , the second . * The third weights gluons according to max(1,ln(p_T)+1) in the averages. * the last takes the two options as arguments. */ double participantAngle(int n, vector < vector > gluons, pair CoG); double participantAngleN(int n, vector < vector > gluons, pair CoG); double participantAngleW(int n, vector < vector > gluons, pair CoG); double participantAngle(int n, vector < vector > gluons, pair CoG, bool always2, bool weighted); /** * Saves the time=0 gluons to file. */ void saveGluonsToFile(tEventPtr event); /** * Saves the final state in bins of x,y,eta using the SPheRIO format. */ void exportToSPheRIO(tEventPtr event); /** * Counts and returns the number of spectating nucleons in a HI collision. */ int numberOfSpectators(tEventPtr event); 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: /** The multiplicity distribution for 1-2 interactions. */ tH1DPtr mult12; /** The reaction plane eccentricity. */ tH1DPtr epsRP; /** The participant eccentricity. */ tH1DPtr epsPart; /** The participant eccentricity squared. */ tH1DPtr epsPartOver20; /** The participant eccentricity to the fourth power. */ tH1DPtr epsPartOver40; /** The distribution of the weights. */ tH1DPtr weights; /** The number of gluons before final state shower. */ tH1DPtr ngbefore; /** The number of gluons after final state shower. */ tH1DPtr ngafter; /** The PT distribution in rapidity for DIPSY. */ tH1DPtr DIPSYPT; /** The PT distribution in rapidity for final state. */ tH1DPtr finalPT; /** The PT distribution in pseudorapidity for final state. */ tH1DPtr finalPTeta; /** The PT distribution in pseudorapidity for final state. */ tH1DPtr finalChargedPTeta; /** The ET distribution in pseudorapidity for final state. */ tH1DPtr finalETeta; /** The Nch distribution in pseudorapidity for final state. */ tH1DPtr finalNcheta; /** The distribution in excited mass dN/dln(M_X^2) for single diffraction. */ tH1DPtr lnMX2dist; tH1DPtr lnMX2distFrac; tH1DPtr lnMX2dist0; tH1DPtr lnMX2dist1; tH1DPtr lnMX2dist2; tH1DPtr lnMX2distWeights; tH1DPtr lnMX2dist0Weights; tH1DPtr lnMX2dist1Weights; tH1DPtr lnMX2dist2Weights; /** The Nch distribution in pseudorapidity for single diffraction. */ tH1DPtr SDNchdeta; /** The rapidity range versus MX and MX^2. */ tH1DPtr MXmaxY; tH1DPtr MXmaxYWeights; tH1DPtr MX2maxY; tH1DPtr MX2maxYWeights; /** UA4 SD analysis */ tH1DPtr UA4dndetaMX20; tH1DPtr UA4dndetaMX20Weights; tH1DPtr UA4dndetaMX60; tH1DPtr UA4dndetaMX60Weights; tH1DPtr UA4dndetaMX80; tH1DPtr UA4dndetaMX80Weights; tH1DPtr UA4dndetaMX100; tH1DPtr UA4dndetaMX100Weights; tH1DPtr UA4dndetaMX115; tH1DPtr UA4dndetaMX115Weights; tH1DPtr UA4dndetaMX140; tH1DPtr UA4dndetaMX140Weights; /** The Nch distribution in rapidity (in excited CoM frame) for single diffraction. * The MX is the average MX in GeV in the bins 3-8, 8-15 and 15-30 respectively. */ tH1DPtr SDNchdyMX38; tH1DPtr SDNchdyMX815; tH1DPtr SDNchdyMX1530; tH1DPtr SDNchdyMX38Weights; tH1DPtr SDNchdyMX815Weights; tH1DPtr SDNchdyMX1530Weights; /** The energy distribution in rapidity (in excited CoM frame) for single diffraction. * The MX is the average MX in GeV in the bins 3-8, 8-18 and 18-30 respectively. */ tH1DPtr SDdedetaMX38; tH1DPtr SDdedetaMX818; tH1DPtr SDdedetaMX1830; tH1DPtr SDdedetaMX38Weights; tH1DPtr SDdedetaMX818Weights; tH1DPtr SDdedetaMX1830Weights; /** The weigth distribution in diffractive events. */ tH1DPtr SDweights; tH1DPtr AU4SDweights; /** The number of charged particles above eta = -3 in SD. */ tH1DPtr SDavN; tH1DPtr SDavNWeights; tH1DPtr SDavN2; tH1DPtr SDavN2Weights; /** The PT distribution in rapidity for after FSR, but before hadronisation. */ tH1DPtr secondLastPT; double etaDiffAriadne; double NGlueAriadne; /** The PT distribution for charged particles in rapidity for final state. */ tH1DPtr chargedPT; /** The number of charged particles in rapidity for final state. */ tH1DPtr chargedN; /** The rap dist of charged particles in mid rapidity, following the ALICE paper. */ tH1DPtr chargedNALICE; /** total charge multiplicity, following the ALICE paper. */ tH1DPtr chargeMultALICE; /** counts the total weight of events with at least one charged track in |eta| < 1 */ double INEL; /** Et density in mid rapidity. */ Energy EtDensPHENIX; //keeps track on the total weight in some regions in impact parameter double totalWeight; double centralWeight; double midWeight; /** The distribution of maximum PT among the gluons before FSR. */ tH1DPtr maxPTBefore; /** The sum of pT after DIPSY. */ tH1DPtr DIPSYSumPT; /** The final sum of pT. */ tH1DPtr finalSumET; /** distribution of number of gluon participants */ tH1DPtr nParticipants; /** distribution of number of the eccentricity and area of the participating gluons */ tH1DPtr RPEcc; tH1DPtr PartEcc; /** area in femtometer^2 */ tH1DPtr OverlapArea; /** the average Part Ecc as function of the area in femtometers */ tH1DPtr EccArea; /** the average area as function of participants */ tH1DPtr AreaPart; /** the average of the square of the participant eccentricity */ tH1DPtr PE2; /** the average of the 4:th power of the participant beccentricity */ tH1DPtr PE4; /** The average of the square of eq 5 (event by event) binned in dNdeta */ tH1DPtr v2flow; /** The average of the 4:th power of eq 5 (event by event) binned in dNdeta */ tH1DPtr v4flow; /** A constant times the N participants, to simulate final state dNdeta */ tH1DPtr dNchFlow; /** v2 squared, using eq 5 for high density, normal final state for low density. */ tH1DPtr v2mix; /** the distribution of dN_ch/deta for mixed events. */ tH1DPtr dNchMix; /** v2 squared, using final state. */ tH1DPtr v2final; tH1DPtr v2finalWeights; /** 4 part corr. */ tH1DPtr v2quad; tH1DPtr v2quadWeights; /** v2 with a symmetric gap 0.5 to 2. */ tH1DPtr v2gap; /** the distribution of dN_ch/deta for final state. */ tH1DPtr dNchFinal; /** the ratio of events being dense enough for hydro, binned in multiplicity. */ tH1DPtr denseRatio; tH1DPtr denseRatioWeights; /** the average density dN/deta/Area, binned in multiplicity. */ tH1DPtr density; /** the density distribution for Nch multiplicities 10 to 20. */ tH1DPtr density1020; /** the density distribution for Nch multiplicities 40 to 60. */ tH1DPtr density4060; /** the density distribution for Nch multiplicities above 60. */ tH1DPtr density60plus; /** a testing 2D energy distribution. */ tH2DPtr test2D; tH2DPtr test2DWeights; /** things to measure average number of participants */ double averageNParticipants; //eps /** Number of gluons in mid rapidity as function of impact parameter B. */ tH1DPtr histNGlue; tH1DPtr histNGlueSqr; tH1DPtr histNGlueWeights; /** Number of spectators as function of impact parameter B. */ tH1DPtr histNSpectator; tH1DPtr histNSpectatorSqr; tH1DPtr histNSpectatorWeights; /** Number of gluons in mid rapidity as function of number of spectators. */ tH1DPtr histNGlueSpect; tH1DPtr histNGlueSpectSqr; tH1DPtr histNGlueSpectWeights; /** The area of the central gluons as function of B */ tH1DPtr histArea; tH1DPtr histAreaWeights; /** e1 and phi_1 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe1; tH1DPtr histe1Weights; tH1DPtr histe1N; tH1DPtr histe1NWeights; tH1DPtr histe1W; tH1DPtr histe1WWeights; tH1DPtr histphi1; tH1DPtr histphi1central; tH1DPtr histphi1mid; tH1DPtr histphi1N; tH1DPtr histphi1W; /** e2 and phi_2 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe2; tH1DPtr histe2Weights; tH1DPtr histe2N; tH1DPtr histe2NWeights; tH1DPtr histe2W; tH1DPtr histe2WWeights; tH1DPtr histphi2; tH1DPtr histphi2central; tH1DPtr histphi2mid; tH1DPtr histphi2N; tH1DPtr histphi2W; /** e3 and phi_3 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe3; tH1DPtr histe3Weights; tH1DPtr histe3N; tH1DPtr histe3NWeights; tH1DPtr histe3W; tH1DPtr histe3WWeights; tH1DPtr histphi3; tH1DPtr histphi3central; tH1DPtr histphi3mid; tH1DPtr histphi3N; tH1DPtr histphi3W; /** e4 and phi_4 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe4; tH1DPtr histe4Weights; tH1DPtr histe4N; tH1DPtr histe4NWeights; tH1DPtr histe4W; tH1DPtr histe4WWeights; tH1DPtr histphi4; tH1DPtr histphi4central; tH1DPtr histphi4mid; tH1DPtr histphi4N; tH1DPtr histphi4W; /** e5 and phi_5 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe5; tH1DPtr histe5Weights; tH1DPtr histe5N; tH1DPtr histe5NWeights; tH1DPtr histe5W; tH1DPtr histe5WWeights; tH1DPtr histphi5; tH1DPtr histphi5central; tH1DPtr histphi5mid; tH1DPtr histphi5N; tH1DPtr histphi5W; //with /** e1 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe1Sqrd; tH1DPtr histe1SqrdWeights; /** e2 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe2Sqrd; tH1DPtr histe2SqrdWeights; /** e3 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe3Sqrd; tH1DPtr histe3SqrdWeights; /** e4 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe4Sqrd; tH1DPtr histe4SqrdWeights; /** e5 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe5Sqrd; tH1DPtr histe5SqrdWeights; //with /** e1 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe1Quad; tH1DPtr histe1QuadWeights; /** e2 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe2Quad; tH1DPtr histe2QuadWeights; /** e3 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe3Quad; tH1DPtr histe3QuadWeights; /** e4 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe4Quad; tH1DPtr histe4QuadWeights; /** e5 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe5Quad; tH1DPtr histe5QuadWeights; //touched /** e2 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe2Touched; tH1DPtr histe2TouchedWeights; /** e3 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe3Touched; tH1DPtr histe3TouchedWeights; /** e4 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe4Touched; tH1DPtr histe4TouchedWeights; /** e5 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe5Touched; tH1DPtr histe5TouchedWeights; //eta in (-3,-1) /** e1 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe1m3tom1; tH1DPtr histe1m3tom1Weights; /** e2 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe2m3tom1; tH1DPtr histe2m3tom1Weights; /** e3 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe3m3tom1; tH1DPtr histe3m3tom1Weights; /** e4 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe4m3tom1; tH1DPtr histe4m3tom1Weights; /** e5 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe5m3tom1; tH1DPtr histe5m3tom1Weights; //eta in (1, 3) /** e1 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe1p1top3; tH1DPtr histe1p1top3Weights; /** e2 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe2p1top3; tH1DPtr histe2p1top3Weights; /** e3 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe3p1top3; tH1DPtr histe3p1top3Weights; /** e4 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe4p1top3; tH1DPtr histe4p1top3Weights; /** e5 as function of number of gluons in the central rapidity interval. */ tH1DPtr histe5p1top3; tH1DPtr histe5p1top3Weights; /** frequency of the distance between the CoG of the gluons in (-3,-1) and (1,3) */ tH1DPtr histCoGdistance; /** correaltion between en in (-3,-1) and (1,3) for N_part > 100. */ double over100Weight; double over100under250Weight; double over350Weight; tH2DPtr histeCorr1; tH2DPtr histeCorr2; tH2DPtr histeCorr3; tH2DPtr histeCorr4; tH2DPtr histeCorr5; tH1DPtr histphiCorr1; tH1DPtr histphiCorr2; tH1DPtr histphiCorr2mid; tH1DPtr histphiCorr2central; tH1DPtr histphiCorr3; tH1DPtr histphiCorr4; tH1DPtr histphiCorr5; // double epFepB1, epF1, epB1, epSqrdF1, epSqrdB1, rho1; double epFepB2, epF2, epB2, epSqrdF2, epSqrdB2, rho2; double epFepB2mid, epF2mid, epB2mid, epSqrdF2mid, epSqrdB2mid, rho2mid; double epFepB2central, epF2central, epB2central, epSqrdF2central, epSqrdB2central, rho2central; double epFepB3, epF3, epB3, epSqrdF3, epSqrdB3, rho3; double epFepB4, epF4, epB4, epSqrdF4, epSqrdB4, rho4; tH1DPtr histe1e1p1top3; tH1DPtr histe1e1p1top3Weights; tH1DPtr histe2e2p1top3; tH1DPtr histe2e2p1top3Weights; tH1DPtr histe3e3p1top3; tH1DPtr histe3e3p1top3Weights; tH1DPtr histe4e4p1top3; tH1DPtr histe4e4p1top3Weights; tH1DPtr histe5e5p1top3; tH1DPtr histe5e5p1top3Weights; /** dN/deta in bins of number of spectators */ tH2DPtr histdNdnSpectdeta; tH1DPtr histdNdeta0to100spect; tH1DPtr histdNdeta100to200spect; tH1DPtr histdNdeta200to300spect; tH1DPtr histdNdeta300to400spect; double spect0to100Weight; double spect100to200Weight; double spect200to300Weight; double spect300to400Weight; /** counts the average number of gluons in rapidity [-0.9,0.9]. */ double centralGlueMult; /** flux tube correlation. */ tH2DPtr histFluxTube; tH2DPtr histFluxTubeWeights; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - FSAnalysis & operator=(const FSAnalysis &); + FSAnalysis & operator=(const FSAnalysis &) = delete; }; } #endif /* DIPSY_FSAnalysis_H */ diff --git a/DIPSY/FSDipole5Ordering.h b/DIPSY/FSDipole5Ordering.h --- a/DIPSY/FSDipole5Ordering.h +++ b/DIPSY/FSDipole5Ordering.h @@ -1,147 +1,147 @@ // -*- C++ -*- #ifndef DIPSY_FSDipole5Ordering_H #define DIPSY_FSDipole5Ordering_H // // This is the declaration of the FSDipole5Ordering class. // #include "Ariadne/Cascade/ReweightBase.h" namespace DIPSY { using namespace Ariadne5; /** * Here is the documentation of the FSDipole5Ordering class. * * @see \ref FSDipole5OrderingInterfaces "The interfaces" * defined for FSDipole5Ordering. */ class FSDipole5Ordering: public Ariadne5::ReweightBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ FSDipole5Ordering(); /** * The destructor. */ virtual ~FSDipole5Ordering(); //@} public: /** * In addition to the reweight function a final hit/miss veto may be * given after the \a emission has been performed. Will only be * called if hasFinalVeto() returns true. */ virtual bool finalVeto(const Emission & emission) 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); //@} /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * If positive, the phase space restriction on final-state emissions * is somewhat relaxed. If negative the phase space is strict and * only given by light-cone momentum non-ordering. */ int isGenerous; /** * Veto only emissions from original partons. */ int useOnlyOriginal; /** * Fudge factor for +/- ordering. Values above one increases the * phase space. */ double f; /** * Switch to kill all final state radiation by veto */ bool killfs; /** * Limit on invariant transverse momentum. Any emission below this * is not checked. */ Energy ptmin; /** * Option for suppression of hard radiation if partons in the dipole * are far separated. */ int hardSuppression; /** * Fudge factor to scale the fraction of light-cone momentum * available for radiation. */ double fudge; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - FSDipole5Ordering & operator=(const FSDipole5Ordering &); + FSDipole5Ordering & operator=(const FSDipole5Ordering &) = delete; }; } #endif /* DIPSY_FSDipoleOrdering_H */ diff --git a/DIPSY/FSDipoleOrdering.h b/DIPSY/FSDipoleOrdering.h --- a/DIPSY/FSDipoleOrdering.h +++ b/DIPSY/FSDipoleOrdering.h @@ -1,123 +1,123 @@ // -*- C++ -*- #ifndef DIPSY_FSDipoleOrdering_H #define DIPSY_FSDipoleOrdering_H // // This is the declaration of the FSDipoleOrdering class. // #include "Ariadne/DipoleCascade/ReweightBase.h" namespace DIPSY { using namespace Ariadne; /** * Here is the documentation of the FSDipoleOrdering class. * * @see \ref FSDipoleOrderingInterfaces "The interfaces" * defined for FSDipoleOrdering. */ class FSDipoleOrdering: public Ariadne::ReweightBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ FSDipoleOrdering(); /** * The destructor. */ virtual ~FSDipoleOrdering(); //@} public: /** * In addition to the reweight function a final hit/miss veto may be * given after the emission has been performed. The arguments are * the original \a dipole, the final dipole \a state and the emitted * \a parton. Also the scale (\a pt2) and \a type of the emission * must be supplied. */ virtual bool finalVeto(tcEmiPtr dipole, Ariadne::tcDipoleStatePtr state, tcParPtr parton, Energy2 pt2, const EmissionType & type) 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); //@} /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * If positive, the phase space restriction on final-state emissions * is somewhat relaxed. If negative the phase space is strict and * only given by light-cone momentum non-ordering. */ int isGenerous; /** * Veto only emissions from original partons. */ bool useOnlyOriginal; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - FSDipoleOrdering & operator=(const FSDipoleOrdering &); + FSDipoleOrdering & operator=(const FSDipoleOrdering &) = delete; }; } #endif /* DIPSY_FSDipoleOrdering_H */ diff --git a/DIPSY/FixedImpactGenerator.h b/DIPSY/FixedImpactGenerator.h --- a/DIPSY/FixedImpactGenerator.h +++ b/DIPSY/FixedImpactGenerator.h @@ -1,162 +1,162 @@ // -*- C++ -*- #ifndef DIPSY_FixedImpactGenerator_H #define DIPSY_FixedImpactGenerator_H // // This is the declaration of the FixedImpactGenerator class. // #include "ImpactParameterGenerator.h" #include "ImpactParameters.h" #include "ThePEG/Repository/UseRandom.h" namespace DIPSY { using namespace ThePEG; /** * The objective of the FixedImpactGenerator class is to generate * ImpactParameters objects to be used when two * DipoleStates have been generated w.r.t. origo in the * transverse to displace and rotate one of them before * collision. This class will generate the absolute value of the * impact parameter to be within a given interval. Note that the cross * sections produced with this objects will not be trustworthy, but * the distibution of events will. * * @see \ref FixedImpactGeneratorInterfaces "The interfaces" * defined for FixedImpactGenerator. */ class FixedImpactGenerator: public ImpactParameterGenerator { public: /** * Use the same Point class as the Parton. */ typedef Parton::Point Point; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ FixedImpactGenerator(); /** * The copy constructor. */ FixedImpactGenerator(const FixedImpactGenerator &); /** * The destructor. */ virtual ~FixedImpactGenerator(); //@} public: /** * Generate an ImpactParameters object. */ virtual ImpactParameters generate(double seed = UseRandom::rnd()) const; /** * The maximum value of the impact parameter. */ InvEnergy maxB() const { return theMaxB/Constants::hbarc; } /** * The minimum value of the impact parameter. */ InvEnergy minB() const { return theMinB/Constants::hbarc; } /** * The angle of b (-1 is random). */ double bAngle() const { return theBAngle; } 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The minimum value of the impact parameter. */ Length theMinB; /** * The maximum value of the impact parameter. */ Length theMaxB; /** * The angle of b (-1 is random). */ double theBAngle; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - FixedImpactGenerator & operator=(const FixedImpactGenerator &); + FixedImpactGenerator & operator=(const FixedImpactGenerator &) = delete; }; } #endif /* DIPSY_FixedImpactGenerator_H */ diff --git a/DIPSY/GapAnalysis.h b/DIPSY/GapAnalysis.h --- a/DIPSY/GapAnalysis.h +++ b/DIPSY/GapAnalysis.h @@ -1,165 +1,165 @@ // -*- C++ -*- #ifndef DIPSY_GapAnalysis_H #define DIPSY_GapAnalysis_H // // This is the declaration of the GapAnalysis class. // #include "ThePEG/Handlers/AnalysisHandler.h" namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the GapAnalysis class. * * @see \ref GapAnalysisInterfaces "The interfaces" * defined for GapAnalysis. */ class GapAnalysis: public AnalysisHandler { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ GapAnalysis(); /** * The destructor. */ virtual ~GapAnalysis(); //@} public: /** @name Virtual functions required by the AnalysisHandler class. */ //@{ /** * Analyze a given Event. Note that a fully generated event * may be presented several times, if it has been manipulated in * between. The default version of this function will call transform * to make a lorentz transformation of the whole event, then extract * all final state particles and call analyze(tPVector) of this * analysis object and those of all associated analysis objects. The * default version will not, however, do anything on events which * have not been fully generated, or have been manipulated in any * way. * @param event pointer to the Event to be analyzed. * @param ieve the event number. * @param loop the number of times this event has been presented. * If negative the event is now fully generated. * @param state a number different from zero if the event has been * manipulated in some way since it was last presented. */ virtual void analyze(tEventPtr event, long ieve, int loop, int state); /** * Return a LorentzTransform which would put the event in the * desired Lorentz frame. * @param event a pointer to the Event to be considered. * @return the LorentzRotation used in the transformation. */ virtual LorentzRotation transform(tcEventPtr event) const; /** * 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 weight of the current event. */ virtual void analyze(const tPVector & particles, double weight); /** * Analyze the given particle. * @param particle pointer to the particle to be analyzed. * @param weight the weight of the current event. */ virtual void analyze(tPPtr particle, double weight); //@} protected: /** * 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(); 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: bool ok; tH1DPtr histEtamax; tH1DPtr histMX; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - GapAnalysis & operator=(const GapAnalysis &); + GapAnalysis & operator=(const GapAnalysis &) = delete; }; } #endif /* DIPSY_GapAnalysis_H */ diff --git a/DIPSY/GaussianImpactGenerator.h b/DIPSY/GaussianImpactGenerator.h --- a/DIPSY/GaussianImpactGenerator.h +++ b/DIPSY/GaussianImpactGenerator.h @@ -1,102 +1,102 @@ // -*- C++ -*- #ifndef DIPSY_GaussianImpactGenerator_H #define DIPSY_GaussianImpactGenerator_H // // This is the declaration of the GaussianImpactGenerator class. // #include "ImpactParameterGenerator.h" namespace DIPSY { using namespace ThePEG; /** * The objective of the GaussianImpactGenerator class is to generate * GaussianImpacts objects to be used when two * DipoleStates have been generated w.r.t. origo in the * transverse to displace and rotate one of them before * collision. This base class will generate impact parameters * according to a Gaussian distribution, and the weigth in the * produced GaussianImpacts objects is set accordingly. Sub-classes * may override the generate() function to use any distribution as * long as the weight is set accordingly. * * @see \ref GaussianImpactGeneratorInterfaces "The interfaces" * defined for GaussianImpactGenerator. */ class GaussianImpactGenerator: public ImpactParameterGenerator { public: /** * Use the same Point class as the Parton. */ typedef Parton::Point Point; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ GaussianImpactGenerator(); /** * The destructor. */ virtual ~GaussianImpactGenerator(); //@} public: /** * Generate an GaussianImpacts object. */ virtual ImpactParameters generate(double seed = UseRandom::rnd()) const; public: /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - GaussianImpactGenerator & operator=(const GaussianImpactGenerator &); + GaussianImpactGenerator & operator=(const GaussianImpactGenerator &) = delete; }; } #endif /* DIPSY_GaussianImpactGenerator_H */ diff --git a/DIPSY/GlauberAnalysis.h b/DIPSY/GlauberAnalysis.h --- a/DIPSY/GlauberAnalysis.h +++ b/DIPSY/GlauberAnalysis.h @@ -1,373 +1,373 @@ // -*- C++ -*- #ifndef DIPSY_GlauberAnalysis_H #define DIPSY_GlauberAnalysis_H // // This is the declaration of the GlauberAnalysis class. // #include "DipoleAnalysisHandler.h" #include "ThePEG/Analysis/FactoryBase.h" #include "ThePEG/Analysis/LWH/AnalysisFactory.h" #include #include "Bin.h" #include "GlauberModels.h" #include "StrikmanModel.h" namespace DIPSY { using namespace ThePEG; using std::valarray; /** * Here is the documentation of the GlauberAnalysis class. * * @see \ref GlauberAnalysisInterfaces "The interfaces" * defined for GlauberAnalysis. */ class GlauberAnalysis: public DIPSY::DipoleAnalysisHandler { public: struct ParticipantParton { ParticipantParton(): p(0), mother(0), father(0), next(0), child(0), y(-10000), interacted(false), index(-1) {} const Parton * p; // The original parton; ParticipantParton * mother; // the main parent (if any. ie. not initial). ParticipantParton * father; // the main parent (if any. ie. not initial). ParticipantParton * next; // The same parton after an emission. ParticipantParton * child; // The emitted parton (if any, ie. has emitted). double y; // The rapidity when this parton instance was produced bool interacted; // true if this parton has already interacted int index; // The index of the nucleon to which this parton belongs. static int mode; // How to trace back parents. const ParticipantParton * origin() const { return mother? mother->origin(): this; } double interact() { interacted = true; if ( !mother || mother->interacted ) return y; if ( mode < 2 || !father || father->interacted ) return mother->interact(); return min(mother->interact(), father->interact()); } static map final; static map initial; static vector all; static void clear() { for ( int i = 0, N = all.size(); i < N; ++i ) delete all[i]; all.clear(); final.clear(); initial.clear(); } static ParticipantParton * create(const Parton & pin, double yin) { ParticipantParton * p = new ParticipantParton(); p->p = &pin; p->y = yin; all.push_back(p); return p; } static ParticipantParton * createInitial(const Parton & pin, double yin) { if ( ParticipantParton * pold = getInitial(&pin) ) return pold; ParticipantParton * pnew = create(pin, yin); initial[&pin] = pnew; return pnew; } static ParticipantParton * getFinal(const Parton * p) { map::iterator pit = final.find(p); if ( pit == final.end() ) return 0; return pit->second; } static ParticipantParton * getInitial(const Parton * p) { map::iterator pit = initial.find(p); if ( pit == initial.end() ) return 0; return pit->second; } void decayAll(); void decay(multimap & children); }; struct Nucleon { Nucleon(): maxdeltay(-10000.0), participating(false) {} void add(const Dipole * d, int index) { add(d->partons().first, index); add(d->partons().second, index); } void add(const Parton * p, int index) { if ( valence.find(p) == valence.end() ) { ParticipantParton * pp = ParticipantParton::createInitial(*p, p->oY()); valence[p] = pp; pp->index = index; pp->decayAll(); } } map valence; double maxdeltay; bool participating; }; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ GlauberAnalysis(); /** * The destructor. */ virtual ~GlauberAnalysis(); //@} public: /** @name Standard virtual functions inherited from the classes. */ //@{ /** * Initialize the analysis object. */ virtual void initialize(); /** * Analyze a given set of collision given a set of left- and * right-moving dipole states in \a vl and \a vr, an a set of * ImpactParameters object in \a vb, and a cross section object, \a * xsec. Also a jacobian, \a jac, is supplied in case of varying * total energy. */ virtual void analyze(const vector & vr, const vector & vl, const vector & vb, const DipoleXSec & xsec, const Vec3D & probs, double jac); virtual void analyze2(const vector & vr, const vector & vl, const vector & vb, const DipoleXSec & xsec, const Vec3D & probs, double jac); /** * Finalize the analysis, (compute statistics etc.). \a neve is the * number of times analyze() has been called since last * initialize(). */ virtual void finalize(long neve); virtual void finalize2(long neve); //@} 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; //@} private: /** * The assumed total nucleon - nucleon cross section */ CrossSection nnSigTot; /** * The assumed elastic nucleon - nucleon cross section */ CrossSection nnSigEl; /** * The assumed inelastic, non-diffracitve nucleon - nucleon cross section */ CrossSection nnSigInND; /** * The assumed single diffractive nucleon - nucleon cross section. */ CrossSection nnSigSD; /** * Different modes for tracing partons back to a nucleon. */ int parentalMode; /** * Cut off above which a wounded nucleon is assumed to contribute as * a true absorbtive nn collision. */ double deltayCut; /** * skewness */ double summean; double sumsig; double skew; double nskew; /** * Number of strategies. */ static const int nstr = 16; /** * The sums. */ valarray sigtot, signd, sigel, sigdt, sigdr, sigdl, sigdd, sigql, sigqr; Bin< valarray > sumlr, sumnd, sum2lr, sumlr2, suml2r, sumr2l; Bin wsigsdl, wsigsdr, wsigdd, wsignd; /** * The sum of squares. */ valarray sigtot2, signd2, sigel2, sigdt2, sigdr2, sigdl2, sigdd2, sigql2, sigqr2; /** * The number of b-values. */ long ntot; /** * The number of t-bins for the elastic cross section */ int Nt; /** * The maximum t-value for the elastic cross section. */ Energy2 tMax; /** * The t-values, first and second strategy */ vector hists, hdyl, hdyr, hdycl, hdycr, habsl, habsr; vector< Bin< valarray > > tel, tel0, telql, telqr; vector< vector > npartdiff; FactoryBase::tH1DPtr histsig, histsig2, histsigerr; /** * The grey2 probabilities for the nucleons, */ mutable map > probl, probr; /** * Calulate all transition probabilities */ valarray getT(const DipoleState & dr, const DipoleState & dl, const ImpactParameters & b, const DipoleXSec & xsec, double fsum) const; pair< vector, vector > dipsyParticipants(const DipoleState & dr, const DipoleState & dl, const ImpactParameters & b, const DipoleXSec & xsec, double fsum) const; /** * Setup probabilities for grey2 nucleons. */ void setupProb(int Nr, const DipoleState & dr, int Nl, const DipoleState & dl) const; /** * helper function for printing */ void print(valarray sig, valarray sig2, int ntot, string xstype) const; void print(valarray sig, valarray sig2, string xstype) const; void print(const Bin< valarray > & sig, string xstype) const; /** * helper function for histogram booking; */ void bookHistos(); /** * Calculate average number ofparticipants above a certain fraction given a histogram. */ static double avpart(FactoryBase::tH1DPtr h, double frac); /** * helper function for printing */ string getStrat(int i) const; static const int a2 = 1; // Glauber2R grey2R; // BlackStrikman grey2R; // Strikman grey2R; GlauberR2 grey2R; ofstream * scaT; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - GlauberAnalysis & operator=(const GlauberAnalysis &); + GlauberAnalysis & operator=(const GlauberAnalysis &) = delete; }; } #endif /* DIPSY_GlauberAnalysis_H */ diff --git a/DIPSY/HIAnalysis.h b/DIPSY/HIAnalysis.h --- a/DIPSY/HIAnalysis.h +++ b/DIPSY/HIAnalysis.h @@ -1,179 +1,179 @@ // -*- C++ -*- #ifndef DIPSY_HIAnalysis_H #define DIPSY_HIAnalysis_H // // This is the declaration of the HIAnalysis class. // #include "ThePEG/Handlers/AnalysisHandler.h" #include #include namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the HIAnalysis class. * * @see \ref HIAnalysisInterfaces "The interfaces" * defined for HIAnalysis. */ class HIAnalysis: public AnalysisHandler { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ HIAnalysis(); /** * The destructor. */ virtual ~HIAnalysis(); //@} public: /** @name Virtual functions required by the AnalysisHandler class. */ //@{ /** * Analyze a given Event. Note that a fully generated event * may be presented several times, if it has been manipulated in * between. The default version of this function will call transform * to make a lorentz transformation of the whole event, then extract * all final state particles and call analyze(tPVector) of this * analysis object and those of all associated analysis objects. The * default version will not, however, do anything on events which * have not been fully generated, or have been manipulated in any * way. * @param event pointer to the Event to be analyzed. * @param ieve the event number. * @param loop the number of times this event has been presented. * If negative the event is now fully generated. * @param state a number different from zero if the event has been * manipulated in some way since it was last presented. */ virtual void analyze(tEventPtr event, long ieve, int loop, int state); /** * Transform the event to the desired Lorentz frame and return the * corresponding LorentzRotation. * @param event a pointer to the Event to be transformed. * @return the LorentzRotation used in the transformation. */ virtual LorentzRotation transform(tEventPtr event) const; /** * 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 */ virtual void analyze(const tPVector & particles, double weight); //@} 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: /** * The output stream where we write the tuples. */ ostream * tuple; /** * Inclusive pt distribution for charged. */ tH1DPtr ptch; /** * Inclusive pt distribution for pi. */ tH1DPtr ptpi; /** * Inclusive pt distribution for K. */ tH1DPtr ptK; /** * Inclusive pt distribution for p. */ tH1DPtr ptp; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - HIAnalysis & operator=(const HIAnalysis &); + HIAnalysis & operator=(const HIAnalysis &) = delete; }; } #endif /* DIPSY_HIAnalysis_H */ diff --git a/DIPSY/ImpactParameterGenerator.h b/DIPSY/ImpactParameterGenerator.h --- a/DIPSY/ImpactParameterGenerator.h +++ b/DIPSY/ImpactParameterGenerator.h @@ -1,147 +1,147 @@ // -*- C++ -*- #ifndef DIPSY_ImpactParameterGenerator_H #define DIPSY_ImpactParameterGenerator_H // // This is the declaration of the ImpactParameterGenerator class. // #include "ThePEG/Handlers/HandlerBase.h" #include "ImpactParameterGenerator.fh" #include "ImpactParameters.h" #include "ThePEG/Repository/UseRandom.h" namespace DIPSY { using namespace ThePEG; /** * The objective of the ImpactParameterGenerator class is to generate * ImpactParameters objects to be used when two * DipoleStates have been generated w.r.t. origo in the * transverse to displace and rotate one of them before * collision. This base class will generate impact parameters * according to a Gaussian distribution, and the weigth in the * produced ImpactParameters objects is set accordingly. Sub-classes * may override the generate() function to use any distribution as * long as the weight is set accordingly. * * @see \ref ImpactParameterGeneratorInterfaces "The interfaces" * defined for ImpactParameterGenerator. */ class ImpactParameterGenerator: public HandlerBase { public: /** * Use the same Point class as the Parton. */ typedef Parton::Point Point; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ ImpactParameterGenerator(); /** * The copy constructor. */ ImpactParameterGenerator(const ImpactParameterGenerator &); /** * The destructor. */ virtual ~ImpactParameterGenerator(); //@} public: /** * Generate an ImpactParameters object. */ virtual ImpactParameters generate(double seed = UseRandom::rnd()) const; /** * Generate an ImpactParameters object, with * the two points at the centre of the distribution. */ virtual ImpactParameters generateDynamic(vector > points1, vector > points2) const; /** * The width of the generated distribution. */ InvEnergy width() const { return theWidth; } 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The width of the generated distribution. */ InvEnergy theWidth; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ImpactParameterGenerator & operator=(const ImpactParameterGenerator &); + ImpactParameterGenerator & operator=(const ImpactParameterGenerator &) = delete; }; } #endif /* DIPSY_ImpactParameterGenerator_H */ diff --git a/DIPSY/LargePTDipoleAbsorber.h b/DIPSY/LargePTDipoleAbsorber.h --- a/DIPSY/LargePTDipoleAbsorber.h +++ b/DIPSY/LargePTDipoleAbsorber.h @@ -1,136 +1,136 @@ // -*- C++ -*- #ifndef DIPSY_LargePTDipoleAbsorber_H #define DIPSY_LargePTDipoleAbsorber_H // // This is the declaration of the LargePTDipoleAbsorber class. // #include "Ariadne/DIPSY/DipoleAbsorber.h" #include "Ariadne/DIPSY/Parton.fh" #include "Ariadne/DIPSY/Dipole.fh" namespace DIPSY { using namespace ThePEG; /** * The LargePTDipoleAbsorber class implements a model describing how * non-interacted dipoles will be reabsorbed. The model is based on * the removal of dipoles with partons with large and opposite * transverse momenta. * * @see \ref LargePTDipoleAbsorberInterfaces "The interfaces" * defined for LargePTDipoleAbsorber. */ class LargePTDipoleAbsorber: public DipoleAbsorber { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ LargePTDipoleAbsorber(); /** * The destructor. */ virtual ~LargePTDipoleAbsorber(); //@} public: /** @name Virtual functions to be overridden. */ //@{ /** * Adds recoils from dipoles that has emitted, trying to account * for emission history. */ virtual void hiddenRecoil(DipoleState &) const; /** * Reabsorb dipoles in the given state. */ virtual void reabsorb(DipoleState &) const; //@} public: /** * Absorb the virtual partons that has no interacting children. */ void absorbVirtualPartons ( DipoleState & ) const; /** * Absorb the provided parton. */ void absorbParton ( tPartonPtr p, DipoleState & ) const; /** * Absorb the provided dipole. */ void absorbDipole ( tDipolePtr d, DipoleState & ) 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); //@} /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - LargePTDipoleAbsorber & operator=(const LargePTDipoleAbsorber &); + LargePTDipoleAbsorber & operator=(const LargePTDipoleAbsorber &) = delete; }; } #endif /* DIPSY_LargePTDipoleAbsorber_H */ diff --git a/DIPSY/NoFluctXSecAnalysis.h b/DIPSY/NoFluctXSecAnalysis.h --- a/DIPSY/NoFluctXSecAnalysis.h +++ b/DIPSY/NoFluctXSecAnalysis.h @@ -1,190 +1,190 @@ // -*- C++ -*- #ifndef DIPSY_NoFluctXSecAnalysis_H #define DIPSY_NoFluctXSecAnalysis_H // // This is the declaration of the NoFluctXSecAnalysis class. // #include "DipoleAnalysisHandler.h" #include "ThePEG/Analysis/FactoryBase.h" #include "ThePEG/Analysis/LWH/AnalysisFactory.h" namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the NoFluctXSecAnalysis class. * * @see \ref NoFluctXSecAnalysisInterfaces "The interfaces" * defined for NoFluctXSecAnalysis. */ class NoFluctXSecAnalysis: public DIPSY::DipoleAnalysisHandler { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ NoFluctXSecAnalysis(); /** * The destructor. */ virtual ~NoFluctXSecAnalysis(); //@} public: /** @name Standard virtual functions inherited from the classes. */ //@{ /** * Initialize the analysis object. */ virtual void initialize(); /** * Analyze a given set of collision given a set of left- and * right-moving dipole states in \a vl and \a vr, an a set of * ImpactParameters object in \a vb, and a cross section object, \a * xsec. Also a jacobian, \a jac, is supplied in case of varying * total energy. */ virtual void analyze(const vector & vr, const vector & vl, const vector & vb, const DipoleXSec & xsec, const Vec3D & probs, double jac); /** * Finalize the analysis, (compute statistics etc.). \a neve is the * number of times analyze() has been called since last * initialize(). */ virtual void finalize(long neve); //@} 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; //@} private: /** * The sum over interactions. */ CrossSection sum00; /** * The sum over interactions with left-going cascades averaged. */ CrossSection sumL0, sum2L0; /** * The sum over interactions with right-going cascades averaged. */ CrossSection sum0R; /** * The sum over squared interactions with both cascades averaged. */ CrossSection sumLR; /** * The sum over squared interactions. */ CrossSection2 sum002; /** * The sum over squared interactions with left-going cascades averaged. */ CrossSection2 sumL02, sum2L02; /** * The sum over squared interactions with right-going cascades averaged. */ CrossSection2 sum0R2; /** * The sum over squared interactions with both cascades averaged. */ CrossSection2 sumLR2; /** * The number of interactions. */ long n00; /** * The number interactions with left-going cascades averaged. */ long nL0, n2L0; /** * The bumber interactions with right-going cascades averaged. */ long n0R; /** * The number interactions with both cascades averaged. */ long nLR; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - NoFluctXSecAnalysis & operator=(const NoFluctXSecAnalysis &); + NoFluctXSecAnalysis & operator=(const NoFluctXSecAnalysis &) = delete; }; } #endif /* DIPSY_NoFluctXSecAnalysis_H */ diff --git a/DIPSY/NucleusData.h b/DIPSY/NucleusData.h --- a/DIPSY/NucleusData.h +++ b/DIPSY/NucleusData.h @@ -1,156 +1,156 @@ // -*- C++ -*- #ifndef DIPSY_NucleusData_H #define DIPSY_NucleusData_H // // This is the declaration of the NucleusData class. // #include "ThePEG/PDT/ParticleData.h" namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the NucleusData class. * * @see \ref NucleusDataInterfaces "The interfaces" * defined for NucleusData. */ class NucleusData: public ThePEG::ParticleData { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ NucleusData(); /** * The destructor. */ virtual ~NucleusData(); //@} /** @name The Create methods are special interfaces for ParticleData classes. */ //@{ /** * Create a Particle which is its own anti-particle. */ static PDPtr Create(long newId, string newPDGName); /** * Create a particle - anti particle pair. */ static PDPair Create(long newId, string newPDGName, string newAntiPDGName); //@} public: /** * Get the atomic number for this nucleus. */ inline unsigned int A() const { return theA; } /** * Get the number of protons in this nucleus. */ inline int Z() const { return theZ; } /** @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: /** * Protected constructor only to be used by subclasses or by the * Create method. */ NucleusData(long newId, string newPDGName); /** * Read setup info from a standard stream. The information that must * be supplied is the same as for ParticleData::readSetup with an * additional constituent mass (in GeV) added in the end. */ virtual void readSetup(istream & is); /** * ParticleData clone method */ virtual PDPtr pdclone() const; 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The atomic number for this nucleus. */ unsigned int theA; /** * The number of protons in this nucleus. */ int theZ; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - NucleusData & operator=(const NucleusData &); + NucleusData & operator=(const NucleusData &) = delete; }; } #endif /* DIPSY_NucleusData_H */ diff --git a/DIPSY/OldGlauberAnalysis.h b/DIPSY/OldGlauberAnalysis.h --- a/DIPSY/OldGlauberAnalysis.h +++ b/DIPSY/OldGlauberAnalysis.h @@ -1,183 +1,183 @@ // -*- C++ -*- #ifndef DIPSY_GlauberAnalysis_H #define DIPSY_GlauberAnalysis_H // // This is the declaration of the GlauberAnalysis class. // #include "DipoleAnalysisHandler.h" #include "ThePEG/Analysis/FactoryBase.h" #include "ThePEG/Analysis/LWH/AnalysisFactory.h" namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the GlauberAnalysis class. * * @see \ref GlauberAnalysisInterfaces "The interfaces" * defined for GlauberAnalysis. */ class GlauberAnalysis: public DIPSY::DipoleAnalysisHandler { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ GlauberAnalysis(); /** * The destructor. */ virtual ~GlauberAnalysis(); //@} public: /** @name Standard virtual functions inherited from the classes. */ //@{ /** * Initialize the analysis object. */ virtual void initialize(); /** * Analyze a given collision. Given left- and right-moving dipole * states, \a dl and \a dr, an ImpactParameters object, \a b, a * cross section object, \a xsec, and the total summed dipole-dipole * scattering probabilities, \a fsum, and the total \a weight * associated with the generated states. */ virtual void analyze(const DipoleState & dl, const DipoleState & dr, const ImpactParameters & b, const DipoleXSec & xsec, double fsum, CrossSection weight); /** * Finalize the analysis, (compute statistics etc.). \a neve is the * number of times analyze() has been called since last * initialize(). */ virtual void finalize(long neve); //@} 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; //@} private: /** * The assumed total nucleon - nucleon cross section */ CrossSection nnSigTot; /** * The assumed elastic nucleon - nucleon cross section */ CrossSection nnSigEl; /** * The assumed inelastic, non-diffracitve nucleon - nucleon cross section */ CrossSection nnSigInND; /** * Number of strategies. */ static const int nstr = 7; /** * The total number of points */ double sumNTot; /** * The total number of points with collisions */ vector sumNColl; /** * The sum of individual weights */ vector sumWeights, sumsig, sumsigel, sumsignd, sumsigdt, sumcoll, sumcoll2, sumpart, sumpart2; /** * The sum of individual squared weights */ vector sumsig2, sumsigel2, sumsignd2, sumsigdt2; /** * The sum of the cross sections seen so far. */ CrossSection sum, sumND; /** * The sum of the squared cross sections seen so far. */ CrossSection2 sum2, sumND2; /** * Helper function for printing. */ void printstrat(int) const; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - GlauberAnalysis & operator=(const GlauberAnalysis &); + GlauberAnalysis & operator=(const GlauberAnalysis &) = delete; }; } #endif /* DIPSY_GlauberAnalysis_H */ diff --git a/DIPSY/OldStyleEmitter.h b/DIPSY/OldStyleEmitter.h --- a/DIPSY/OldStyleEmitter.h +++ b/DIPSY/OldStyleEmitter.h @@ -1,127 +1,127 @@ // -*- C++ -*- #ifndef DIPSY_OldStyleEmitter_H #define DIPSY_OldStyleEmitter_H // // This is the declaration of the OldStyleEmitter class. // #include "Emitter.h" namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the OldStyleEmitter class. * * @see \ref OldStyleEmitterInterfaces "The interfaces" * defined for OldStyleEmitter. */ class OldStyleEmitter: public DIPSY::Emitter { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ OldStyleEmitter(); /** * The destructor. */ virtual ~OldStyleEmitter(); //@} public: /** @name Virtual functions which may be overridden by sub-classes. */ //@{ /** * Generate a possible emission or a swing from a given dipole in the * given rapidity interval [\a miny,\a maxy]. */ virtual void generate(Dipole & dipole, double miny, double maxy) const; /** * Perform the emission previously generated for the given \a * dipole. If no emission has been generated a runtime_error is * thrown. */ virtual void emit(Dipole & dipole) const; //@} protected: /** * Internal function. */ double oldGenerateY(Dipole dip,double ymin) const; /** * Internal function. */ pair oldGenerateXY(Dipole dip, double y0) 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); //@} /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - OldStyleEmitter & operator=(const OldStyleEmitter &); + OldStyleEmitter & operator=(const OldStyleEmitter &) = delete; }; } #endif /* DIPSY_OldStyleEmitter_H */ diff --git a/DIPSY/PT1DEmitter.h b/DIPSY/PT1DEmitter.h --- a/DIPSY/PT1DEmitter.h +++ b/DIPSY/PT1DEmitter.h @@ -1,115 +1,115 @@ // -*- C++ -*- #ifndef DIPSY_PT1DEmitter_H #define DIPSY_PT1DEmitter_H // // This is the declaration of the PT1DEmitter class. // #include "Emitter.h" namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the PT1DEmitter class. * * @see \ref PT1DEmitterInterfaces "The interfaces" * defined for PT1DEmitter. */ class PT1DEmitter: public DIPSY::Emitter { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ PT1DEmitter(); /** * The destructor. */ virtual ~PT1DEmitter(); //@} public: /** @name Virtual functions which may be overridden by sub-classes. */ //@{ /** * Generate a possible emission or a swing from a given dipole in the * given rapidity interval [\a miny,\a maxy]. */ virtual void generate(Dipole & dipole, double miny, double maxy) const; /** * Perform the emission previously generated for the given \a * dipole. If no emission has been generated a runtime_error is * thrown. */ virtual void emit(Dipole & dipole) 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); //@} /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - PT1DEmitter & operator=(const PT1DEmitter &); + PT1DEmitter & operator=(const PT1DEmitter &) = delete; }; } #endif /* DIPSY_PT1DEmitter_H */ diff --git a/DIPSY/PTAnalysis.h b/DIPSY/PTAnalysis.h --- a/DIPSY/PTAnalysis.h +++ b/DIPSY/PTAnalysis.h @@ -1,189 +1,189 @@ // -*- C++ -*- #ifndef DIPSY_PTAnalysis_H #define DIPSY_PTAnalysis_H // // This is the declaration of the PTAnalysis class. // #include "ThePEG/Handlers/AnalysisHandler.h" #include #include namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the PTAnalysis class. * * @see \ref PTAnalysisInterfaces "The interfaces" * defined for PTAnalysis. */ class PTAnalysis: public AnalysisHandler { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ PTAnalysis(); /** * The destructor. */ virtual ~PTAnalysis(); //@} public: /** @name Virtual functions required by the AnalysisHandler class. */ //@{ /** * Analyze a given Event. Note that a fully generated event * may be presented several times, if it has been manipulated in * between. The default version of this function will call transform * to make a lorentz transformation of the whole event, then extract * all final state particles and call analyze(tPVector) of this * analysis object and those of all associated analysis objects. The * default version will not, however, do anything on events which * have not been fully generated, or have been manipulated in any * way. * @param event pointer to the Event to be analyzed. * @param ieve the event number. * @param loop the number of times this event has been presented. * If negative the event is now fully generated. * @param state a number different from zero if the event has been * manipulated in some way since it was last presented. */ virtual void analyze(tEventPtr event, long ieve, int loop, int state); /** * Transform the event to the desired Lorentz frame and return the * corresponding LorentzRotation. * @param event a pointer to the Event to be transformed. * @return the LorentzRotation used in the transformation. */ virtual LorentzRotation transform(tEventPtr event) const; /** * 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 */ virtual void analyze(const tPVector & particles, double weight); /** * Analyze the given particle. * @param particle pointer to the particle to be analyzed. */ virtual void analyze(tPPtr particle, double weight); //@} 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: /** The pt-distribution of charged particles -7 < y < -5. */ tH1DPtr hpt75; /** The pt-distribution of charged particles -5 < y < -3. */ tH1DPtr hpt53; /** The pt-distribution of charged particles -3 < y < -1. */ tH1DPtr hpt31; /** The pt-distribution of charged particles -1 < y < 1. */ tH1DPtr hpt11, hptm1, hptg1, hptG1; /** The pt-distribution of charged particles 1 < y < 3. */ tH1DPtr hpt13; /** The pt-distribution of charged particles 3 < y < 5. */ tH1DPtr hpt35; /** The pt-distribution of charged particles 5 < y < 07. */ tH1DPtr hpt57; /** The eta-distribution of charged particles pt > 5 GeV. */ tH1DPtr heta5; /** * The sum of weights. */ double sumw; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - PTAnalysis & operator=(const PTAnalysis &); + PTAnalysis & operator=(const PTAnalysis &) = delete; }; } #endif /* DIPSY_PTAnalysis_H */ diff --git a/DIPSY/ParticleInfo.h b/DIPSY/ParticleInfo.h --- a/DIPSY/ParticleInfo.h +++ b/DIPSY/ParticleInfo.h @@ -1,110 +1,110 @@ // -*- C++ -*- #ifndef DIPSY_ParticleInfo_H #define DIPSY_ParticleInfo_H // // This is the declaration of the ParticleInfo class. // #include "Ariadne/Config/ColourInfo.h" #include "Parton.h" namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the ParticleInfo class. */ class ParticleInfo: public Ariadne5::ColourInfo { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ ParticleInfo(tcPartonPtr p = tcPartonPtr()); /** * Construct from information supplied by a \a particle. */ ParticleInfo(tcPPtr particle); /** * Construct from information supplied by a \a particle. */ ParticleInfo(const Particle & particle); /** * The destructor. */ virtual ~ParticleInfo(); //@} public: /** * Return the parton from which the particle was created. */ tcPartonPtr parton() const { return theParton; } /** * Return the parton from which the given particle was created. */ static tcPartonPtr getParton(const Particle & particle); 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(); private: /** * Construct from information supplied by a \a particle. */ void init(const Particle & particle); /** * The DIPSY::Parton from which the particle was created. */ cPartonPtr theParton; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ParticleInfo & operator=(const ParticleInfo &); + ParticleInfo & operator=(const ParticleInfo &) = delete; }; } #endif /* DIPSY_ParticleInfo_H */ diff --git a/DIPSY/Parton.h b/DIPSY/Parton.h --- a/DIPSY/Parton.h +++ b/DIPSY/Parton.h @@ -1,743 +1,743 @@ // -*- C++ -*- #ifndef DIPSY_Parton_H #define DIPSY_Parton_H // // This is the declaration of the Parton class. // #include "ThePEG/Config/ThePEG.h" #include "ThePEG/Vectors/Transverse.h" #include "ThePEG/PDT/EnumParticles.h" #include "Ariadne/Config/CloneBase.h" #include "Parton.fh" #include "ShadowParton.fh" #include "Dipole.fh" namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the Parton class. */ class Parton: public Ariadne5::CloneBase { public: friend class RealParton; /** * Typedef for position in transverse coordinate space. */ typedef Transverse Point; /** * A pair of partons. */ typedef pair tPartonPair; /** * A pair of dipoles. */ typedef pair tDipolePair; /** * The Dipole is a friend. */ friend class Dipole; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline Parton() : thePosition(Point()), thePlus(0.0*GeV), theOriginalY(0.0), thePT(TransverseMomentum()), theValencePT(TransverseMomentum()),theValencePlus(ZERO), theMinus(0*GeV), theY(0), isRightMoving(true), theFlavour(ParticleID::g), theParents(tPartonPair()), theDipoles(tDipolePair()), hasInteracted(false), isOnShell(false), isValence(false), theMass(-1*GeV), theShadow(tSPartonPtr()), theColProp(ZERO), theAcoProp(ZERO) {} /** * The copy constructor. */ inline Parton(const Parton & x) : thePosition(x.thePosition), thePlus(x.thePlus), theOriginalY(x.theOriginalY), thePT(x.thePT), theValencePT(x.theValencePT),theValencePlus(x.theValencePlus), theMinus(x.theMinus), theY(x.theY), isRightMoving(x.isRightMoving), theFlavour(x.theFlavour),theParents(x.theParents), theChildren(x.theChildren), theDipoles(x.theDipoles), hasInteracted(x.hasInteracted), isOrdered(x.isOrdered), isOnShell(x.isOnShell), isValence(x.isValence), theMass(x.theMass), theShadow(x.theShadow), theColProp(x.theColProp), theAcoProp(x.theAcoProp) {} /** * The destructor. */ virtual ~Parton(); //@} protected: /** @name The virtual functions to be overridden in sub-classes. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual Ariadne5::ClonePtr clone() const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} public: /** * Return the DipoleState to which this parton belongs. If it was * originally belonged to one state which was subsequently merged * into another, the parton will belong to the latter state. */ DipoleState & dipoleState() const; /** * finds the pTscale through the dipolestates emitter. */ double pTScale() const; /** * Calculate the squared transverse distance to the given parton. */ inline InvEnergy2 dist2(const Parton & p) const { return (position() - p.position()).pt2(); } /** * Produce a ThePEG::Particle corresponding to this parton. */ PPtr produceParticle() const; /** * The mass of this parton. */ Energy mass() const; /** * The scalar transverse momentum squared of this parton. */ Energy2 pt2() const { return pT().pt2(); } /** * The scalar transverse mass squared of this parton. */ Energy2 mt2() const { return pT().pt2() + sqr(mass()); } /** * The scalar transverse momentum of this parton. */ Energy pt() const { return sqrt(pt2()); } /** * The scalar transverse mass of this parton. */ Energy mt() const { return sqrt(mt2()); } /** * The final-state momentum of this particle. */ LorentzMomentum momentum() const { return lightCone(plus(), minus(), pT()); } /** @name Simple access functions. */ //@{ /** * Get the position in impact parameter space. */ inline const Point & position() const { return thePosition; } /** * Get the positive light-cone momentum. */ inline Energy plus() const { return thePlus; } /** * Get the transverse momentum. */ inline TransverseMomentum pT() const { return thePT; } /** * Get the transverse valence momentum. 0 if not a valence parton. */ inline TransverseMomentum valencePT() const { if (isValence) return theValencePT; return TransverseMomentum(); } /** * Get the valence energy. 0 if not a valence parton. */ inline Energy valencePlus() const { if (isValence) return theValencePlus; return ZERO; } /** * Get the accumulated negative light-cone momentum deficit. */ inline Energy minus() const { return theMinus; } /** * Get the rapidity. */ inline double y() const { return theY; } /** * Get the flavour of this parton. */ inline long flavour() const { return theFlavour; } /** * Get the parent partons. */ inline tPartonPair parents() const { return theParents; } /** * Get the main parent. */ inline tPartonPtr mainParent() const { return theMainParent; } /** * Get the children partons. */ inline const set & children() const { return theChildren; }; /** * Remove a child **/ inline void removeChild(PartonPtr child) { theChildren.erase(child); }; /** * Remove all children **/ inline void removeAllChildren() { theChildren.clear(); }; /** * Get the connecting dipoles. */ inline tDipolePair dipoles() const { return theDipoles; } /** * Indicate if this parton has interacted. */ inline bool interacted() const { return hasInteracted; } /** * Indicate if this parton is ordered. */ inline bool ordered() const { return isOrdered; } /** * Set if this parton is ordered. */ inline void ordered(bool b) { isOrdered = b; } /** * Return if this parton is on shell. */ inline bool onShell() const { return isOnShell; } /** * Set if this parton is on shell. */ inline void onShell(bool b) { isOnShell = b; } /** * Return if this parton is a valence parton. */ inline bool valence() const { return isValence; } /** * Returns true if the parton is absorbed. */ bool absorbed() const; /** * Set if this parton is a valence parton. */ inline void valence(bool b) { isValence = b; } /** * Set the position in impact parameter space. */ inline void position(const Point & x) { thePosition = x; } /** * Set the positive light-cone momentum. */ inline void plus(Energy x) { thePlus = x; } /** * Set the transverse momentum. */ inline void pT(TransverseMomentum x) { thePT = x; } /** * Set the transverse valence momentum, and set isValence to true. */ inline void valencePT(TransverseMomentum x) { isValence = true; theValencePT = x; } /** * Set the valence energy. */ inline void valencePlus(Energy E) { theValencePlus = E; } /** * Set the accumulated negative light-cone momentum deficit. */ inline void minus(Energy x) { theMinus = x; } /** * Set the rapidity. */ inline void y(double x) { theY = x; } /** * Set the flavour of this parton. */ inline void flavour(long x) { theFlavour = (x == 0? ParticleID::g: x); } /** * Set the parent partons. */ inline void parents(tPartonPair x) { theParents = x; } /** * Set the main parent parton. */ inline void mainParent(tPartonPtr p) { theMainParent = p; } /** * Set the connecting dipoles. */ inline void dipoles(tDipolePair x) { theDipoles = x; } /** * Get the original emission rapidity. */ inline const double oY() const { return theOriginalY; } /** * Set the original emission rapidity. */ inline void oY(double y) { theOriginalY = y; } /** * Indicate that this parton has interacted. If \a onegluon is true, * only the main parent is recursively flagged as interacted. */ void interact(bool onegluon = false); /** * Returns true if the parton comes from a rightmoving state. */ inline bool rightMoving() const { return isRightMoving; } /** * Set the direction of the original state. */ inline void rightMoving(bool rM) { isRightMoving = rM; } /** * Get and set the number of the parton. */ inline int number() { return theNumber; } inline void number(int N) { theNumber = N; } /** * Checks if the parton is colour connected (in many steps if * needed) to an interacting dipole. */ bool inInteractingLoop() const; /** * counts the number of on shell partons in this partons colour chain. */ int nOnShellInChain() const; /** * Checks if the parton is part of on of its states original dipoles. */ bool valenceParton() const; /** * Checks if the parton is in a colour chain containing a valenceparton. */ bool inValenceChain() const; /** * Returns true if the dipole the parton was emitted from is the result of a swing. **/ bool swingedEmission() const; /** * Updates pT according to the colour neighbours, and changes y and * plus/minus for right/left moving. minus/plus unchanged. */ void updateMomentum(); /** * Updates y and p- from plus and pT. */ inline void updateYMinus() { theY = log(mt()/thePlus); theMinus = mt()*exp(theY); } inline void mirror(double y0) { y(2.0*y0 - y()); swap(thePlus, theMinus); rightMoving(!rightMoving()); } /** * Prints all the member variables to cout. */ void coutData(); /** * Returns the recoil this parton would get from the argument parton. */ TransverseMomentum recoil(tPartonPtr) const; /** * Return the current shadow parton. */ tSPartonPtr shadow() const { return theShadow; } /** * Return a new shadow parton. */ void shadow(tSPartonPtr sp) { theShadow = sp; } /** * Set the virtuality for the propagator conecting the colour side of * this parton. */ void colPropagator(Energy2 kt2) { theColProp = kt2; } /** * Set the virtuality for the propagator conecting the anti-colour side of * this parton. */ void acoPropagator(Energy2 kt2) { theAcoProp = kt2; } /** * The virtuality for the propagator conecting the colour side of * this parton. */ Energy2 colPropagator() const { return theColProp; } /** * The virtuality for the propagator conecting the anti-colour side of * this parton. */ Energy2 acoPropagator() const { return theAcoProp; } //@} public: /** * debugging */ mutable TransverseMomentum m1pT, m2pT; mutable Energy m1plus, m2plus; mutable InvEnergy minr1, minr2, maxr1, maxr2; 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(); private: /** * The position in impact parameter space. */ Point thePosition; /** * The positive light-cone momentum. */ Energy thePlus; /** * The enumeration of this emission. */ double theOriginalY; /** * The transverse momentum. */ TransverseMomentum thePT; /** * The transverse momentum and energy a valenceparton got at creation. */ TransverseMomentum theValencePT; Energy theValencePlus; /** * The accumulated negative light-cone momentum deficit. */ Energy theMinus; /** * The rapidity. */ double theY; /** * The original direction of the particle. */ bool isRightMoving; /** * The flavour of this parton. */ long theFlavour; /** * The parent partons. */ tPartonPair theParents; /** * The main parent parton. */ tPartonPtr theMainParent; /** * The children **/ set theChildren; /** * The connecting dipoles. */ tDipolePair theDipoles; /** * Indicate if this parton has interacted. */ bool hasInteracted; /** * Indicate if this parton is ordered with respect to its colour neighbours. */ bool isOrdered; /** * Indicate if this parton is on shell, that is if it has * been supplied with the neccesary p+ or p- for left or rightmoving * particles respectively. */ bool isOnShell; /** * Indicate if this parton is a valence parton. */ bool isValence; /** * A number that identifies the parton in a dipole state. */ int theNumber; /** * The mass of this parton. */ mutable Energy theMass; /** * The current shadow parton. */ tSPartonPtr theShadow; /** * The virtuality for the propagator conecting the colour side of * this parton. */ Energy2 theColProp; /** * The virtuality for the propagator conecting the anti-colour side of * this parton. */ Energy2 theAcoProp; protected: /** * Exception class for bad kinematics. */ struct PartonKinematicsException: public Exception {}; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - Parton & operator=(const Parton &); + Parton & operator=(const Parton &) = delete; }; } template std::vector & expandToFit(std::vector & v, typename std::vector::size_type indx) { if ( indx >= v.size() ) v.resize(indx + 1); return v; } template T & forceAt(std::vector & v, typename std::vector::size_type indx) { return expandToFit(v, indx)[indx]; } #endif /* DIPSY_Parton_H */ diff --git a/DIPSY/PhotonDipoleState.h b/DIPSY/PhotonDipoleState.h --- a/DIPSY/PhotonDipoleState.h +++ b/DIPSY/PhotonDipoleState.h @@ -1,72 +1,72 @@ // -*- C++ -*- #ifndef DIPSY_PhotonDipoleState_H #define DIPSY_PhotonDipoleState_H // // The PhotonDipoleState class is a simple wrapper sub-class of // DipoleState for easy construction of an initial simple q-qbar // dipole. // #include "DipoleState.h" #include "PhotonWFInfo.h" namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the PhotonDipoleState class. */ class PhotonDipoleState: public DipoleState { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline PhotonDipoleState() {} /** * The standard constructor taking an event handler, the total * positive light-cone momentum and a PhotonWFInfo as argument. */ PhotonDipoleState(const DipoleEventHandler & eh, Energy plus, Energy minus, Ptr::pointer wfi, double weight); /** * The copy constructor. */ inline PhotonDipoleState(const PhotonDipoleState & x) : DipoleState(x) {} /** * The destructor. */ virtual ~PhotonDipoleState(); //@} public: /** * 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(); private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - PhotonDipoleState & operator=(const PhotonDipoleState &); + PhotonDipoleState & operator=(const PhotonDipoleState &) = delete; }; } #endif /* DIPSY_PhotonDipoleState_H */ diff --git a/DIPSY/PhotonWFInfo.h b/DIPSY/PhotonWFInfo.h --- a/DIPSY/PhotonWFInfo.h +++ b/DIPSY/PhotonWFInfo.h @@ -1,153 +1,153 @@ // -*- C++ -*- #ifndef DIPSY_PhotonWFInfo_H #define DIPSY_PhotonWFInfo_H // // This is the declaration of the PhotonWFInfo class. // #include "Ariadne/DIPSY/WFInfo.h" namespace DIPSY { using namespace ThePEG; /** * The PhotonWFInfo class describes the polarizations and energy * sharing of a DipoleState constructed from a VirtualPhoton * wavefunction. */ class PhotonWFInfo: public WFInfo { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor, giving the size, \a rini, energy * sharing, \a zini, the photon polarization, \a polini, the quark * and anti-quark helicities, \a hini and \a hbarini, and the quark * flavour, \a flini, as arguments */ inline PhotonWFInfo(tcWaveFunctionPtr wfin = tcWaveFunctionPtr(), InvEnergy rini = 0.0*InvGeV, double zini = 0.0, int polini = 0, int hini = 0, int hbarini = 0, int flini = 0) : WFInfo(wfin, rini), theZ(zini), thePol(polini), theH(hini), theHbar(hbarini), theFlav(flini) {} /** * The copy constructor. */ inline PhotonWFInfo(const PhotonWFInfo & x) : WFInfo(x), theZ(x.theZ), thePol(x.thePol), theH(x.theH), theHbar(x.theHbar), theFlav(x.theFlav) {} /** * The destructor. */ virtual ~PhotonWFInfo(); //@} public: /** * The energy fraction of the quark. */ inline double z() const { return theZ; } /** * The polarization (-1, 0 or 1) of the photon. */ inline int pol() const { return thePol; } /** * The helicity (+-1) of the quark. */ inline int h() const { return theH; } /** * The helicity (+-1) of the antiquark. */ inline int hbar() const { return theHbar; } /** * Get the flavour of the quark. */ inline int flav() const { return theFlav; } 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(); private: /** * The energy fraction of the quark. */ double theZ; /** * The polarization (-1, 0 or 1) of the photon. */ int thePol; /** * The helicity (+-1) of the quark. */ int theH; /** * The helicity (+-1) of the antiquark. */ int theHbar; /** * The flavour of the quark. */ int theFlav; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - PhotonWFInfo & operator=(const PhotonWFInfo &); + PhotonWFInfo & operator=(const PhotonWFInfo &) = delete; }; } #endif /* DIPSY_PhotonWFInfo_H */ diff --git a/DIPSY/RealParton.h b/DIPSY/RealParton.h --- a/DIPSY/RealParton.h +++ b/DIPSY/RealParton.h @@ -1,595 +1,595 @@ // -*- C++ -*- #ifndef DIPSY_RealParton_H #define DIPSY_RealParton_H // // This is the declaration of the RealParton class. // #include "ThePEG/Config/ThePEG.h" #include "RealParton.fh" #include "RealPartonState.fh" #include "Parton.h" namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the RealParton class. */ class RealParton: public Base { public: /** * Internal class to define the rapidity ordering of RealParton * objects. */ struct RealPartonOrder { /** The actual ordering function. */ bool operator()(tRealPartonPtr a, tRealPartonPtr b) const { return a->theParton->oY() < b->theParton->oY(); } }; /** * A rapidity-ordered set of RealParton objects. */ typedef set RealPartonSet; /** * A recoil with a parton, and how much momenta was TAKEN from that parton. */ typedef pair > Recoil; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ RealParton(tPartonPtr); /** * The destructor. */ virtual ~RealParton(); //@} public: /** * The real state it belongs to. */ tRealPartonStatePtr realState; /** * The possible verdicts for a partons existance. */ enum status {YES, NO}; /** * If this parton should be part of the final state. */ status keep; status cKeep; /** * If this parton is interacting, and with what dipole. */ tDipolePtr interacting; tDipolePtr cInteracting; /** * If the parton has an interaction on the first and second side in colour flow. **/ bool firstInt; bool secondInt; bool cFirstInt; bool cSecondInt; /** * The number of mothers the parton has. **/ int nMothers; /** * The mothers in the final state. */ pair mothers; /** * The original mothers from the evolution. */ pair oMothers; /** * The last pair of mothers that has been part of a consistent state. */ pair cMothers; /** * The mother in the final state, in the model with a single mother. */ tRealPartonPtr mother; tRealPartonPtr cMother; tRealPartonPtr oMother; /** * The children emitted on the first mothers and second mothers side * respectively. */ pair children; pair oChildren; pair cChildren; /** * The parton. */ tPartonPtr theParton; /** * The interactions this parton is connected to. */ set interactions; set cInteractions; /** * The distance to the parton it will be connected to in an interaction, * if the parton is interacting. */ InvEnergy intDist; InvEnergy cIntDist; /** * Dipoles towards mothers that have been checked for DGLAP supression, * and the scale needed to resolve the dipole. */ map resolutionScales; /** * The momentum of the particle. */ TransverseMomentum pT; Energy plus; Energy minus; double y; /** * The plus the parton took from the first and second effective mother respectively. */ Energy plus1, plus2; /** * The transverse momenta and p+ that has been taken from partons at emission. **/ list< Recoil > recoils; /** * The transverse momentum and p+ gotten from the colliding state. **/ pair< TransverseMomentum, Energy > interactionRecoil; pair< TransverseMomentum, Energy > cInteractionRecoil; /** * The future emissions that have effected this parton. **/ RealPartonSet future; /** * the set of partons that will merge into one after interaction. * Points to a set in the realpartonstate. **/ int fluct; int cFluct; /** * The recoilSwings that were made when this realparton was emitted. */ set, pair > > exchanges; set, pair > > cExchanges; /** * if the parton is a valence parton in the last saved state, and the info. */ bool cValence; Energy cValencePlus; TransverseMomentum cValencePT; /** * The parton that inherited the valence status from this parton when * it got set to NO. OR the parton that it inherited the valence status from. */ tRealPartonPtr movedValence; tRealPartonPtr cMovedValence; /** * The p- that has been given to this parton from the other state. **/ Energy givenMinus; Energy cGivenMinus; /** * If the parton has been checked for DGLAP. No point in checking twice. **/ bool DGLAPchecked; /** * Adds the interacting dipole to this parton, and recursively to its oMothers. */ void addInteraction(tDipolePtr); /** * Return the pT the gluon got when emitted from its parents. */ TransverseMomentum opT() ; /** * Controls if the parton is ordered with respect to its mothers. * Valence partons return true. */ bool isOrdered(); /** * Controls if the parton is ordered with respect to its first mothers. * Valence partons return true. */ bool isFirstOrdered(); /** * Controls if the parton is ordered with respect to its second mothers. * Valence partons return true. */ bool isSecondOrdered(); /** * Controls if the parton is ordered with respect to its mother. * Valence partons return true. */ bool isSingleOrdered(); /** * Controls that the emission had enough p+ from the mothers **/ bool hasEnergy(); /** * What pT scale the inconsistencies of the parton is associated with. * Returns ZERO if parton is ok. * problemScale return the max of the other scales. **/ Energy problemScale(); Energy orderedScale(); Energy DGLAPScale(); Energy motherScale(); /** * Some of the scales above has to be calculated at emission, remember/set these here. **/ Energy emissionScale; tRealPartonPtr emissionCause; void checkEmissionProblem(); /** * Returns the cause of the problem with the parton. **/ RealPartonPtr findCause(); RealPartonPtr orderedCause(); RealPartonPtr DGLAPCause(); RealPartonPtr motherCause(); /** * Finds the main suspect for causing this realparton to be unordered. **/ RealPartonPtr findSuspect(); /** * Controls if the parton has any children. */ bool hasChild() const { return !children.first.empty() || !children.second.empty(); } /** * Controls if the parton should be absorb for non-DGLAP chain, * using both future and history of the parton. * Valence partons return true. */ bool DGLAPSafe(InvEnergy scale = ZERO); bool singleDGLAPSafe(InvEnergy scale = ZERO); /** * Tries to anticipate if the parton will get DGLAPVetoed * using only the backwards history. * Does not give false positives. */ bool willBeDGLAPVetoed(); /** * Randomly */ bool checkDGLAPSafe(tRealPartonPtr, tRealPartonPtr, InvEnergy scale = ZERO); /** * Removes the mother links and undoes the recoils. */ void eraseMothers(); /** * Removes the children links and undoes the recoils. */ void eraseChildren(); /** * Finds the colour neighbors. */ RealPartonPtr firstColourNeighbor(); RealPartonPtr secondColourNeighbor(); /** * Finds and returns the (guessed) colour neighbours within range. * Looks among mothers and childs on first or second side. * Due to the swing, this may not reproduce the original neighbor. */ RealPartonSet effectiveParton(InvEnergy range, bool firstSide); /** * The effective plus and minus of the particles within range. * @first flags to look for partons at first or second side. */ pair effectivePlusMinus(InvEnergy range, bool firstSide); /** * The amount of minus required to put all partons within range on shell. */ Energy inRangeMinus(InvEnergy range, bool firstSide); /** * Searches through the effective parton and return true if it finds any negative p+ or p-. **/ bool searchNegative(InvEnergy range, bool firstSide); /** * Does the recoil for the parton p. Uses different schemes from EventFiller::recoilScheme. */ void doRecoil( RealPartonPtr p, Energy recPlus, TransverseMomentum recPT ); /** * Recoils p with constant p+. */ void doXmasRecoil( RealPartonPtr p, Energy recPlus, TransverseMomentum recPT ); /** * Recoils p with constant y. Extra p+ taken from parents. */ void doRainfallRecoil( RealPartonPtr p, Energy recPlus, TransverseMomentum recPT ); /** * Recoils p straight towards (y=0, log(pT)=log(W/2)). Takes extra p+ from parents. **/ void sunshineRecoil(RealPartonPtr p, Energy recPlus, TransverseMomentum recPT); /** * coherently recoils the parton p and the real partons within range. plus and recoil refers * to how much is taken away from the partons, not how much they recieve. * if not enough plus in the partons, y and p- are not updated. * firstSide indicates if the recoil is the first or second mother. */ void doEffectiveRecoil( RealPartonPtr p, InvEnergy range, bool firstSide, Energy recPlus, TransverseMomentum recPT ); /** * Same as above, but forced to weight the partons after p+ */ void doPlusWeightedRecoil( RealPartonPtr p, InvEnergy range, bool firstSide, Energy recPlus, TransverseMomentum recPT ); /** * undoes all recoils made when this real parton was emitted. */ void undoRecoils(); /** * undoes all recoils this real parton caused in the colliding state. */ void undoInteractionRecoils(); /** * Sets NO and updates the relatives. returns false. */ bool setNO(); /** * Sets YES and updates the relatives. returns true if ordered. */ bool setYES(); /** * Sets YES and updates the relatives. returns true if enough energy. */ bool quickSetYES(); /** * Updates y and minus, decide from pT and plus. */ void updateYMinus(); /** * removes all valence substitutes' valence status, and sets this to valence. */ void reclaimValenceStatus(); /** * Undoes all recoilswings that were triggered when the real parton was emitted. */ void eraseExchanges(); /** * Finds the youngest child emitted before the argument was emitted. * If none, the corresponding mother is returned if checkMothers. */ tRealPartonPtr youngestFirstChild(tRealPartonPtr, bool checkMother); tRealPartonPtr youngestSecondChild(tRealPartonPtr, bool checkMother); /** * Sets the mothers of the parton by searching for YES backwards. */ void setMothers(); /** * Sets the single mother of the parton by calling findmothers. */ void setMother(); /** * set the mothers, and change the kid of the mother. */ void setFirstOMother(tRealPartonPtr); void setSecondOMother(tRealPartonPtr); void setOMother(tRealPartonPtr); /** * removes the given child, and undoes the recoil. */ void eraseFirstChild(tRealPartonPtr); void eraseSecondChild(tRealPartonPtr); /** * Set the momentum using the valencePT and oY in theParton. * Should be the starting momentum. */ void setValenceMomentum(); /** * sets p_mu of this realparton, and recoils the mothers. * Return false if not 2 mothers that are ordered. */ bool doRecoil(); /** * sets p_mu of this realparton, and recoils the mother. * Returns false if the mother is not ordered. */ bool doSingleRecoil(); /** * sets p_mu of this realparton, and recoils the mothers. * Return false if not enough energy to do emission. */ bool quickDoRecoil(); /** * check if its mothers were swinged together, and in that maybe gives them an * extra recoil. returns true if recoil is done. */ bool doSwingRecoil(); /** * sets the parton, and recursively its parents, as onShell. */ void setOnShell(); /** * Moves the valence status of this parton to the first child. * returns false if no kids, or if kids are already valence partons. */ bool moveValenceStatus(); /** * Moves the valence status to the realparton rp. */ bool moveValenceStatus(RealPartonPtr); /** * Returns the oldest child, or grandchild etc, that is younger than the argument. */ tRealPartonPtr oldestHeir(tRealPartonPtr); /** * Returns a set of all ancestors, the mothers, the mothers mothers, etc. */ RealPartonSet ancestors(); /** * Checks how much minus is missing from the parton and its parents, * not checking the ones in @checked. */ Energy checkMinus(RealPartonSet checked); /** * Checks how much minus is missing from the effective parton and its parents, * not checking the ones in @checked. */ Energy effectiveCheckMinus(InvEnergy range, bool firstSide, RealPartonSet checked); /** * Gives the parton and it's mothers the minus it needs, and returns how much was missing. */ Energy giveMinus(); /** * Gives the effective parton and it's mothers the minus it needs, and returns how much was missing. */ Energy effectiveGiveMinus(InvEnergy range, bool firstSide); /** * Emits a recoiler gluon with transverse momentum rec, taking a ratio plusRatio of the p+ */ void emitRecoiler(TransverseMomentum rec, double plusRatio); /** * Returns a list of relative weights for the partons in the effective parton. decides how much * recoil each parton should take. */ list effectiveWeights(const RealPartonSet & partons); /** * Saves current configuration. */ void saveState(); /** * reverts to last saved configuration. */ void revert(tDipolePtr intDip); /** * Returns true if the pT fits with wath is expected from the relatives. */ bool checkMomentum() const; /** * the rapidity at which the parton was originally emitted. */ const double oY() const { return theParton->oY(); } /** * For debugging, can all be removed */ TransverseMomentum intRecoil; TransverseMomentum cIntRecoil; mutable int plus1veto; mutable int plus2veto; mutable int minus1veto; mutable int minus2veto; mutable int unDGLAP; void checkPS() const; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - RealParton & operator=(const RealParton &); + RealParton & operator=(const RealParton &) = delete; }; } #endif /* DIPSY_RealParton_H */ diff --git a/DIPSY/RealPartonState.h b/DIPSY/RealPartonState.h --- a/DIPSY/RealPartonState.h +++ b/DIPSY/RealPartonState.h @@ -1,494 +1,494 @@ // -*- C++ -*- #ifndef DIPSY_RealPartonState_H #define DIPSY_RealPartonState_H // // This is the declaration of the RealPartonState class. // #include "ThePEG/Config/ThePEG.h" #include "RealPartonState.fh" #include "RealParton.h" #include "Parton.h" #include "Dipole.h" #include "DipoleState.fh" #include namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the RealPartonState class. */ class RealPartonState: public Base { public: /** * Get typedef from RealParton for convenience. */ typedef RealParton::RealPartonSet RealPartonSet; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ RealPartonState(); /** * The destructor. */ virtual ~RealPartonState(); //@} public: /** * A map relating all generated partons to the corresponding * RealParton objects. */ map partons; /** * The p+ and p- that the original particle had. */ Energy plus; Energy minus; /** * The p- missing that is not reflected in the valence partons. */ Energy minusDeficit; /** * These are the partons that need to be checked to find a * consistent evolution history, */ RealPartonSet toCheck; /** * The prime suspect of making the state not consistent. **/ RealPartonSet suspects; /** * These partons are considered to be valence and do not need to be * checked. */ RealPartonSet valence; RealPartonSet oValence; /** * These are the partons which would be directly involved in the * interaction. */ RealPartonSet interacting; /** * These are the dipoles which would interact if we can find a * consistent evolution history. */ list interactions; list > doesInts; /** * Tested interacting dipoles that failed as primary interactions. */ set failedInts; /** * True if a consistent evolution history has been found for this * state. */ bool consistent; /** * True if the last treated interaction was with a previously interacting dipole. */ bool rescatter; /** * The set of real partons that recoiled over y0 in the last interaction. */ RealPartonSet backwardsPartons; /** * The set of virtual fluctuations in the state. **/ vector flucts; vector cFlucts; /** * Adds an interaction to the state, updating all partons and toCheck. */ void newInteraction(tDipolePtr intDip, tDipolePtr otherIntDip, bool firstInt, bool secondInt, Energy rec1 = ZERO, Energy rec2 = ZERO); /** * Adds an interaction to the state, updating all partons and toCheck. */ void newInteraction(tDipolePtr intDip, tDipolePtr otherIntDip, tPartonPtr parton, const TransverseMomentum & recoil); /** * Adds a real parton to the state, and to toCheck. * Recurs if it has no previous interactions. */ tRealPartonPtr addParton(tPartonPtr); /** * Adds all valence partons in the state to the real state. */ void addValence(DipoleState & state); /** * Finds the RealParton associated with p, or creates one if it doesnt exist. */ tRealPartonPtr getReal(tPartonPtr p); /** * Assuming the past fix, looks for a consistent forward history in which the * parton can exist. */ bool findConsistentEvolution(RealPartonSet::iterator); /** * Does the evolution of toCheck wihtout checking ordering etc. * Only stops if a parton doesnt have enough p+, otherwise goes all the way through. **/ void doEvolution(); /** * checks a parton for non-DGLAP and fixes by merging if needed. * this method recurs backwards to check the pt max first. * Compares to the scale provided, or find it itself if zero. **/ bool checkFixDGLAP(RealPartonPtr rp, InvEnergy scale = ZERO); /** * as above, but for partons with a single mother **/ bool checkFixSingleDGLAP(RealPartonPtr rp, InvEnergy scale = ZERO); /** * checks if mom has a DGLAP-checkable structure, and the mother scale * corresponds to a pt larger than the provided scale. returns false * if either of those fails. **/ bool isMotherStepUp(tRealPartonPtr mom, bool firstSide, InvEnergy scale); /** * merges an FSR double counted parton with its mother. **/ void fixFSRDoubleCounting(tRealPartonPtr rp); /** * checks if the parton couldve been emitted as FSR from its mother and children * does not check if the child is interacting. **/ bool inFSRRegion(tRealPartonPtr rp); /** * takes plus from the parents of rp to set give rp a plus of zero. * does nothing if rp already has positive plus **/ Energy fixNegativePlus(RealPartonPtr rp); /** * checks if rp has a mother in one colour direction, and a child in the other. * this means that the parton should be checked for DGLAP. **/ bool isOutside(tRealPartonPtr rp, bool firstSide); /** * The distance to the last child (or int). Recurs if merged. **/ InvEnergy childScale(tRealPartonPtr rp, bool firstSide); /** * Fixes a DGLAP inconsistency by merging. **/ void fixDGLAP(RealPartonPtr rp); /** * Fixes a DGLAP inconsistency by merging in the singlemother mode. **/ void fixSingleDGLAP(RealPartonPtr rp); /** * Fixes a DGLAP inconsistency by merging. **/ void fixUnOrdered(RealPartonPtr rp, bool forced = false); /** * Adds all plus and pT in each virtual set to the first parton, * and flags the rest as off shell. Manually sets NO without calling setNO(), * to avoid other recoils being canceled outside the virtual set. * should be called only last, after all evos and interactions are done. **/ void mergeVirtuals(); /** * changes all recoils to the "cloud scheme", where the recoil kicks out a fraction * of the parent in a new recoiler gluon. **/ void addRecoilers(); /** * changes rp to the "cloud scheme", where recoils kick out a fraction * of the parent in a new recoiler gluon. **/ void addRecoiler(RealPartonPtr rp); /** * a different (simpler) implementation of the same thing. **/ void addRecoiler2(RealPartonPtr rp); /** * checks if there are any YES partons with negative plus or minus. **/ bool checkForNegatives(); /** * checks if all fluctuations contains partons with identical momenta. * (for debugging) **/ bool checkFlucts(); /** * couts the total and onshell plus and minus. * (for debugging) **/ bool checkPlusMinus(); /** * Joins the partons in a virtual pair, sharing their momenta and flaging them * for reabsorbtion after interaction. **/ void merge(RealPartonPtr rp1, RealPartonPtr rp2); /** * Splits the fluctuation so that rp1 and rp2 will not be merged. * Does nothing if they are not in a common fluctuation. **/ void splitFluct(RealPartonPtr rp1, RealPartonPtr rp2); /** * Divides up the plus and pT evenly and then updates minus. **/ void makeCollinear(const RealPartonSet & rps); /** * Divides up the plus weighted by exp(-oY), * with oY the original y the parton was emitted at. **/ void redistributePlus(const RealPartonSet & rps); /** * Calls setNO for all partons, except the original valence partons, that get setYES. */ void reset(); /** * Calls setNO for all non-valence in toCheck. Calls setYES for valence in toCheck. */ void undoEmissions(); /** * Sets all YES partons in toCheck after rp in oY to NO, and undoes recoils by YES or INT. */ void setFutureNO(tRealPartonPtr rp); /** * Sets all YES partons in rps to NO, calling the setNO of each parton in reverse oY order. */ void setNO(const RealPartonSet & rps); /** * Looks through the partons in toCheck for the problem with highest pT scale. **/ RealPartonPtr findWorstProblem(); /** * Tries to solve the provided problem by removing a parton. * Returns false if no solution is found. **/ bool fix(RealPartonPtr problem); /** * Adds the interacting dipole and checks if the evolution is self consistent. */ bool controlEvolution(tDipolePtr intDip, tDipolePtr otherIntDip); /** * Adds the interacting dipole and does a quick check to remove unordered partons. */ bool singleControlEvolution(tDipolePtr intDip, tDipolePtr otherIntDip, bool firstInt, bool secondInt, Energy rec1 = ZERO, Energy rec2 = ZERO); /** * Adds the interacting dipole and remakes the consistency check * from the start. */ bool singleControlEvolution(tDipolePtr intDip, tDipolePtr otherIntDip, tPartonPtr parton, const TransverseMomentum & recoil); /** * Finds an evolution by eliminating one parton at a time. */ bool nonRecursiveControlEvolution(tDipolePtr intDip, tDipolePtr otherIntDip); /** * Adds the interacting dipole and remakes the consistency check * from the start. */ bool fullControlEvolution(tDipolePtr intDip, tDipolePtr otherIntDip, bool firstInt, bool secondInt, Energy rec1 = ZERO, Energy rec2 = ZERO); /** * adds all partons which have at least one inteaction to the partons to be checked. */ void checkAllInteracting(); /** * adds partons that belong to only the provided interaction to toCheck. */ void checkOnlyNew(tDipolePtr intDip); /** * adds partons that belong to the provided interaction to toCheck. */ void checkInteraction(tDipolePtr intDip); /** * adds rp and its oMothers (recursively) to toCheck. */ void checkHistory(tRealPartonPtr rp); /** * adds the future of every realparton in toCheck to toCheck. */ void checkFuture(); /** * Tells all partons in toCheck to save away current status as * consistent. */ void saveState(); /** * Reverts the state and all its parton to last saved state, and removes last interaction */ void revertToPrevious(DipolePtr intDip); /** * Removes the correct interaction tags on the partons after a failed rescattering. */ void removeLastRescatter(tDipolePtr intDip); /** * Removes/adds the interaction tags on the parton and all its ancestors. */ void removeInt(tRealPartonPtr rp, DipolePtr intDip); void addInt(tRealPartonPtr rp, DipolePtr intDip); // /** // * Return a list of how much p- each interaction needs to put the state on shell. // * NOT USED?? // */ // list neededMinuses(); /** * Checks how much p- all valence partons need. **/ Energy neededValenceMinus(); /** * Sets onShell to true for all YES partons deriving from this interaction. */ void setOnShell(tDipolePtr intDip); /** * Cleans up as if the interaction did not happen by setting both * partons NO. Assumes no rescattering. */ void removeInteraction(tDipolePtr); /** * Removes the partons in backwardsPartons and finds a new parton to do the interaction. */ void removeBackwards(); /** * Prints the state to "realState.dat", and can pauses the program. */ void plotState(bool pause) const; /** * Prints this state and rrs (mirrored) to "realState.dat", and can pauses the program. */ void plotBothStates(RealPartonStatePtr rrs, bool pause) const; /** * Prints the state to @file, and can pauses the program. * The file has to be opened and closed outside this function. * The state can be mirrored in y = 0 in the plot. */ void plotStateToFile(ostream & file, bool mirror) const; /** * returns thenumber of YES and NO particles in the state. */ pair countYESNO() const; /** * Returns the average length in rapidity between a parton and its mother. */ double avYInEvo() const; /** * Runs some tests on the state to check for inconsistencies. */ bool diagnosis(bool pause) const; /** * for debugging. */ mutable int calls; mutable int unOrdered; mutable int unDGLAP; mutable double currentY; mutable int partonCalls; mutable bool monitored; mutable TransverseMomentum totalRecoil; mutable TransverseMomentum cTotalRecoil; Energy totalMinus(); Energy totalPlus(); protected: /** * Exception class to signal bad kinematics. */ struct RealPartonKinematicException: public Exception {}; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - RealPartonState & operator=(const RealPartonState &); + RealPartonState & operator=(const RealPartonState &) = delete; }; } #endif /* DIPSY_RealPartonState_H */ diff --git a/DIPSY/RecoilSwinger.h b/DIPSY/RecoilSwinger.h --- a/DIPSY/RecoilSwinger.h +++ b/DIPSY/RecoilSwinger.h @@ -1,140 +1,140 @@ // -*- C++ -*- #ifndef DIPSY_RecoilSwinger_H #define DIPSY_RecoilSwinger_H // // This is the declaration of the RecoilSwinger class. // #include "Ariadne/DIPSY/Swinger.h" namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the RecoilSwinger class. * * @see \ref RecoilSwingerInterfaces "The interfaces" * defined for RecoilSwinger. */ class RecoilSwinger: public Swinger { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ RecoilSwinger(); /** * The destructor. */ virtual ~RecoilSwinger(); //@} public: /** @name Virtual functions which may be overridden by sub-classes. */ //@{ /** * Generate a swing for the given \a dipole in the given rapidity * interval [\a miny,\a maxy]. If \a force is true, always generate * a swing, otherwise only check if a swing is possible with dipoles * which are new or has changed. */ virtual void generate(Dipole & dipole, double miny, double maxy, bool force) const; /** * Perform a recombination previously generated by generateRec(). */ virtual void recombine(Dipole & dipole) const; //@} public: /** * Exchanges a gluon, resulting in a colour recombination and a recoil. */ void exchange(Dipole & dipole) const; /** * The probability per rapidity of a gluon exchange. kinematics veto not included. */ double exchangeAmp(const pair, const pair) const; /** * If a gluon exchange between the two dipoles is forbidden. */ bool kinematicsVeto(const pair, const pair) const; /** * Generates a gluon exchange in the given rapidity intervall. */ void generateExchange(Dipole & dipole, double miny, double maxy, bool force) 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); //@} /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - RecoilSwinger & operator=(const RecoilSwinger &); + RecoilSwinger & operator=(const RecoilSwinger &) = delete; }; } #endif /* DIPSY_RecoilSwinger_H */ diff --git a/DIPSY/SemiInclusiveXSecAnalysis.h b/DIPSY/SemiInclusiveXSecAnalysis.h --- a/DIPSY/SemiInclusiveXSecAnalysis.h +++ b/DIPSY/SemiInclusiveXSecAnalysis.h @@ -1,142 +1,142 @@ // -*- C++ -*- #ifndef DIPSY_SemiInclusiveXSecAnalysis_H #define DIPSY_SemiInclusiveXSecAnalysis_H // // This is the declaration of the SemiInclusiveXSecAnalysis class. // #include "DipoleAnalysisHandler.h" #include "ThePEG/Analysis/FactoryBase.h" #include "ThePEG/Analysis/LWH/AnalysisFactory.h" namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the SemiInclusiveXSecAnalysis class. * * @see \ref SemiInclusiveXSecAnalysisInterfaces "The interfaces" * defined for SemiInclusiveXSecAnalysis. */ class SemiInclusiveXSecAnalysis: public DIPSY::DipoleAnalysisHandler { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ SemiInclusiveXSecAnalysis(); /** * The destructor. */ virtual ~SemiInclusiveXSecAnalysis(); //@} public: /** @name Standard virtual functions inherited from the classes. */ //@{ /** * Initialize the analysis object. */ virtual void initialize(); /** * Analyze a given set of collision given a set of left- and * right-moving dipole states in \a vl and \a vr, an a set of * ImpactParameters object in \a vb, and a cross section object, \a * xsec. Also a jacobian, \a jac, is supplied in case of varying * total energy. */ virtual void analyze(const vector & vr, const vector & vl, const vector & vb, const DipoleXSec & xsec, const Vec3D & probs, double jac); /** * Finalize the analysis, (compute statistics etc.). \a neve is the * number of times analyze() has been called since last * initialize(). */ virtual void finalize(long neve); //@} 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; //@} private: /** * The sums. */ CrossSection sigtot, signd, sigel, sigdt, sigdr, sigdl, sigdd; /** * The sum of squares. */ CrossSection2 sigtot2, signd2, sigel2, sigdt2, sigdr2, sigdl2, sigdd2; /** * The number of b-values. */ long ntot; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - SemiInclusiveXSecAnalysis & operator=(const SemiInclusiveXSecAnalysis &); + SemiInclusiveXSecAnalysis & operator=(const SemiInclusiveXSecAnalysis &) = delete; }; } #endif /* DIPSY_SemiInclusiveXSecAnalysis_H */ diff --git a/DIPSY/ShadowParton.h b/DIPSY/ShadowParton.h --- a/DIPSY/ShadowParton.h +++ b/DIPSY/ShadowParton.h @@ -1,1022 +1,1022 @@ // -*- C++ -*- #ifndef DIPSY_ShadowParton_H #define DIPSY_ShadowParton_H // // This is the declaration of the ShadowParton class. // #include "ThePEG/Config/ThePEG.h" #include "ThePEG/Vectors/Transverse.h" #include "ThePEG/PDT/EnumParticles.h" #include "ThePEG/Repository/UseRandom.h" #include "Ariadne/Config/CloneBase.h" #include "ShadowParton.fh" #include "Parton.h" #include "Dipole.fh" #include "DipoleXSec.fh" #include "Sum20Momentum.h" namespace DIPSY { using namespace ThePEG; class ImpactParameters; /** * Here is the documentation of the ShadowParton class. */ class ShadowParton: public Ariadne5::CloneBase { public: /** * Typedef for position in transverse coordinate space. */ typedef Transverse Point; /** * A pair of partons. */ typedef pair tSPartonPair; /** * Helper class for traversing along a propagator to an interaction */ struct Propagator { /** * Constructor. */ Propagator(): colpos(Constants::MaxEnergy), colneg(ZERO), colptp(ZERO), acopos(Constants::MaxEnergy), aconeg(ZERO), acoptp(ZERO), maxkt(ZERO), fail(false) {} /** * Copy constructor. */ Propagator(const Propagator & k) : p(k.p), colpos(k.colpos), colneg(k.colneg), colptp(k.colptp), acopos(k.acopos), aconeg(k.aconeg), acoptp(k.acoptp), maxkt(k.maxkt), fail(k.fail) {} /** * Construct from momentum. p */ Propagator(const LorentzMomentum & mom) : p(mom), colpos(Constants::MaxEnergy), colneg(ZERO), colptp(ZERO), acopos(Constants::MaxEnergy), aconeg(ZERO), acoptp(ZERO), maxkt(ZERO), fail(false) {} /** * The Momentum of the propagator. */ LorentzMomentum p; /** * The positive light-cone momentum of the previous emission on * the colour line. */ Energy colpos; /** * The negative light-cone momentum of the previous emission on * the colour line. */ Energy colneg; /** * The pt of the propagator before the previous emission on the * colour line (ie. previous emission with an inti-colour sibling). */ Energy2 colptp; /** * The positive light-cone momentum of the previous emission on * the anti-colour line (ie. previous emission with a colour sibling). */ Energy acopos; /** * Thenegative light-cone momentum of the previous emission on the * anti-colour line. */ Energy aconeg; /** * The pt of the propagator before the previous emission on the * anti-colour line. */ Energy2 acoptp; /** * The maximum transverse momentum of the chain of propagators * leading up to (and including) this. */ Energy maxkt; /** * Indicate that the propagator has failed. */ bool fail; /** * Update the maximumtransverse momentum. */ void setmaxkt() { if ( p.perp() > maxkt ) maxkt = p.perp(); } }; /** * Helper class to temporarily protect a propagator. */ struct Lock { /** * The only constructor. Locking the propagator to a given parton. */ Lock(tPartonPtr p): sp(p->shadow()) { sp->lock(); } /** * The destructor, unlocking the propagator. */ ~Lock() { sp->unlock(); } /** * The parton to which the propagator should be locked. */ tSPartonPtr sp; }; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline ShadowParton() : thePlus(ZERO), theMass(-1*GeV), theMinus(0*GeV), theY(0), theY0(0), theFlavour(ParticleID::g), theEmissionFactor(ZERO), theRes(ZERO), isLocked(false), hasInteracted(false), isOnShell(false), isValence(false), hasColourSibling(false), memememe(false) {} /** * Construct from ordinary parton. */ ShadowParton(Parton & p); /** * The destructor. */ virtual ~ShadowParton(); /** * Create a valence shadow parton from a given ordinary parton. */ static SPartonPtr createValence(Parton & p); /** * Easy access to alphaS. */ static double alphaSr(InvEnergy2 r2); /** * Setup shadow partons in an emission. */ void setupEmission(Parton & emitter, Parton & produced, Parton & recoiler); /** * Setup pointers to and from neighboring partons. */ void setupParton(); //@} protected: /** @name The virtual functions to be overridden in sub-classes. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual Ariadne5::ClonePtr clone() const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} public: /** * Return the DipoleState to which this parton belongs. If it was * originally belonged to one state which was subsequently merged * into another, the parton will belong to the latter state. */ DipoleState & dipoleState() const; /** * finds the pTscale through the dipolestates emitter. */ double pTScale() const; /** * Calculate the squared transverse distance to the given parton. */ inline InvEnergy2 dist2(const ShadowParton & p) const { return (position() - p.position()).pt2(); } /** * Calculate the transverse distance to the given parton. */ inline InvEnergy dist(const ShadowParton & p) const { return sqrt(dist2(p)); } /** * Produce a ThePEG::Particle corresponding to this parton. */ PPtr produceParticle() const; /** * The mass of this parton. */ Energy mass() const; /** * The transverse momentum squared of this parton. */ Energy2 pt2() const { return pT().pt2(); } /** * The transverse mass squared of this parton. */ Energy2 mt2() const { return pt2() + sqr(mass()); } /** * The transverse mass of this parton in the emission. */ Energy2 mt02() const { return pT0().pt2() + sqr(mass()); } /** * The transverse mass of this parton in the emission. */ Energy mt0() const { return sqrt(mt02()); } /** * The transverse momentum of this parton. */ Energy pt() const { return sqrt(pt2()); } /** * The transverse momentum of this parton. */ Energy mt() const { return sqrt(mt2()); } /** * The final-state momentum of this particle. */ LorentzMomentum momentum() const { return lightCone(plus(), mt2()/plus(), pT()); } /** @name Simple access functions. */ //@{ /** * Get the position in impact parameter space. */ inline const Point & position() const { return original()->position(); } /** * Get the positive light-cone momentum. */ inline Energy plus() const { return thePlus; } /** * Get the original positive light-cone momentum. */ inline Energy plus0() const { return mt0()*exp(-y0()); } /** * Get the transverse momentum. */ inline TransverseMomentum pT() const { return thePT; } /** * Get the transverse momentum. */ inline TransverseMomentum pT0() const { return thePT0; } /** * Get the accumulated negative light-cone momentum deficit. */ inline Energy minus() const { return theMinus; } /** * Get the rapidity. */ inline double y() const { return theY; } /** * Get the rapidity generated in the emission. */ inline double y0() const { return theY0; } /** * Get the flavour of this parton. */ inline long flavour() const { return theFlavour; } /** * Get the original DIPSY parton. */ tPartonPtr original() const { return theOriginal; } /** * Get the previous instance of this parton befor it was emitted or * swinged. */ inline tSPartonPtr previous() const { return thePrevious; } /** * Get the parent parton if this was emitted. */ inline tSPartonPtr parent() const { return theParent; } /** * Get the sibling of this parton if any. */ inline tSPartonPtr sibling() const { return theSibling; } /** * Get the next version of this parton if emitted or swinged. */ inline tSPartonPtr next() const { return theNext; } /** * Get the first version of this parton if emitted or swinged. */ tSPartonPtr initial(); /** * Get the first (grand)mother of this parton. */ tSPartonPtr valenceMother(); /** * Get the last version of this parton if emitted or swinged. */ tSPartonPtr last(); /** * Get the last version of this parton if emitted or swinged. */ tcSPartonPtr last() const; /** * Get the parton this has emitted if any. */ inline tSPartonPtr child() const { return theChild; } /** * Get the mother parton, either previous() or parent(). */ inline tSPartonPtr mother() const { return parent()? parent(): previous(); } /** * Indicate that the corresponding emission is on a protected * propagator. Any other propagator must assume that this emission * must be resolved. */ inline bool locked() const { return isLocked; } /** * Indicate that the propagator leading up to this parton is protected. */ void lock(); /** * Indicate that the propagator leading up to thi parton is no * longer protected. */ void unlock(); /** * Indicate if this parton has interacted. */ inline bool interacted() const { return hasInteracted; } /** * Return true if the sibling is on the colour side of this parton. */ inline bool colourSibling() const { return hasColourSibling; } /** * Return if this shadow was the root of an interacting propagator. */ inline bool interactionRoot() const { return theInteractionRoots.size() > 0; } /** * Return if this shadow was the root of an interacting propagator. */ inline bool hasInteractionRoot(int i) const { return theInteractionRoots.find(i) != theInteractionRoots.end(); } /** * Return if this shadow was directly involved in the interaction. */ inline int interacting() const { return theInteractions.size() > 0; } /** * Return if this parton is on shell. */ inline bool onShell() const { return isOnShell; } /** * Set if this parton is on shell. */ inline void onShell(bool b) { isOnShell = b; } /** * Indicate that this parton is the root of an interaction. */ inline void interactionRoot(int i) { theInteractionRoots.insert(i); } /** * Set if this shadow is directly involved in an interaction. */ inline void interacting(int i) { theInteractions.insert(i); } /** * Return if this parton is a valence parton. */ inline bool valence() const { return isValence; } /** * Set if this parton is a valence parton. */ inline void valence(bool b) { isValence = b; } /** * Set the positive light-cone momentum. */ inline void plus(Energy x) { thePlus = x; } /** * Set the transverse momentum. */ inline void pT(const TransverseMomentum & x) { thePT = x; } /** * Set the momentum using transverse momentum and positive * light-cone momentum. Set also other components assuming real. */ void pTplus(const TransverseMomentum & qt, Energy qp); /** * Reset the momentum to its original value in the evolution. */ void resetMomentum0() { pTplus(pT0(), mt0()/exp(y0())); } /** * Set the transverse momentum. */ inline void pT0(const TransverseMomentum & x) { thePT0 = x; } /** * Set the accumulated negative light-cone momentum deficit. */ inline void minus(Energy x) { theMinus = x; } /** * Set the rapidity. */ inline void y(double x) { theY = x; } /** * Set the rapidity. */ inline void y0(double x) { theY0 = x; } /** * Set the flavour of this parton. */ inline void flavour(long x) { theFlavour = (x == 0? ParticleID::g: x); } /** * Set the parent parton. */ inline void parent(tSPartonPtr p) { theParent = p; } /** * Indicate that this parton has interacted and mark all parent and * original partons if needed. */ void interact(); /** * The emission factor for this parton if emitted or emitter. */ InvEnergy2 emissionFactor() const { return theEmissionFactor; } /** * The resolusion scale factor for this parton if emitted or emitter. */ InvEnergy2 res() const { return theRes; } /** * Return true if this parton and its sibling are resolved. */ bool resolved(InvEnergy2 r2) const; // { // return ( ( sibling() && ( sibling()->locked() // || emissionFactor() > r2 ) ) ); // // return ( ( sibling() && ( sibling()->locked() // // || emissionFactor() > r2*alphaS(r2) ) ) ); // } /** * Return true if the sibling must be put on-shell even if it was not * resolved, because it will partake in a subsequent interaction or is * a valence. */ bool forceEmission() const { return sibling() && ( sibling()->valence() || sibling()->interactionRoot() ); } /** * Go back in the history of this shadow parton and find the * original parton which would be resolved at a given size or would * be the interaction root. Always resolve emissions involving \a * stopp. */ tSPartonPtr resolveInteraction(InvEnergy2 d2, tPartonPtr stopp) { Lock safeguard(stopp); return resolveInteraction(alphaSr(d2)*d2); // return resolveInteraction(d2); } /** * Go back in the history of this shadow parton and find the * original parton which would be resolved at a given size scale or * would be the interaction root. */ tSPartonPtr resolveInteraction(InvEnergy2 r2); /** * Go back in the history of this shadow parton and find the * original parton which would be resolved at a given size. Always * resolve emissions involving \a stopp. */ tSPartonPtr resolve(InvEnergy2 d2, tPartonPtr stopp) { Lock safeguard(stopp); return resolve(d2*alphaSr(d2)); // return resolve(d2); } /** * Go back in the history of this shadow parton and find the * original parton which would be resolved at a given size. Always * resolve emissions involving \a stopp. (const version). */ // tcSPartonPtr resolve(InvEnergy2 r2, tPartonPtr stopp) const; /** * Go back in the history and flag all partons which are resoved by * the given size to be set on-shell. Always * resolve emissions involving \a stopp. */ // void flagOnShell(InvEnergy2 r2, tPartonPtr stopp); /** * If this parton is not on shell, find an emitted parton * with the same colour lines (modulo swing) that is. */ tSPartonPtr findFirstOnShell(); /** * If this parton is not on shell, find an emitted parton * with the same colour lines (modulo swing) that is. */ tSPartonPtr findSecondOnShell(); /** * Flag on-shell if \a mode >= 0 and copy to original parton if \a * mode > 0. Also supplied is the incoming propagator before the emission. */ void setOnShell(int mode, const Propagator & incprop); /** * If prevoíously set on-shell, clear the flag. */ void unsetOnShell(); /** * Go forward in the evolution and reset all interaction flags. */ void reset(); /** * Go forward in the evolution and reset all interacted flags. */ void resetInteracted(); /** * Set the momenta in an emission, assuming the incoming momentum \a p. */ bool setEmissionMomenta(const LorentzMomentum & p, bool valencefix); bool setEmissionMomentaPlus(const LorentzMomentum & p, bool valencefix); protected: /** * Go back in the history of this shadow parton and find the * original parton which would be resolved at a given size scale. */ tSPartonPtr resolve(InvEnergy2 r2); public: /** * Go back in the history and find the momentum of this incoming * parton. Always resolve emissions involving \a stopp. If \a mode * >= 0 flag partons which would be put on shell. if \a mode > 0 * also propagate the momentum to the original() parton. */ Propagator propagator(InvEnergy2 d2, tPartonPtr stopp, int mode) { Lock safeguard(stopp); return propagator(d2*alphaSr(d2), mode); // return propagator(d2, mode); } Propagator propagator(InvEnergy2 r2, int mode); Propagator setMomentum(const Propagator & prop) { plus(prop.p.plus()); pT(TransverseMomentum(prop.p.x(), prop.p.y())); return prop; } void checkMomentum(Sum20Momentum & sum20, const ImpactParameters * b = 0) const; /** * Check if the propagator leading to this interaction is still * viable. Ie. Either that it is the primary interaction, or that a * previous interaction still has put an appropriate parton * on-shell. * *** TODO *** fix a better solution to this problem */ bool checkInteractionRoot(int i) const; /** * Indicate that this parton should be tested for an * interaction. Insert the corresponding interaction object at the * correct place in the chain. The primary interaction is always at * one of the incoming shadows. Secondary interactions are inserted * at a parton which has been or should be made real by a previous * emission. If this parton already had an interaction, simply leave * it as it is. */ void insertInteraction(int i); /** * Indicate that a previously tested interaction is accepted. This * is done by marking all propagators interacted() in the chain down * to the one where the interaction was found. */ void acceptInteraction(int i); /** * Make this and all its anceseters incoming. */ void makeIncoming(); /** * Indicate that the interaction that has been tested was rejected * by simply removing the interaction root inserted by * insertInteraction(). */ void rejectInteraction(int i); /** * Change direction before producing collision. */ void mirror(double yframe); /** * Translate according to the impagt parameter. */ void translate(const ImpactParameters & b); /** * Check if the generated emission fails the ordering requirement. */ bool orderfail(const Propagator & prop) const; /** * Setup the continuing propagater with the generated emission. */ Propagator setup(Propagator & prop) const; /** * Prints all the member variables to cerr. */ void debugme(); /** * Debug the structure of the shadow tree. */ void debugTree(string indent); //@} 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(); private: /** * The original DIPSY parton */ tPartonPtr theOriginal; /** * The positive light-cone momentum. */ Energy thePlus; /** * The transverse momentum. */ TransverseMomentum thePT; /** * The transverse momentum generated in the emission. */ TransverseMomentum thePT0; /** * The mass of this parton. */ mutable Energy theMass; /** * The accumulated negative light-cone momentum deficit. */ Energy theMinus; /** * The rapidity. */ double theY; /** * The rapidity generated in the emission. */ double theY0; /** * The flavour of this parton. */ long theFlavour; /** * The state of this parton, if any, before the swing or the emission of this * parton's sibling. Is aways null if theParent exists. */ tSPartonPtr thePrevious; /** * The parent parton if this has emitted or swinged. Is aways null if * thePrevious exists. */ tSPartonPtr theParent; /** * The sibling of this parton if any. */ tSPartonPtr theSibling; /** * The state of this parton after the emission of the child. Is null * if this parton has not emitted. */ SPartonPtr theNext; /** * The child this parton has emitted, if any. */ SPartonPtr theChild; /** * The emission factor for this parton if emitted or emitter. */ InvEnergy2 theEmissionFactor; /** * The resolution factor for this parton if emitted or emitter. */ InvEnergy2 theRes; /** * Indicate that the corresponding emission is on a protected * propagator. Any other propagator must assume that this emission * must be resolved. */ bool isLocked; /** * Indicate if this parton has interacted. */ bool hasInteracted; /** * Indicate if this parton is on shell, that is if it has * been supplied with the neccesary p+ or p- for left or rightmoving * particles respectively. */ bool isOnShell; /** * If this is on-shell, here is the incoming propagator before this was emitted. */ Propagator theIncomingPropagator; /** * This is root of an interaction chain. */ set theInteractionRoots; /** * The interactions this was directly involved with. */ set theInteractions; /** * Indicate if this parton is a valence parton. */ bool isValence; /** * Indicate if this partons sibling is on the colour side (true) or * the anti-colour side (false). */ bool hasColourSibling; protected: /** * Exception class for bad kinematics. */ struct ShadowPartonKinematicsException: public Exception {}; public: bool memememe; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ShadowParton & operator=(const ShadowParton &); + ShadowParton & operator=(const ShadowParton &) = delete; }; } #endif /* DIPSY_ShadowParton_H */ diff --git a/DIPSY/SimpleNucleus.h b/DIPSY/SimpleNucleus.h --- a/DIPSY/SimpleNucleus.h +++ b/DIPSY/SimpleNucleus.h @@ -1,294 +1,294 @@ // -*- C++ -*- #ifndef DIPSY_SimpleNucleus_H #define DIPSY_SimpleNucleus_H // // This is the declaration of the SimpleNucleus class. // #include "Ariadne/DIPSY/WaveFunction.h" #include "ThePEG/Analysis/FactoryBase.h" namespace DIPSY { using namespace ThePEG; /** * The SimpleNucleus class represents the unevolved proton wave * function described in terms of an equilatteral triangle of dipoles * with a size distributed as a Gaussian. * * @see \ref SimpleNucleusInterfaces "The interfaces" * defined for SimpleNucleus. */ class SimpleNucleus: public WaveFunction { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ SimpleNucleus() : A(208), Z(82), R(6.68*femtometer), a(0.546*femtometer), w(0.0), wf(WaveFunctionPtr()), wfp(WaveFunctionPtr()), wfn(WaveFunctionPtr()), Rn(1.3*femtometer), useInterNucleonSwing(true), nTry(1), doRecenter(false), rdist(0) {} /** * The destructor. */ virtual ~SimpleNucleus(); //@} public: /** @name Main virtual functions to be overridden in sub-classes. */ //@{ /** * Initialize the wavefunction for the given DipoleEventHandler. */ virtual void initialize(const DipoleEventHandler &); /** * Generate a dipole state according to this wavefunction, given an * event handler and a positive light-cone momentum component. */ virtual DipoleStatePtr generate(const DipoleEventHandler & eh, Energy plus); /** * Return the invariant mass squared of the particle. */ virtual Energy2 m2() 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(); //@} public: /** @Name Simple access functions. */ //@{ /** * Return the nucleon wave function. */ tWaveFunctionPtr nucleon() const { return wf; } /** * Return the proton wave function. */ tWaveFunctionPtr proton() const { return wfp; } /** * Return the number of protons. */ int nProtons() const { return abs(Z); } /** * Return the neutron wave function. */ tWaveFunctionPtr neutron() const { return wfn; } /** * Return the number of protons. */ int nNeutrons() const { return abs(A) - nProtons(); } /** * Return the mass number. */ int massNumber() const { return A; } /** * Return true if we want inter-nucleon swings. */ bool interNucleonSwing() const { return useInterNucleonSwing; } /** * Return true if the nucleons should be recentered to put the * center of mass at zero impact parameter after distribution of * nucleons. */ inline bool recenter() const { return doRecenter; } /** * Return the Wood-Saxon potential. */ double ws(Length r) const { Length Rc = min(R - Rn/2.0, R); return (1.0 + w*sqr(r)/sqr(Rc))/(1.0 + exp((r - Rc)/a)); } //@} 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 { return new_ptr(*this); } /** 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 { return new_ptr(*this); } //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The mass number of the nucleaus. */ int A; /** * The charge of the nucleaus. */ int Z; /** * The size of the nucleus. */ Length R; /** * The suppression at the edge of the nucleus. */ Length a; /** * Optional quadratic term in Wood-Saxon potential */ double w; /** * Wave function of the individual nucleons. */ WaveFunctionPtr wf; /** * Wave function of the individual protons. */ WaveFunctionPtr wfp; /** * Wave function of the individual neutrons. */ WaveFunctionPtr wfn; /** * Size of an individual nucleon for the exclusion mechanism. */ Length Rn; /** * Allow swings between nucleons in the nuclei. */ bool useInterNucleonSwing; /** * Number of times to try new angles for the same r-value if * overlapping nucleons are found. If zero, the whole set of * generated positions is discarded if anoverlap is found. */ int nTry; /** * Return true if the nucleons should be recentered to put the * center of mass at zero impact parameter after distribution of * nucleons. */ bool doRecenter; /** The distribution of nucleon centers. */ FactoryBase::tH1DPtr rdist; /** * Helper function to set measured parametrs of a nucleus given by * the name. */ string setParameters(string); private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - SimpleNucleus & operator=(const SimpleNucleus &); + SimpleNucleus & operator=(const SimpleNucleus &) = delete; }; } #endif /* DIPSY_SimpleNucleus_H */ diff --git a/DIPSY/SimpleNucleusState.h b/DIPSY/SimpleNucleusState.h --- a/DIPSY/SimpleNucleusState.h +++ b/DIPSY/SimpleNucleusState.h @@ -1,70 +1,70 @@ // -*- C++ -*- #ifndef DIPSY_SimpleNucleusState_H #define DIPSY_SimpleNucleusState_H // // This is the declaration of the SimpleNucleusState class. // #include "DipoleState.h" namespace DIPSY { using namespace ThePEG; class SimpleNucleus; /** * Here is the documentation of the SimpleNucleusState class. */ class SimpleNucleusState: public DipoleState { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline SimpleNucleusState() {} /** * The standard constructor. */ SimpleNucleusState(const DipoleEventHandler & eh, SimpleNucleus & WF, Energy plus, Energy minus, const vector & positions, WFInfoPtr wfi); /** * The copy constructor. */ inline SimpleNucleusState(const SimpleNucleusState & x) : DipoleState(x) {} /** * The destructor. */ virtual ~SimpleNucleusState(); //@} public: /** * 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(); private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - SimpleNucleusState & operator=(const SimpleNucleusState &); + SimpleNucleusState & operator=(const SimpleNucleusState &) = delete; }; } #endif /* DIPSY_SimpleNucleusState_H */ diff --git a/DIPSY/SimpleProton.h b/DIPSY/SimpleProton.h --- a/DIPSY/SimpleProton.h +++ b/DIPSY/SimpleProton.h @@ -1,261 +1,261 @@ // -*- C++ -*- #ifndef DIPSY_SimpleProton_H #define DIPSY_SimpleProton_H // // This is the declaration of the SimpleProton class. // #include "Ariadne/DIPSY/WaveFunction.h" #include "ThePEG/PDT/SimpleBaryonRemnantDecayer.h" namespace DIPSY { using namespace ThePEG; /** * The SimpleProton class represents the unevolved proton wave * function described in terms of an equilatteral triangle of dipoles * with a size distributed as a Gaussian. * * @see \ref SimpleProtonInterfaces "The interfaces" * defined for SimpleProton. */ class SimpleProton: public WaveFunction { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ SimpleProton(); /** * The destructor. */ virtual ~SimpleProton(); //@} public: /** * Get the width of the Gaussian distribution. */ InvEnergy R() const; /** * Get the shift in the average of the Gaussian distribution. */ InvEnergy r0() const; /** * Get the width of the distribution of the angle of the proton. */ inline double angleWidth() const { return theAngleWidth; } /** * Get the width of the distribution of the angle of the proton. */ inline double rapidityWidth() const { return theRapidityWidth; } /** * Get the maximum mass difference between the valence system and * the hadron allowed for collapsing into the original hadron after * the evolution. */ inline Energy collapseTolerance() const { return theCollapseTolerance; } /** * Controls if the ends of the dipoles are connected or not. */ inline int connectOption() const { return theConnected; } public: /** @name Main virtual functions to be overridden in sub-classes. */ //@{ /** * Initialize the wavefunction for the given DipoleEventHandler. */ virtual void initialize(const DipoleEventHandler &); /** * Generate a dipole state according to this wavefunction, given an * event handler and a positive light-cone momentum component. */ virtual DipoleStatePtr generate(const DipoleEventHandler & eh, Energy plus); /** * Return the invariant mass squared of the particle. */ virtual Energy2 m2() const; /** * Generate the shifted gaussian distribution. */ virtual InvEnergy rndShiftGauss() const; /** * Set the corresponding particle. Check that it is actually a * proton or at least a baryon. */ virtual void setParticle(PDPtr); /** * Fix up valens partons if they were not of the correct flavour or * if they should collapse into a hadron. */ virtual void fixValence(Step & step, tPPtr particle, const vector & valence) const; /** * try to collapse the valence gluons into the original * particle. @return true if succeeded. */ virtual bool collapseToProton(Step &, tPPtr particle, const vector &) const; /** * Pick a valence gluon and split it into a quark-diquark pair. */ virtual bool splitValence(Step & step, tPPtr particle, const vector & valence) const; /** * Produce diquark--quark pair. */ cPDPair produceQuarkDiquarkPair() 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); //@} /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The width of the Gaussian distribution. */ InvEnergy theR; /** * The shift in the average of the Gaussian distribution. */ InvEnergy theR0; /** * The width of the gaussian in rapidity for the individual partons. */ double theRapidityWidth; /** * The width of the gaussian in shape for the individual partons. */ double theAngleWidth; /** * Controls if the ends of the dipoles are connected or not. Also * allow for diquark-gluon-quark configurations. */ int theConnected; /** * The maximum mass difference between the valence system and the * hadron allowed for collapsing into the original hadron after the * evolution. */ Energy theCollapseTolerance; /** * A pointer to a RemnantDecayer object which is able to handle the * remnants of the particle. */ Ptr::pointer remdec; private: /** * Excleption class */ struct RemnantException: public Exception {}; /** * Utility function for the interface. */ void setDecayer(RemDecPtr rd); /** * Simple helper function. */ static void swapColourLines(tPPtr gluon); /** * Simple helper function. */ static void insertIntermediate(Step & step, tPPtr parent, tPPtr children); /** * Simple helper function. */ static void eraseIntermediate(Step & step, tPPtr p); /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - SimpleProton & operator=(const SimpleProton &); + SimpleProton & operator=(const SimpleProton &) = delete; }; } #endif /* DIPSY_SimpleProton_H */ diff --git a/DIPSY/SimpleProtonState.h b/DIPSY/SimpleProtonState.h --- a/DIPSY/SimpleProtonState.h +++ b/DIPSY/SimpleProtonState.h @@ -1,69 +1,69 @@ // -*- C++ -*- #ifndef DIPSY_SimpleProtonState_H #define DIPSY_SimpleProtonState_H // // This is the declaration of the SimpleProtonState class. // #include "DipoleState.h" namespace DIPSY { using namespace ThePEG; /** * Here is the documentation of the SimpleProtonState class. */ class SimpleProtonState: public DipoleState { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline SimpleProtonState() {} /** * The standard constructor. */ SimpleProtonState(const DipoleEventHandler & eh, Energy plus, Energy minus, double angleWidth, double rapWidth, int connected, WFInfoPtr wfi, double weight); /** * The copy constructor. */ inline SimpleProtonState(const SimpleProtonState & x) : DipoleState(x) {} /** * The destructor. */ virtual ~SimpleProtonState(); //@} public: /** * 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(); private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - SimpleProtonState & operator=(const SimpleProtonState &); + SimpleProtonState & operator=(const SimpleProtonState &) = delete; }; } #endif /* DIPSY_SimpleProtonState_H */ diff --git a/DIPSY/SmallDipoleAbsorber.h b/DIPSY/SmallDipoleAbsorber.h --- a/DIPSY/SmallDipoleAbsorber.h +++ b/DIPSY/SmallDipoleAbsorber.h @@ -1,204 +1,204 @@ // -*- C++ -*- #ifndef DIPSY_SmallDipoleAbsorber_H #define DIPSY_SmallDipoleAbsorber_H // // This is the declaration of the SmallDipoleAbsorber class. // #include "Ariadne/DIPSY/DipoleAbsorber.h" #include "DipoleState.h" namespace DIPSY { using namespace ThePEG; /** * The SmallDipoleAbsorber class implements a model describing how * non-interacted dipoles will be reabsorbed. The model is based on * the removal of small dipoles. * * @see \ref SmallDipoleAbsorberInterfaces "The interfaces" * defined for SmallDipoleAbsorber. */ class SmallDipoleAbsorber: public DipoleAbsorber { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ SmallDipoleAbsorber(); /** * The destructor. */ virtual ~SmallDipoleAbsorber(); //@} public: /** @name Virtual functions to be overridden. */ //@{ /** * Reabsorb dipoles in the given state. */ virtual void reabsorb( DipoleState &) const; // /** // * Swing so that all non participating nucleons are just the original triangle. // */ // virtual void isolateNonParticipating ( DipoleState & ) const; //@} public: /** * Adds recoils from dipoles that has emitted, trying to account * for emission history. */ void hiddenRecoil(DipoleState &) const; /** * Absorb the provided parton, sharing p_mu according to distance. * swing determines if a swing should be forced if the parton is in a loop. */ virtual void absorbParton (tPartonPtr p, DipoleState & ) const; /** * Swings the two dipoles. */ virtual bool swing (tDipolePtr, tDipolePtr ) const; /** * Absorb the nonordered partons according to sorted. */ template void absorbNonOrderedPartons ( DipoleState &, Sort sort ) const; /** * Sets the parton as sorted, and recursively also all its neighbours. */ template < typename Sort > void setOrdered ( tPartonPtr p, Sort sort ) const; /** * Confirm the dipole as real, and recursively also all its larger neighbours. */ void setDGLAPsafe ( tDipolePtr dip ) const; /** * Decides if a dipole of length r1 can be resolved by a dipole of length r2. */ bool checkDGLAPsafe ( InvEnergy r1, InvEnergy r2 ) const; /** * compoensate for the 1/r^2 vs 1/r^4 weights by absorbing small dipoles created * with too high weight. */ void absorbSmallDipoles ( DipoleState & ) const; /** * Set the parton as y ordered, and recursively also all its ordered neighbours. */ void setYOrdered ( tPartonPtr p ) const; /** * Set the parton as p- ordered, and recursively also all its ordered neighbours. */ void setMinusOrdered ( tPartonPtr p ) const; /** * Absorb the parton, and all partons in the direction of smaller dipoles. * Starts with the smallest dipole at the end of the chain. */ void DGLAPabsorb ( tPartonPtr p, DipoleState & ) 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); //@} /** * 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * Recoils the two partons, as from an emission. pT and y changed. * p+/p- conserved for right/left moving particles respectively. y changes. * ymax is evolved rapidity of the state, to know when the partons recoil * too far in rapidity. */ void recoil(tPartonPtr p1, tPartonPtr p2, double ymax) const; /** * Marks the valence partons as interacted, that is non virtual. */ void realValence(DipoleState &) const; /** * Finds the largest non DGLAPsafe dipole among /a dipoles that is * not in a loop that should be absorbed. Returns an empty pointer * if no nonsafe dipoles that shouldnt be absorb were found. */ DipolePtr largestNonsafeDipole(list dipoles, DipoleState &) const; /** * Absorb the loop that the dipole /a d is part of. */ void absorbLoop( DipolePtr d, DipoleState &) const; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - SmallDipoleAbsorber & operator=(const SmallDipoleAbsorber &); + SmallDipoleAbsorber & operator=(const SmallDipoleAbsorber &) = delete; }; } #endif /* DIPSY_SmallDipoleAbsorber_H */ diff --git a/DIPSY/Swinger.h b/DIPSY/Swinger.h --- a/DIPSY/Swinger.h +++ b/DIPSY/Swinger.h @@ -1,233 +1,233 @@ // -*- C++ -*- #ifndef DIPSY_Swinger_H #define DIPSY_Swinger_H // // This is the declaration of the Swinger class. // #include "ThePEG/Handlers/HandlerBase.h" #include "Parton.h" #include "Swinger.fh" #include "Dipole.fh" namespace DIPSY { using namespace ThePEG; /** * The Swinger class is responsible for generating and performing a * swing for a dipole. This base class does the standard thing. Any * non-standard thing must be implemented in a sub-class overriding * the generateRec() and/or recombine() functions. * * @see \ref SwingerInterfaces "The interfaces" * defined for Swinger. */ class Swinger: public HandlerBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline Swinger(): theLambda(1.0) {} /** * The copy constructor. */ inline Swinger(const Swinger & x) : HandlerBase(x), theLambda(x.theLambda) {} /** * The destructor. */ virtual ~Swinger(); //@} public: /** @name Virtual functions which may be overridden by sub-classes. */ //@{ /** * Generate a swing for FS colour reconnection. */ virtual void generateFS(Dipole & dipole, double miny, double maxy) const; /** * The FS amplitude for swinging, taking time and rapidity distance into account */ virtual double swingAmpFS(const pair, const pair, InvEnergy2 time) const; /** * Calculate the distance between partons entering in the FS swing. */ virtual InvEnergy2 swingDistanceFS(const Parton & p1, const Parton & p2, InvEnergy2 time) const; /** * The FS amplitude for swinging, taking distances calculated by * swingDistanceFS(). */ virtual double swingAmpFS(InvEnergy2 a, InvEnergy2 b, InvEnergy2 c, InvEnergy2 d) const; /** * Generate a swing for the given \a dipole in the given rapidity * interval [\a miny,\a maxy]. If \a force is true, always generate * a swing, otherwise only check if a swing is possible with dipoles * which are new or has changed. */ virtual void generate(Dipole & dipole, double miny, double maxy, bool force) const; /** * Try really hard to generate a swing. But if larger rapidity gap * than /a ymax, then don't bother. /a ymax = 0 means no limit. */ virtual bool forceGenerate(Dipole & d, double ymax) const; /** * Perform a recombination previously generated by generateRec(). */ virtual void recombine(Dipole & dipole) const; /** * Perform a recombination previously generated by swingFS. Does not * produce new dipoles, just recombines the current ones. */ virtual void recombineFS(Dipole & dipole) const; /** * The probability per rapidity for a swing to happen between the two dipoles. */ virtual double swingAmp(const Dipole & d1, const Dipole & d2) const; /** * The probability per rapidity for a swing to happen between the two dipoles. */ virtual double swingAmp(const pair, const pair) const; /** * Tests the distribution in generated y - miny for a swing between two dipoles. */ virtual void testGenerate(set & dips,double miny, double maxy); //inline functions /** * get lambda. */ inline double lambda() const { return theLambda; } /** * set lambda. */ inline void lambda(double x) { theLambda = x; } //@} protected: /** * Checks that a swing doesnt push any parton above maxy, using the pT * definition that depends on the two colour neighbours. * Internal function. */ virtual bool checkMaxY(DipolePtr dip, DipolePtr swingDip, double maxY ) 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); //@} /** * 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. */ inline virtual IBPtr clone() const { return new_ptr(*this); } /** 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 { return new_ptr(*this); } //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). protected: /** * If testing mode is active. /CF */ bool thestMode; /** * Exception indicating inconsistent colour lines. */ struct ColourIndexException: public Exception {}; /** * Exception swinging decayed dipole. */ struct SwingConsistencyException: public Exception {}; private: /** * Controls how fast the swings are. default is 1. */ double theLambda; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - Swinger & operator=(const Swinger &); + Swinger & operator=(const Swinger &) = delete; }; } #endif /* DIPSY_Swinger_H */ diff --git a/DIPSY/TotalXSecAnalysis.h b/DIPSY/TotalXSecAnalysis.h --- a/DIPSY/TotalXSecAnalysis.h +++ b/DIPSY/TotalXSecAnalysis.h @@ -1,132 +1,132 @@ // -*- C++ -*- #ifndef DIPSY_TotalXSecAnalysis_H #define DIPSY_TotalXSecAnalysis_H // // This is the declaration of the TotalXSecAnalysis class. // #include "Ariadne/DIPSY/DipoleAnalysisHandler.h" namespace DIPSY { using namespace ThePEG; /** * TotalXSecAnalysis class calculates the total cross section in the * presampling phase of the DipoleEventHandler. * * @see \ref TotalXSecAnalysisInterfaces "The interfaces" * defined for TotalXSecAnalysis. */ class TotalXSecAnalysis: public DIPSY::DipoleAnalysisHandler { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ TotalXSecAnalysis(); /** * The destructor. */ virtual ~TotalXSecAnalysis(); //@} public: /** @name Standard virtual functions inherited from the classes. */ //@{ /** * Initialize the analysis object. */ virtual void initialize(); /** * Analyze a given collision. Given left- and right-moving dipole * states, \a dl and \a dr, an ImpactParameters object, \a b, a * cross section object, \a xsec, and the total summed dipole-dipole * scattering probabilities, \a fsum, and the total \a weight * associated with the generated states. */ virtual void analyze(const DipoleState & dl, const DipoleState & dr, const ImpactParameters & b, const DipoleXSec & xsec, double fsum, CrossSection weight); /** * Finalize the analysis, (compute statistics etc.). \a neve is the * number of times analyze() has been called since last * initialize(). */ virtual void finalize(long neve); //@} /** @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; //@} private: /** * The sum of the cross sections seen so far. */ CrossSection sum; /** * The sum of the squared cross sections seen so far. */ CrossSection2 sum2; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - TotalXSecAnalysis & operator=(const TotalXSecAnalysis &); + TotalXSecAnalysis & operator=(const TotalXSecAnalysis &) = delete; }; } #endif /* DIPSY_TotalXSecAnalysis_H */ diff --git a/DIPSY/VectorMesonBase.h b/DIPSY/VectorMesonBase.h --- a/DIPSY/VectorMesonBase.h +++ b/DIPSY/VectorMesonBase.h @@ -1,164 +1,164 @@ // -*- C++ -*- #ifndef DIPSY_VectorMesonBase_H #define DIPSY_VectorMesonBase_H // // This is the declaration of the VectorMesonBase class. // #include "Ariadne/DIPSY/WaveFunction.h" namespace DIPSY { using namespace ThePEG; /** * The VectorMesonBase class inherits from WaveFunction and is the * base class of all vector meson wave functions. It includes abstract * functions for different polarization and helicity components. * * @see \ref VectorMesonBaseInterfaces "The interfaces" * defined for VectorMesonBase. */ class VectorMesonBase: public WaveFunction { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline VectorMesonBase() : theMaxFlav(4), qmass(7, -1.0*GeV) {} /** * The copy constructor. */ inline VectorMesonBase(const VectorMesonBase & x) : WaveFunction(x), theMaxFlav(x.theMaxFlav), qmass(x.qmass) {} /** * The destructor. */ virtual ~VectorMesonBase(); //@} public: /** @name Abstract functions for different wave function components. */ //@{ /** * Return (the absolute value of) the wave function for the given * polarization \a pol, quark and antiquark helicities, \a h and \a * hbar, quark flavour \a flav, energy fraction \a z and transverse * size \a r. */ virtual Energy psi(int pol, int h, int hbar, int flav, InvEnergy r, double z) = 0; /** * Return the square of the wavefunction summed over flavours and * helicities. */ virtual Energy2 psi2(InvEnergy r, double z); //@} public: /** @name Simple access functions. */ //@{ /** * Get the maxumim number of flavours considered. If negative only * the corresponding flavour will be considered. */ inline int maxFlav() const { return theMaxFlav; } //@} 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(); // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). protected: /** @name Standard Interfaced functions. */ //@{ /** * Initialize this object after the setup phase before saving an * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ virtual void doinit(); /** * Initialize this object. Called in the run phase just before * a run begins. */ inline virtual void doinitrun() { WaveFunction::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() { WaveFunction::dofinish(); } //@} private: /** * The maxumim number of flavours considered. If negative only the * corresponding flavour will be considered. */ int theMaxFlav; protected: /** * The quark masses to be used (zero'th component is always ignored). */ vector qmass; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - VectorMesonBase & operator=(const VectorMesonBase &); + VectorMesonBase & operator=(const VectorMesonBase &) = delete; }; } #endif /* DIPSY_VectorMesonBase_H */ diff --git a/DIPSY/VirtualPhoton.h b/DIPSY/VirtualPhoton.h --- a/DIPSY/VirtualPhoton.h +++ b/DIPSY/VirtualPhoton.h @@ -1,283 +1,283 @@ // -*- C++ -*- #ifndef DIPSY_VirtualPhoton_H #define DIPSY_VirtualPhoton_H // // This is the declaration of the VirtualPhoton class. // #include "Ariadne/DIPSY/VectorMesonBase.h" namespace DIPSY { using namespace ThePEG; /** * The VirtualPhoton class represents the perturbative * quark--anti-quark dipole wave function of a virtual photon with a * given virtuality. * * @see \ref VirtualPhotonInterfaces "The interfaces" * defined for VirtualPhoton. */ class VirtualPhoton: public VectorMesonBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline VirtualPhoton() : theQ2(0.0*GeV2), theShrinkR(0.0*InvGeV),thePolarisation(0), theVMDLightA(0.0), theVMDLightR(0.0*InvGeV), theVMDLightW(0.0*InvGeV), theVMDCharmA(0.0), theVMDCharmR(0.0*InvGeV), theVMDCharmW(0.0*InvGeV), rMax(ZERO), r2Psi2Int(ZERO), r2Psi2Max(ZERO) {} /** * The copy constructor. */ inline VirtualPhoton(const VirtualPhoton & x) : VectorMesonBase(x), theQ2(x.theQ2), theShrinkR(x.theShrinkR), thePolarisation(x.thePolarisation), theVMDLightA(x.theVMDLightA), theVMDLightR(x.theVMDLightR), theVMDLightW(x.theVMDLightW), theVMDCharmA(x.theVMDCharmA), theVMDCharmR(x.theVMDCharmR), theVMDCharmW(x.theVMDCharmW), rMax(x.rMax), r2Psi2Int(x.r2Psi2Int), r2Psi2Max(x.r2Psi2Max) {} /** * The destructor. */ virtual ~VirtualPhoton(); //@} public: /** @name Main virtual functions to be overridden in sub-classes. */ //@{ /** * Initialize the wavefunction for the given DipoleEventHandler. */ virtual void initialize(const DipoleEventHandler &); /** * Generate a dipole state according to this wavefunction, given an * event handler and a positive light-cone momentum component. */ virtual DipoleStatePtr generate(const DipoleEventHandler & eh, Energy plus); /** * Generate a dipole state according to this wavefunction, given an * event handler and a positive light-cone momentum component. */ virtual DipoleStatePtr generate2(const DipoleEventHandler & eh, Energy plus); /** * Return (the absolute value of) the wave function for the given * polarization \a pol, quark and antiquark helicities, \a h and \a * hbar, quark flavour \a flav, energy fraction \a z and transverse * size \a r. */ virtual Energy psi(int pol, int h, int hbar, int flav, InvEnergy r, double z); /** * The purely perturbative version of the wavefunction. */ virtual Energy pertPsi(int pol, int h, int hbar, int flav, InvEnergy r, double z); /** * r*2*pi*(sum_i Psi_i^2(r,z)) with sum i over helicities. this describes * the weight to get a dipole with certain r and z. **/ virtual Energy sumPsi2(InvEnergy r, double z); /** * returns the correction on the wavefunction due to vector meson resonance * at a given dipole size for a given quark flavour. **/ virtual double VMDCorr(InvEnergy r, int flav); /** * Return the invariant mass squared of the particle. */ virtual Energy2 m2() const; //@} /** * The virtuality of the photon. */ inline Energy2 Q2() const { return theQ2; } /** * The confinement range. */ inline InvEnergy shrinkR() const { return theShrinkR; }; /** * The amplitude of the vector meson resonance for light quarks. */ inline double VMDLightA() const { return theVMDLightA; }; /** * A flag showing which polarisation the photon has. */ inline int polarisation() const { return thePolarisation; }; /** * The typical dipole size of the vector meson resonance for light quarks. */ inline InvEnergy VMDLightR() const { return theVMDLightR; }; /** * The width in dipole size of the vector meson resonance for light quarks. */ inline InvEnergy VMDLightW() const { return theVMDLightW; }; /** * The amplitude of the vector meson resonance for charm quarks. */ inline double VMDCharmA() const { return theVMDCharmA; }; /** * The typical dipole size of the vector meson resonance for charm quarks. */ inline InvEnergy VMDCharmR() const { return theVMDCharmR; }; /** * The width in dipole size of the vector meson resonance for charm quarks. */ inline InvEnergy VMDCharmW() const { return theVMDCharmW; }; /** * Set the corresponding particle. Check that it is actually a * photon. */ virtual void setParticle(PDPtr); 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. */ inline virtual IBPtr clone() const { return new_ptr(*this); } /** 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 { return new_ptr(*this); } //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The virtuality of the photon. */ Energy2 theQ2; /** * Parameter for the confinement range */ InvEnergy theShrinkR; /** * 0: both T and L, 1: Transverse only, 2: Longitudinal only */ int thePolarisation; /** * Parameter for the vector meson resonance for light and charm quarks. */ double theVMDLightA; InvEnergy theVMDLightR; InvEnergy theVMDLightW; double theVMDCharmA; InvEnergy theVMDCharmR; InvEnergy theVMDCharmW; /** * The maximum dipole size that will be considered. */ InvEnergy rMax; /** * The integral of r^2 times the sum of the square of all wavefunctions, up to rMax. **/ InvEnergy2 r2Psi2Int; /** * The max of r^2 times the sum of the square of all the wavefunctions, up to rMax. **/ InvEnergy r2Psi2Max; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - VirtualPhoton & operator=(const VirtualPhoton &); + VirtualPhoton & operator=(const VirtualPhoton &) = delete; }; } #endif /* DIPSY_VirtualPhoton_H */ diff --git a/DIPSY/WFInfo.h b/DIPSY/WFInfo.h --- a/DIPSY/WFInfo.h +++ b/DIPSY/WFInfo.h @@ -1,117 +1,117 @@ // -*- C++ -*- #ifndef DIPSY_WFInfo_H #define DIPSY_WFInfo_H // // This is the declaration of the WFInfo class. // #include "ThePEG/Config/ThePEG.h" #include "WFInfo.fh" #include "WaveFunction.fh" #include "ThePEG/EventRecord/EventInfoBase.h" #include "ThePEG/EventRecord/Particle.h" namespace DIPSY { using namespace ThePEG; /** * WFInfo is the base class for additional information about the * WaveFunction used for constructing an intitial Dipole state. This * base class keeps information about the size, r, of the initial * DipoleSystem. The class does not have any virtual * functions. Instead dynaic_cast should be used to access information * from sub-classes. */ class WFInfo: public ThePEG::EventInfoBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor giving the wave function that produces * this object and the size as argument. */ inline WFInfo(tcWaveFunctionPtr wfin = tcWaveFunctionPtr(), InvEnergy rini = 0.0*InvGeV) : theWF(wfin), theR(rini) {} /** * The destructor. */ virtual ~WFInfo(); //@} public: /** * Get the wave function that produced this info object. */ inline const WaveFunction & wf() const { return *theWF; } /** * The initial size of the DipoleSystem. */ inline InvEnergy r() const { return theR; } /** * Return the WFInfo object stored with the given particle. */ static tcWFInfoPtr getWFInfo(const Particle & particle); 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(); private: /** * The wave function that produced this info object. */ tcWaveFunctionPtr theWF; /** * The initial size of the DipoleSystem. */ InvEnergy theR; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - WFInfo & operator=(const WFInfo &); + WFInfo & operator=(const WFInfo &) = delete; }; } #endif /* DIPSY_WFInfo_H */ diff --git a/DIPSY/WaveFunction.h b/DIPSY/WaveFunction.h --- a/DIPSY/WaveFunction.h +++ b/DIPSY/WaveFunction.h @@ -1,154 +1,154 @@ // -*- C++ -*- #ifndef DIPSY_WaveFunction_H #define DIPSY_WaveFunction_H // // This is the declaration of the WaveFunction class. // #include "ThePEG/Handlers/HandlerBase.h" #include "ThePEG/PDT/ParticleData.h" #include "WaveFunction.fh" #include "DipoleState.h" #include "DipoleEventHandler.fh" namespace DIPSY { using namespace ThePEG; /** * WaveFunction is the base class for wavefunction objects capable of * generating initial DipoleState objects. * * @see \ref WaveFunctionInterfaces "The interfaces" * defined for WaveFunction. */ class WaveFunction: public HandlerBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline WaveFunction() : theEventHandler(tcDipoleEventHandlerPtr()), theParticle(PDPtr()) {} /** * The copy constructor. */ inline WaveFunction(const WaveFunction & x) : HandlerBase(x), theEventHandler(x.theEventHandler), theParticle(x.theParticle) {} /** * The destructor. */ virtual ~WaveFunction(); //@} public: /** @name Main virtual functions to be overridden in sub-classes. */ //@{ /** * Initialize the wavefunction for the given DipoleEventHandler. */ virtual void initialize(const DipoleEventHandler &); /** * Generate a dipole state according to this wavefunction, given an * event handler and a positive light-cone momentum component. */ virtual DipoleStatePtr generate(const DipoleEventHandler & eh, Energy plus) = 0; /** * Fix up valens partons if they were not of the correct flavour or * if they should collapse into a hadron. */ virtual void fixValence(Step & step, tPPtr particle, const vector & valence) const; /** * Return the invariant mass squared of the particle. */ virtual Energy2 m2() const = 0; //@} /** * The DipoleEventHandler in charge of the generation. */ inline tcDipoleEventHandlerPtr eventHandler() const { return theEventHandler; } /** * Get the corresponding particle. */ inline tcPDPtr particle() const { return theParticle; } /** * Set the corresponding particle. May be overridden by sub classes * to check the particle is relevant for the particular wave * function. */ virtual void setParticle(PDPtr); 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(); // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The DipoleEventHandler in charge of the generation. */ tcDipoleEventHandlerPtr theEventHandler; /** * The corresponding particle. */ PDPtr theParticle; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - WaveFunction & operator=(const WaveFunction &); + WaveFunction & operator=(const WaveFunction &) = delete; }; } #endif /* DIPSY_WaveFunction_H */ diff --git a/DipoleCascade/CascadeBase.h b/DipoleCascade/CascadeBase.h --- a/DipoleCascade/CascadeBase.h +++ b/DipoleCascade/CascadeBase.h @@ -1,216 +1,216 @@ // -*- C++ -*- #ifndef ARIADNE_CascadeBase_H #define ARIADNE_CascadeBase_H // // This is the declaration of the CascadeBase class. // #include "Ariadne/Config/CloneBase.h" #include "CascadeBase.fh" #include "DipoleState.fh" #include "Ariadne/DipoleCascade/CascadeHandler.h" namespace Ariadne { using namespace ThePEG; /** * CascadeBase is the base class of all Partons, Emitters and * DipoleState classes in the Ariadne dipole cascade classes. It keeps * track of the DioleState to which an object belongs, and has also a * pointer to the AriadneCascade object administering the cascade. */ class CascadeBase: public CloneBase { public: /** * The DipoleState is a friend. */ friend class DipoleState; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor has an optional pointer to the * CascadeHandler in charge as argument. */ inline CascadeBase(tHandlerPtr hdl = tHandlerPtr()); /** * The copy constructor. */ inline CascadeBase(const CascadeBase &); /** * The destructor. */ inline virtual ~CascadeBase(); //@} protected: /** @name Functions relating to the DipoleState and CascadeHandler * to which this belongs. */ //@{ /** * Get the Ariadne::CascadeHandler in charge of the current generation. */ inline tHandlerPtr handler() const; /** * Set the Ariadne::CascadeHandler in charge of the current generation. */ inline void handler(tHandlerPtr); /** * Get the DipoleState to which this Dipole belongs. */ inline tDipoleStatePtr state() const; /** * Set the DipoleState to which this Dipole belongs. */ inline void state(tDipoleStatePtr); /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} public: /** @name Functions determining if the object has been changed since the last generation. */ //@{ /** * If true, this object has been modified since the last round of * generating emissions. */ inline bool touched() const; /** * Signal that this object has been modified. */ inline void touch(); /** * Signal that all possible emissions involving this object has been * generated. */ inline void untouch(); //@} 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(); private: /** * The Ariadne::CascadeHandler in charge of the current generation. */ tHandlerPtr theHandler; /** * The DipoleState to which this Dipole belongs. */ tDipoleStatePtr theState; /** * If true, this object has been modified since the last round of * generating emissions. */ bool isTouched; private: /** * The static object used to initialize the description of this class. * Indicates that this is an abstract class with persistent data. */ static AbstractClassDescription initCascadeBase; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - CascadeBase & operator=(const CascadeBase &); + CascadeBase & operator=(const CascadeBase &) = delete; }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of CascadeBase. */ template <> struct BaseClassTrait { /** Typedef of the first base class of CascadeBase. */ typedef Ariadne::CloneBase NthBase; }; /** This template specialization informs ThePEG about the name of * the CascadeBase class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Ariadne::CascadeBase"; } /** Return the name of the shared library be loaded to get * access to the CascadeBase class and every other class it uses * (except the base class). */ static string library() { return "libArCascade.so"; } }; /** @endcond */ } #include "CascadeBase.icc" #ifndef ThePEG_TEMPLATES_IN_CC_FILE // #include "CascadeBase.tcc" #endif #endif /* ARIADNE_CascadeBase_H */ diff --git a/DipoleCascade/CascadeHandler.h b/DipoleCascade/CascadeHandler.h --- a/DipoleCascade/CascadeHandler.h +++ b/DipoleCascade/CascadeHandler.h @@ -1,494 +1,494 @@ // -*- C++ -*- #ifndef ARIADNE_CascadeHandler_H #define ARIADNE_CascadeHandler_H // // This is the declaration of the CascadeHandler class. // #include "Ariadne/Config/Ariadne.h" #include "ThePEG/Handlers/CascadeHandler.h" #include "ThePEG/Utilities/Triplet.h" #include "ThePEG/StandardModel/AlphaSBase.h" #include "CascadeHandler.fh" #include "MECorrBase.fh" #include "ReweightBase.fh" #include "DipoleState.fh" namespace Ariadne { using namespace ThePEG; /** * The CascadeHandler class inherits form the ThePEG::CascadeHandler * base class and implements the Dipole Cascade Model for partonic * cascades. * * @see \ref CascadeHandlerInterfaces "The interfaces" * defined for CascadeHandler. */ class CascadeHandler: public ThePEG::CascadeHandler { public: /** * A vector of matrix element correction objects. */ typedef vector MECVector; /** * Enum different options for running \f$\alpha_s\f$. */ enum RunningOption { externalRunning = -1, /**< Use the \f$\alpha_s\f$ specified in the current StandardModel object. */ noRunning = 0, /**< Use a fixed \f$\alpha_s\f$ specified by alpha0(). */ simpleRunning = 1, /**< Use simple leading order running with \f$\Lambda_{QCD}\f$ given by lambdaQCD() */ internalRunning = 2 /**< Use internal AlphaSBase object in theInternalAlphaS for the running. */ }; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ CascadeHandler(); /** * The copy constructor. */ CascadeHandler(const CascadeHandler &); /** * The destructor. */ virtual ~CascadeHandler(); //@} public: /** * The main function to be overwritten by sub-classes. It is called * by handle() after storing some information which is then * available through simple access functions. */ virtual void cascade(); /** * The CascadeHandler can be used inside the process generation to do * so-called CKKW reweighting of the hard sub-process. In this case * this function is called after information about the sub-process is * made available through the LastXCombInfo base class. Only the * function belonging to the primary CascadeHandler for the event to * be generated is called. This default implementation of the function * simply return one. The current sub-process is mixed together with * other processes with a multiplicity of outgoing particles between * \a minMult and \a maxMult. * @throws CKKWMultiplicityException if the minMult > maxMult or if * the number of outgoing particle is outside the specified range. */ virtual double reweightCKKW(int minMult, int maxMult); /** * Check if the particles in the dipole state passes the cuts from * lastXComb. */ bool passCuts(tcDipoleStatePtr state); public: /** @name Functions relating to the running coupling. */ //@{ /** * Strategy for \f$\alpha_S\f$. 0 means constant a constant * \f$\alpha_S\f$ with a value given by alpha0(). 1 means a leading * order running \f$\alpha_S\f$ with a \f$\Lambda_{QCD}\f$ given by * lambdaQCD(). -1 means take whatever is specified in the current * StandardModelBase object. */ inline RunningOption runningCoupling() const; /** * The constant \f$\alpha_S\f$ to be used if runningCoupling() is 0. */ inline double alpha0() const; /** * The \f$\Lambda_{QCD}\f$ to use in the one loop running * \f$\alpha_S\f$ if runningCoupling is 1 */ inline Energy lambdaQCD() const; /** * An internal \f$\alpha_S\f$ object to be used if runningCoupling() * is internalRunning. */ inline Ptr::const_pointer internalAlphaS() const; /** * The constant \f$\alpha_{EM}\f$ to be used. If zero, use whatever * is specified in the current StandardModelBase object. */ inline double alphaEM0() const; /** * The number of different colour indices available to dipoles. */ inline int nCol() const; /** * The number of possible flavours in a \f$g\to q\bar{q}\f$ splitting. */ inline int nFlav() const; //@} /** * Check if photon emission are switched on or off. */ inline bool photonEmissions() const; public: /** * The cutoff in invariant transverse momentum for QCD emissions. */ inline Energy pTCut() const; /** * The cutoff in invariant transverse momentum for QED emissions. */ inline Energy pTCutEM() const; /** * The inverse extension of a hadron remnant. */ inline Energy softMu() const; /** * The dimension assumed for the extension of a hadron remnant. */ inline double softAlpha() const; /** * The dimension assumed for the extension of a perturbative remnant. */ inline double hardAlpha() const; /** * The power in the suppression of radiation from extended dipoles. */ inline double beta() const; /** * Return the vector of available reweighting objects. */ inline const vector & reweighters() const { return theReweighters; } /** * Return the vector of available matrix element reweighting objects. */ inline const MECVector & MECorrectors() const; /** * The maximum number of allowed emission in the cascade. */ inline int maxEmissions() 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); //@} /** * 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: /** * Exception class used if the outgoing multiplicity is out of range * or the maximum multiplicity is larger than the minimum in * reweightCKKW. */ struct CKKWMultiplicityException: Exception {}; /** * Exception class used if the dipole state is not self consistant at * any stage of the cascade. */ struct IntegretyException: Exception {}; 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. */ 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 pointers 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(); /** * Return true if this object needs to be initialized before all * other objects because it needs to extract PDFs from the event * file. This version will return true if runningCoupling() returns * internalRunning and no internalAlphaS() object has been given. */ virtual bool preInitialize() const; //@} private: /** * Function used by the interface. */ Energy minPTCut() const; /** * Function used by the interface. */ Energy maxLambdaQCD() const; private: /** * Strategy for \f$\alpha_S\f$. 0 means constant a constant * \f$\alpha_S\f$ with a value given by alpha0(). 1 means a leading * order running \f$\alpha_S\f$ with a \f$\Lambda_{QCD}\f$ given by * lambdaQCD(). -1 means take whatever is specified in the current * StandardModelBase object. */ RunningOption theRunningCoupling; /** * The constant \f$\alpha_S\f$ to be used if runningCoupling() is * noRunning. */ double theAlpha0; /** * The \f$\Lambda_{QCD}\f$ to use in the one loop running * \f$\alpha_S\f$ if runningCoupling is simpleRunning. */ Energy theLambdaQCD; /** * An internal \f$\alpha_S\f$ object to be used if runningCoupling() * is internalRunning. */ Ptr::pointer theInternalAlphaS; /** * The cutoff in invariant transverse momentum for QCD emissions. */ Energy thePTCut; /** * The constant \f$\alpha_{EM}\f$ to be used. If zero, use whatever * is specified in the current StandardModelBase object. */ double theAlphaEM0; /** * The cutoff in invariant transverse momentum for QED emissions. */ Energy thePTCutEM; /** * The number of different colour indices available to dipoles. */ int theNCol; /** * The number of possible flavours in a \f$g\to q\bar{q}\f$ splitting. */ int theNFlav; /** * Switch to turn on and off photon emission in the cascade. */ bool thePhotonEmissions; /** * The inverse extension of a hadron remnant. */ Energy theSoftMu; /** * The dimension assumed for the extension of a hadron remnant. */ double theSoftAlpha; /** * The dimension assumed for the extension of a hard remnant. */ double theHardAlpha; /** * The power in the suppression of radiation from extended dipoles. */ double theBeta; /** * A list of reweighting objects which may be applied to dipole * emissions. */ vector theReweighters; /** * A list of leading-order matrix-element correction objects which * may be applied to dipole emissions. */ MECVector theMECorrectors; /** * The maximum number of emissions allowed in the cascade. */ int theMaxEmissions; /** * A map containing the states generated by reweight CKKW. The map * assiciates an XComb to a struct containing the dipole state, the * rotation, the last pt2 and a boolean which specifies if the state * has the maximum parton multiplicity or not. */ struct CKKWState { DipoleStatePtr state; LorentzRotation rotation; Energy2 pt2; bool maxMult; }; map theCKKWMap; private: /** * The static object used to initialize the description of this class. * Indicates that this is a concrete class with persistent data. */ static ClassDescription initCascadeHandler; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - CascadeHandler & operator=(const CascadeHandler &); + CascadeHandler & operator=(const CascadeHandler &) = delete; }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of CascadeHandler. */ template <> struct BaseClassTrait { /** Typedef of the first base class of CascadeHandler. */ typedef CascadeHandler NthBase; }; /** This template specialization informs ThePEG about the name of * the CascadeHandler class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Ariadne::CascadeHandler"; } /** Return the name of the shared library be loaded to get * access to the CascadeHandler class and every other class it uses * (except the base class). */ static string library() { return "libArCascade.so"; } }; /** @endcond */ } #include "CascadeHandler.icc" #ifndef ThePEG_TEMPLATES_IN_CC_FILE // #include "CascadeHandler.tcc" #endif #endif /* ARIADNE_CascadeHandler_H */ diff --git a/DipoleCascade/DISDipole.h b/DipoleCascade/DISDipole.h --- a/DipoleCascade/DISDipole.h +++ b/DipoleCascade/DISDipole.h @@ -1,290 +1,290 @@ // -*- C++ -*- #ifndef ARIADNE_DISDipole_H #define ARIADNE_DISDipole_H // // This is the declaration of the DISDipole class. // #include "ExtendedDipole.h" #include "DISDipole.fh" #include "HardRemnant.fh" namespace Ariadne { using namespace ThePEG; /** * The DISDipole class represents the QCD dipole that performs the first * emission in a DIS process. */ class DISDipole: public ExtendedDipole { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline DISDipole(); /** * The copy constructor. */ inline DISDipole(const DISDipole &); /** * The destructor. */ virtual ~DISDipole(); //@} public: /** @name The main virtual functions to be overridden by sub-classes. */ //@{ /** * Initialize this dipole. Given then incoming and outgoing partons, * \a ip and \a op, set up this dipole. If \a respectScales is true * the dipoles will get a maximum scale set by the minimum * scale of the original partons. */ virtual void init(tParPtr ip, tParPtr op, bool respectScale = false); /** * Generate the variables needed to perform an emission. The * variables should be saved so that the emission can be performed * by a subsequent call to perform(). * * @param pt2min the minimum transverse momentum squared allowed. * * @param pt2max the minimum transverse momentum squared allowed. * * @return the transverse momentum squared of the generated * emission. If pt2min is returned, no emission was generated. */ virtual Energy2 generate(Energy2 pt2min, Energy2 pt2max); /** * Perform an emission. Use the information previously generated by * generate(Energy2,Energy2) to perform the corresponding emission. * * @return the parton which is considered to have been emitted, or * the null pointer if the emission failed. */ virtual tParPtr perform(); //@} protected: /** * Generate a gluon emission. Saves x1, x3 and rotation angle in * genVar. * * @param pt2min the minimum transverse momentum squared allowed. * * @param pt2max the minimum transverse momentum squared allowed. */ virtual void genG(Energy2 pt2min, Energy2 pt2max); /** * Implemented to disable the quark anti-quark splitting. */ virtual void genQ(Energy2 pt2min, Energy2 pt2max); /** * Generate a gluon emission from a dipole between the remnant and the * hard remant. Saves rapidity in genVar. Uses the perform method for * initial state gluons to perform the emission. * * @param pt2min the minimum transverse momentum squared allowed. * * @param pt2max the minimum transverse momentum squared allowed. */ void genDISG(Energy2 pt2min, Energy2 pt2max); /** * Generate boson gluon fusion. Saves xi, z and the quark mass in GeV * in genVar. * * @param pt2min the minimum transverse momentum squared allowed. * * @param pt2max the minimum transverse momentum squared allowed. */ void genBGF(Energy2 pt2min, Energy2 pt2max); /** * Perform an initial state quark emission. This contains the common * parts of performSeaQ and performQtoGQ. This is an extended version * that takes into account hard remnants. */ virtual tParPtr performInitialQ(); /** * Calculate y = P.q/P.l, where q, P and l are the momentum of the * virtual photon, incoming proton and incoming lepton respectivly. */ double y(); public: /** @name Simple access functions. */ //@{ /** * The hard remnant. */ inline tHardRemPtr hardRem() const; /** * The soft remnant. */ inline tSoftRemPtr softRem() const; /** * Set the hard remnant. */ inline void hardRem(tHardRemPtr); /** * Set the soft remnant. */ inline void softRem(tSoftRemPtr); //@} private: /** * The hard remnant. */ tHardRemPtr theHardRem; /** * The soft remnant. */ tSoftRemPtr theSoftRem; /** * The cached y value. */ double theY; protected: /** @name Functions relating to the DipoleState to which this belongs. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual ClonePtr clone() const; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} 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(); public: /** * Print out debugging information on std::cerr. */ virtual void debugme() const; private: /** * The static object used to initialize the description of this class. * Indicates that this is a concrete class with persistent data. */ static ClassDescription initDISDipole; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - DISDipole & operator=(const DISDipole &); + DISDipole & operator=(const DISDipole &) = delete; }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of DISDipole. */ template <> struct BaseClassTrait { /** Typedef of the first base class of DISDipole. */ typedef Ariadne::ExtendedDipole NthBase; }; /** This template specialization informs ThePEG about the name of * the DISDipole class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Ariadne::DISDipole"; } /** * The name of a file containing the dynamic library where the class * DISDipole is implemented. It may also include several, space-separated, * libraries if the class DISDipole depends on other classes (base classes * excepted). In this case the listed libraries will be dynamically * linked in the order they are specified. */ static string library() { return "libArCascade.so"; } }; /** @endcond */ } #include "DISDipole.icc" #ifndef ThePEG_TEMPLATES_IN_CC_FILE // #include "DISDipole.tcc" #endif #endif /* ARIADNE_DISDipole_H */ diff --git a/DipoleCascade/DYCorr.h b/DipoleCascade/DYCorr.h --- a/DipoleCascade/DYCorr.h +++ b/DipoleCascade/DYCorr.h @@ -1,158 +1,158 @@ // -*- C++ -*- #ifndef ARIADNE_DYCorr_H #define ARIADNE_DYCorr_H // // This is the declaration of the DYCorr class. // #include "Ariadne/DipoleCascade/MECorrBase.h" #include "DYCorr.fh" namespace Ariadne { using namespace ThePEG; /** * DYCorr is a class implementing the first order matrix element * corrections to the W/Z/gamma production in hadron collisions. * * @see \ref DYCorrInterfaces "The interfaces" * defined for DYCorr. */ class DYCorr: public MECorrBase { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline DYCorr(); /** * The copy constructor. */ inline DYCorr(const DYCorr &); /** * The destructor. */ virtual ~DYCorr(); //@} public: /** * 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(); public: /** * Check if the matrix-element correction can be applied to the * given \a dipole in the given dipole \a state. * @return true if this correction is applicable, false otherwise. */ virtual bool canHandle(tcEmiPtr dipole, tcDipoleStatePtr state) const; /** * Return the matrix-element correction weight associated with an * emission of a parton with PDG number \a id and mass emass from * the given dipole, \a dip. The transverse momentum squared, \a * pt2, and the vector of doubles that will be stored in genVar must * be given. Besides the \a id, an emission \a type need to be * specified. * */ virtual double reweight(tcEmiPtr dip, tcDipoleStatePtr state, long id, Energy2 pt2, vector & genVar, const EmissionType & type) 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The static object used to initialize the description of this class. * Indicates that this is an concrete class without persistent data. */ static NoPIOClassDescription initDYCorr; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - DYCorr & operator=(const DYCorr &); + DYCorr & operator=(const DYCorr &) = delete; }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of DYCorr. */ template <> struct BaseClassTrait { /** Typedef of the first base class of DYCorr. */ typedef Ariadne::MECorrBase NthBase; }; /** This template specialization informs ThePEG about the name of * the DYCorr class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Ariadne::DYCorr"; } /** * The name of a file containing the dynamic library where the class * DYCorr is implemented. It may also include several, space-separated, * libraries if the class DYCorr depends on other classes (base classes * excepted). In this case the listed libraries will be dynamically * linked in the order they are specified. */ static string library() { return "libArCascade.so"; } }; /** @endcond */ } #include "DYCorr.icc" #ifndef ThePEG_TEMPLATES_IN_CC_FILE // #include "DYCorr.tcc" #endif #endif /* ARIADNE_DYCorr_H */ diff --git a/DipoleCascade/Dipole.h b/DipoleCascade/Dipole.h --- a/DipoleCascade/Dipole.h +++ b/DipoleCascade/Dipole.h @@ -1,433 +1,433 @@ // -*- C++ -*- #ifndef ARIADNE_Dipole_H #define ARIADNE_Dipole_H // // This is the declaration of the Dipole class. // #include "Ariadne/DipoleCascade/Emitter.h" #include "Dipole.fh" #include "Parton.fh" #include "DipoleState.fh" namespace Ariadne { using namespace ThePEG; /** * The Dipole class represents QCD dipoles between * Partons and is able to perform gluon emissions or * gluon splittings into \f$q\\bar{q}\f$ pairs according to the Dipole * Cascade Model. The Dipole also defines the colour flow from the * incoming to the outgoing Parton, where the incoming Parton carries * anti-colour and the outgoing Parton carries colour. */ class Dipole: public Emitter { public: /** * The DipoleState is a friend. */ friend class DipoleState; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline Dipole(); /** * The copy constructor. */ inline Dipole(const Dipole &); /** * The destructor. */ inline virtual ~Dipole(); //@} public: /** @name The main virtual functions to be overridden by sub-classes. */ //@{ /** * Initialize this dipole. Given then incoming and outgoing partons, * \a ip and \a op, set up this dipole. If \a respectScales is true * the dipoles will get a maximum scale set by the minimum * scale of the original partons. */ virtual void init(tParPtr ip, tParPtr op, bool respectScale = false); /** * Generate the variables needed to perform an emission. The * variables should be saved so that the emission can be performed * by a subsequent call to perform(). * * @param pt2min the minimum transverse momentum squared allowed. * * @param pt2max the minimum transverse momentum squared allowed. * * @return the transverse momentum squared of the generated * emission. If pt2min is returned, no emission was generated. */ virtual Energy2 generate(Energy2 pt2min, Energy2 pt2max); /** * Perform an emission. Use the information previously generated by * generate(Energy2,Energy2) to perform the corresponding emission. * * @return the parton which is considered to have been emitted, or * the null pointer if the emission failed. */ virtual tParPtr perform(); //@} public: /** @name Functions used to construct a history.*/ //@{ /** * Construct the previous state in the cascade associated * with the emitter. This will remove one dipole and set * the values in the current dipole corresponding to the * emission needed to produce the state before * the function was called. In the modified dipole set x1, x3, * flav, qmass, and pT2. * @returns a vector of possible reconstructions associated with * the emitter */ virtual DipoleStateVector constructStep(); /** * Returns the emission probability of the emission that was undone * in the constructStep method. */ virtual double emissionProbability(); /** * Returns the value of the alphaS at the scale of the undone * emission. */ virtual double coupling(); //@} protected: /** @name Functions used to undo emissions. */ //@{ /** * Undo a gluon emission with the gluon in OPart. * Avoind double counting by only including OPart */ bool undoOG(); /** * Merges q1 and q2 into a gluon and returns the gluon. * q1 and q2 are removed from dipole state. */ bool undoQ(tParPtr q2); //@} protected: /** * Reset this dipole preparing for generating a new emission below * the scale \a pt2max. */ virtual void reset(Energy2 pt2max); /** * Generate a gluon emission. Saves x1 and x3 in genVar. * * @param pt2min the minimum transverse momentum squared allowed. * * @param pt2max the minimum transverse momentum squared allowed. */ virtual void genG(Energy2 pt2min, Energy2 pt2max); /** * Generate a \f$g\rightarrow q\bar{q}\f$ emission. Saves x1, x3 and * the quark mass in GeV in genVar. * * @param pt2min the minimum transverse momentum squared allowed. * * @param pt2max the minimum transverse momentum squared allowed. */ virtual void genQ(Energy2 pt2min, Energy2 pt2max); /** * Perform an emission. Use the information previously generated by * genG(Energy2,Energy2) to perform the corresponding emission. * * @return the emitted gluon or null if the emission failed. */ virtual tParPtr performG(); /** * Perform an emission. Use the information previously generated by * genQ(Energy2,Energy2) to perform the corresponding emission. * * @return the quark which was assumed to have been emitted or null * if the emission failed. */ virtual tParPtr performQ(); /** * Create a gluon emitted from this Dipole and set its momentum to * \a pg. Also create the new dipole and connect them all together. */ virtual ParPtr emitGluon(const Lorentz5Momentum & pg); /** * Create a \f$q\bar{q}\f$ pair by splitting a gluon in this Dipole * and set their momentum to \a p2 and \a p3. Also split the * corresponding string into two. */ tParPtr splitGluon(const Lorentz5Momentum & p2, const Lorentz5Momentum & p3); public: /** @name Simple access functions. */ //@{ /** * The anti-colour-carrying parton in this dipole. */ inline tParPtr iPart() const; /** * The previous dipole in the string. Returns iPart()->iDip(). */ tDipPtr prev() const; /** * The colour-carrying parton in this dipole. */ inline tParPtr oPart() const; /** * The next dipole in the string. Returns oPart()->oDip(). */ tDipPtr next() const; /** * The colour index of this dipole. 0 means no index has been assigned. */ inline int colourIndex() const; /** * Set the anti-colour-carrying parton in this dipole. */ inline void iPart(tParPtr); /** * Set the colour-carrying parton in this dipole. */ inline void oPart(tParPtr); /** * Set the colour index of this dipole. 0 means no index has been assigned. */ inline void colourIndex(int); /** * Generte a colour index of this dipole with the given string * index. */ void generateColourIndex(); /** * Return the squared invariant mass of this dipole. */ Energy2 sdip() const; /** * The particle type if this dipole comes directly from a decay of a * resonance. If not, null is returned. */ inline tcPDPtr resonance() const; /** * The particle type if this dipole comes directly from a decay of a * resonance. */ inline void resonance(tcPDPtr); //@} public: /** * A class representing the normal gluon emission type. */ struct FSGluon: public EmissionType {}; /** * A class representing emissions of the type final state splitting * of gluons into quak-antiquark pair. */ struct FSGtoQQ: public EmissionType {}; protected: /** @name Functions relating to the DipoleState to which this belongs. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual ClonePtr clone() const; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} 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(); private: /** * The anti-colour-carrying parton in this dipole. */ tParPtr theIPart; /** * The colour-carrying parton in this dipole. */ tParPtr theOPart; /** * The colour index of this dipole. 0 means no index has been assigned. */ int theColourIndex; /** * The particle type if this dipole comes directly from a decay of a * resonance. */ tcPDPtr theResonance; /** * Factor separating the bare colour index ci from the string index * si. */ static const int div = 1000; protected: /** * The flavour of the last generated emission. 0 means no emission * has been generated, 21 means gluon, positive means the iPart() * has been split into the corresponding quark type, and negative * means that the oPart() has been split into the corresponding * quark type. */ int flav; public: /** * Print out debugging information on std::cerr. */ virtual void debugme() const; /** * Check integrety of the emitter. Return false if error is found. */ virtual bool checkIntegrety(); private: /** * The static object used to initialize the description of this class. * Indicates that this is a concrete class with persistent data. */ static ClassDescription initDipole; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - Dipole & operator=(const Dipole &); + Dipole & operator=(const Dipole &) = delete; }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of Dipole. */ template <> struct BaseClassTrait { /** Typedef of the first base class of Dipole. */ typedef Ariadne::Emitter NthBase; }; /** This template specialization informs ThePEG about the name of * the Dipole class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Ariadne::Dipole"; } /** Return the name of the shared library be loaded to get * access to the Dipole class and every other class it uses * (except the base class). */ static string library() { return "libArCascade.so"; } }; /** @endcond */ } #include "Dipole.icc" #ifndef ThePEG_TEMPLATES_IN_CC_FILE // #include "Dipole.tcc" #endif #endif /* ARIADNE_Dipole_H */ diff --git a/DipoleCascade/DipoleState.h b/DipoleCascade/DipoleState.h --- a/DipoleCascade/DipoleState.h +++ b/DipoleCascade/DipoleState.h @@ -1,698 +1,698 @@ // -*- C++ -*- #ifndef ARIADNE_DipoleState_H #define ARIADNE_DipoleState_H // // This is the declaration of the DipoleState class. // #include "CascadeBase.h" #include "DipoleState.fh" #include "Emitter.h" #include "SoftRemnant.h" #include "String.h" #include "HardSubSys.h" #include "ThePEG/Utilities/ObjectIndexer.h" namespace Ariadne { /** * DipoleState contains all Ariadne::Parton, Ariadne::Dipole and * Ariadne::String objects needed to describe a partonic state within * the Dipole Cascade Model. */ class DipoleState: public CascadeBase { public: /** * A set of CascadeBase pointers. */ typedef list BaseSet; /** * A set of Emitter pointers. */ typedef list EmitterSet; /** * A set of String pointers. */ typedef list StringSet; /** * A pair of partons. */ typedef pair tRemPair; /** * A Selector for DipoleStates */ typedef Selector DipoleStateSelector; /** * Enumerate the different types of sub-processes. */ enum ProcessType { unknown, /**< Used if not cascading a primary sub-process. */ annihilation, /**< Lepton annihilation. */ leptonlepton, /**< Virtual photon-photon scattering. */ leptonhadron, /**< Virtula photon-hadron scattering. */ hadronlepton, /**< Hadron-virtual photon scattering. */ hadronhadron, /**< Virtual photon-photon scattering. */ DIPSYlephad, /**< Virtula photon-hadron scattering. */ DIPSYhadlep, /**< Hadron-virtual photon scattering. */ DIPSYhadhad /**< Hadron-hadron collision. */ }; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline DipoleState(tHandlerPtr hdl = tHandlerPtr()); /** * The copy constructor. */ inline DipoleState(const DipoleState &); /** * The destructor. */ virtual ~DipoleState(); //@} public: /** @name The main functions controlling the cascade. */ //@{ /** * Initialize this state. Using information about the hard * sub-process, initialize the DipoleState, preparing for the * cascade. * * @param sub the SubProcess * * @return the Lorentz rotation used to boost to the hadronic * center-of-mass system. */ LorentzRotation init(tSubProPtr sub); /** * Init simple final-state cascade. Using the outgoing partons in \a * out to initialize a final-state cascade. * * @return false if no cascade was possible. */ bool init(const tPVector & out); /** * Select an Emitter. Go through the list of Emitter objects and * tell them to calculate the invariant transverse momentum of the * next emission and select the Emitter with largest transverse * momentum. Subsequent calls to selected() will return the selected * Emitter. * * @param pt2min the minimum allowed transverse momentum. * * @param pt2max the maximum allowed transverse momentum. * * @return the generated invariant squared transverse momentum. If * ptmin is returned, no emission was generated and subsequent calls * to selected() will return null. */ Energy2 select(Energy2 pt2min, Energy2 pt2max); /** * Perform an emission. * * @return false if no emission was possible. */ bool perform(); /** * Output the result of a simple final-state cascade. The new * partons are created, boosted and inserted in the Step provided. * * @param inital the initial list of partons before the cascade. * * @param rot the LorentzRotation by which the final partons will be * bosted. * * @param step the step in which to insert the produced partons. */ void fill(const tPVector & initial, const LorentzRotation & rot, tStepPtr step); /** * Output the result of a cascade starting from a full sub * process. The resulting partons are created, boosted and inserted * in the Step provided. * * @param sub the initial SubProcess object. * * @param rot the LorentzRotation by which the final partons will be * bosted. * * @param step the step in which to insert the produced partons. */ void fill(tSubProPtr sub, const LorentzRotation & rot, tStepPtr step); //@} /** @name Simple access functions. */ //@{ /** * The Emitter selected to perform the next emission. */ inline tEmiPtr selected() const; /** * Set the Emitter selected to perform the next emission. */ inline void selected(const tEmiPtr &); /** * Get the pair of remnant partons, if any. */ inline const tRemPair & remnants() const; /** * Set the pair of remnant partons, if any. */ inline void remnants(const tRemPair &); /** * Replace an \a old remnant parton with a new \a p. * @return false if \a old was not an remnant parton. */ bool replaceRemnant(tSoftRemPtr old, tSoftRemPtr p); /** * Access information abot the current hard sub-system. */ inline const HardSubSys & hardSubSys() const; /** * Access information abot the current hard sub-system. */ inline HardSubSys & hardSubSys(); /** * Return the squared invariant mass of the hadronic center-of-mass * system. */ Energy2 sTot() const; /** * The Process type. */ inline ProcessType pType() const; /** * The number of emissions made in this state. */ inline int ne() const; /** * Return the inverse extension \f$\mu\f$ of the remnant from * particle \a p. */ Energy getSoftMu(tcPPtr p) const; /** * Return the inverse extension \f$\mu\f$ of a hard probe \a p. */ Energy getHardMu(tcPPtr p) const; /** * Return the dimensionality \f$\alpha\f$ of the extension of * remnant from particle \a p. */ double getSoftAlpha(tcPPtr p) const; /** * Return the dimensionality of the extension of a hard probe \a p. */ double getHardAlpha(tcPPtr p) const; /** * Return the extendedness of the remnant particles. */ inline const pair & mus() const; /** * The incoming particles giving the hadronic system. */ inline tPPair particles() const; /** * The scattered lepton(s) in case this is a DIS event. */ inline tPPair scatteredLeptons() const; /** * The scattered quark(s) in case this is a DIS event. */ inline tPPair scatteredQuarks() const; //@} /** @name Functions relating to the book keeping of included objects. */ //@{ /** * Create a new object to be included in this state. */ template inline typename Ptr::pointer create(); /** * Create a new Parton of the given type to be included in this state. */ ParPtr create(PDPtr type); /** * Create a new Parton from the given Particle to be included in * this state. */ ParPtr create(tcPPtr p); /** * Remove the given parton. Note that it is only removed from the * list of partons. It is still remembered as an object belonging to * this state. */ void remove(tParPtr p); /** * Remove the given emitter. Note that it is only removed from the * list of emitters. It is still remembered as an object belonging to * this state. */ void removeEmitter(tEmiPtr p); /** * Remove the given string. Note that it is only removed from the * list of strings. It is still remembered as an object belonging to * this state. */ void removeString(tStrPtr p); /** * Clone this state. Also cloning all included objects and fixing up * their inter-dependence. */ DipoleStatePtr fullclone() const; /** * Clone this state. Also cloning all included objects and fixing up * their inter-dependence. After the call, \a trans will contain the * translation map between the objects in the old and new * DipoleState. */ DipoleStatePtr fullclone(TranslationMap & trans) const; /** * Clone this state. Also cloning all included objects but do not * fix up their inter-dependence, ie. the cloned objects in the new * DipoleState may still point to objects in the old state. Before * the new state can be used, its postclone() function must be * called with the \a trans object as argument. The \a trans object * will contain the translation map between the objects in the old * and new DipoleState. */ DipoleStatePtr preclone(TranslationMap & trans) const; /** * Fix up the inter-dependence among the included objects in this * DipoleState which was produced by the preclone() function. The * same \a trans object which was used in the preclone() call must * be given here as argument. */ void postclone(const TranslationMap & trans) const; //@} public: /** * Construct all possible histrories to this dipole state * and select one radomly according to the product of the * splitting functions. A PT ordered history is selected if * possible The selected state is saved in theSlectedHistory. * theSelected will be set to the modified dipole. Returns false * if no history was found. */ bool constructHistory(int steps); /** * Returns the product of coupling constants for at the constructed scales. */ double couplingProduct(int steps); /** * Returns the product of the pdf ratios that would have been used in * the undone emissions. */ double PDFRatioProduct(int steps); /** * Calculates whether or not an event should be vetoed according to * the Sudakov Veto algorithm. A return value of true means veto the * event. This function does not take in to account the veto that may * occur when emissions from the state given by the maxtrix element is * above the matrix element cutoff. This function destroys the * information in theSelectedHistory. Any other reweighing should be * done before calling this function. */ bool sudakovVeto(int steps); /** * Find a matrix-element correction object for the given \a dipole; */ tcMECPtr findMECorr(tcEmiPtr dipole) const; /** * Calculate the total momentum of the dipole state. */ LorentzMomentum totalMomentum() const; /** * Return the constructed pt2 of the last emission. */ inline Energy2 constructedPT2() const; protected: /** * A function that constructs all possible histories. */ void allHistories(int steps); /** * Returns true if the exists at least one ordered history. */ bool hasOrderedHistory(int steps); /** * Removes all unordered histories. Returns true if there are * any states left. */ bool removeUnorderedHistories(int steps); /** * Select one history among the ones constructed. Removes all of * the states in theHistory and saves the selected one in * theSelectedHistory. Returns false if no possible history * was found. Modifies the pT2 values to make the cascade history * ordered if it is unordered. */ bool selectHistory(int steps); /** * Find possible matrix-element correction object for the dipoles in * this state. */ void findMECorrs(); /** * Returns true if all gluon have an invariant pt above the cutoff. */ bool checkGluonPT(); protected: /** @name The virtual functions to be overridden in sub-classes. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual ClonePtr clone() const; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ inline virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} 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: /** * Determine and return the type of process using information from * incoming partons, \a inc, in the sub-process. */ ProcessType getType(const PPair & inc) const; /** * Determine and store information about the colliding particles * using information from incoming partons, \a inc, in the * sub-process. * * @return the pair of momenta of the found incoming particles. */ pair setIncoming(const PPair & inc); /** * If the \a partons coming into a hard subprocess goes into an * s-channel resonance return this particle, otherwise return null. */ tPPtr singleResonance(const PPair & partons) const; /** * Given a ColourSinglet object, \a sing, create the corresponding * String object together with the necessary Dipole and Parton * objects. If \a respectScales is true the created dipoles will get * a maximum scale set by the minimum scale of the original partons. * If either \a rems is present it is a temporary remant particle * which should be handlers separately. */ void createString(const ColourSinglet & sing, bool respectScales = false, tPPair rems = tPPair()); public: /** @cond EXCEPTIONCLASSES */ /** * Exception class used if a junction string was found - we don't * know how to cascade them yet. */ struct JunctionException: public Exception {}; /** * Exception class used if hadron remnants were found - we can't * cascade them yet. */ struct RemnantException: public Exception {}; /** * Exception class used if a string with less than two partons was * found. */ struct StringException: public Exception {}; /** @endcond */ protected: /** * These are all the emitters included in this state. */ mutable EmitterSet emitters; /** * These are all the strings included in this state. */ mutable StringSet strings; private: /** * A set containing all objects included in this state. */ mutable BaseSet objects; /** * The Emitter selected to perform the next emission. */ tEmiPtr theSelected; /** * The pair of remnant partons, if any. */ tRemPair theRemnants; /** * Information abot the current hard sub-system. */ HardSubSys theHardSubSys; /** * The process type. */ ProcessType thePType; /** * The number of emissions made in this state. */ int theNe; /** * The incoming particles giving the hadronic system. */ tPPair theParticles; /** * The scattered lepton(s) in case this is a DIS event. */ tPPair theScatteredLeptons; /** * The scattered quark(s) in case this is a DIS event. */ tPPair theScatteredQuarks; private: /** * A Selector containing possible histories to the state. * each element will contain a vector with earlier states etc. * For each element theSelected is set to the modiefied dipole. */ DipoleStateSelector theHistory; /** * The selected history. */ DipoleStatePtr theSelectedHistory; public: /** * Print out debugging information on std::cerr. */ virtual void debugme() const; /** * Check integrety of all the emitters. Return false if error is * found. */ bool checkIntegrety(); /** * Create and return an index for the given object. Only used in for * debugging. */ int index(tcCascadeBasePtr o); /** * Keep track of indices for debugging purposes. */ ObjectIndexer emiindx; /** * Keep track of indices for debugging purposes. */ ObjectIndexer parindx; /** * Keep track of indices for debugging purposes. */ ObjectIndexer strindx; /** * The static object used to initialize the description of this class. * Indicates that this is a concrete class with persistent data. */ static ClassDescription initDipoleState; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - DipoleState & operator=(const DipoleState &); + DipoleState & operator=(const DipoleState &) = delete; public: /** @cond EXCEPTIONCLASSES */ /** Exception class used by DipoleState if four momentum is * not conserved. */ class MomentumException: public Exception {}; /** @endcond */ }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of DipoleState. */ template <> struct BaseClassTrait { /** Typedef of the first base class of DipoleState. */ typedef Ariadne::CascadeBase NthBase; }; /** This template specialization informs ThePEG about the name of * the DipoleState class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Ariadne::DipoleState"; } /** Return the name of the shared library be loaded to get * access to the DipoleState class and every other class it uses * (except the base class). */ static string library() { return "libArCascade.so"; } }; /** @endcond */ } #include "DipoleState.icc" #ifndef ThePEG_TEMPLATES_IN_CC_FILE // #include "DipoleState.tcc" #endif #endif /* ARIADNE_DipoleState_H */ diff --git a/DipoleCascade/EMDipole.h b/DipoleCascade/EMDipole.h --- a/DipoleCascade/EMDipole.h +++ b/DipoleCascade/EMDipole.h @@ -1,243 +1,243 @@ // -*- C++ -*- #ifndef ARIADNE_EMDipole_H #define ARIADNE_EMDipole_H // // This is the declaration of the EMDipole class. // #include "Ariadne/DipoleCascade/Emitter.h" #include "EMDipole.fh" #include "Parton.fh" namespace Ariadne { using namespace ThePEG; /** * The EMDipole class represents electromagnetic dipoles between partons * and is able to perform photon emissions. */ class EMDipole: public Emitter { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline EMDipole(); /** * The copy constructor. */ inline EMDipole(const EMDipole &); /** * The destructor. */ virtual ~EMDipole(); //@} /** @name The main virtual functions to be overridden by sub-classes. */ //@{ /** * Initialize this dipole. Given then incoming and outgoing partons, * \a ip and \a op, set up this dipole. If \a respectScales is true * the dipoles will get a maximum scale set by the minimum * scale of the original partons. * * @return truf if initialization succeded. */ virtual bool init(tParPtr ip, tParPtr op, bool respectScale = false); /** * Generate the variables needed to perform an emission. Saves x1 and * x3 in genVar. The variables should be saved so that the emission * can be performed by a subsequent call to perform(). * * @param pt2min the minimum transverse momentum squared allowed. * * @param pt2max the minimum transverse momentum squared allowed. * * @return the transverse momentum squared of the generated * emission. If pt2min is returned, no emission was generated. */ virtual Energy2 generate(Energy2 pt2min, Energy2 pt2max); /** * Perform an emission. Use the information previously generated by * generate(Energy2,Energy2) to perform the corresponding emission. * * @return the emitted photon or null if the emission failed. */ virtual tParPtr perform(); //@} protected: /** @name Functions relating to the DipoleState to which this belongs. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual ClonePtr clone() const; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointer to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} 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(); public: /** @name Simple access functions. */ //@{ /** * The first parton in this dipole. */ inline tParPtr iPart() const; /** * The second parton in this dipole. */ inline tParPtr oPart() const; /** * Set the first parton in this dipole. */ inline void iPart(tParPtr); /** * Set the second parton in this dipole. */ inline void oPart(tParPtr); /** * Return the squared invariant mass of this dipole. */ Energy2 sdip() const; //@} public: /** A class representing photon emission from an EMDipole. */ struct EMPhoton: public EmissionType {}; private: /** * The first parton in this dipole. */ tParPtr theIPart; /** * The second parton in this dipole. */ tParPtr theOPart; public: /** * Print out debugging information on std::cerr. */ virtual void debugme() const; private: /** * The static object used to initialize the description of this class. * Indicates that this is a concrete class with persistent data. */ static ClassDescription initEMDipole; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - EMDipole & operator=(const EMDipole &); + EMDipole & operator=(const EMDipole &) = delete; }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of EMDipole. */ template <> struct BaseClassTrait { /** Typedef of the first base class of EMDipole. */ typedef Ariadne::Emitter NthBase; }; /** This template specialization informs ThePEG about the name of * the EMDipole class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Ariadne::EMDipole"; } /** * The name of a file containing the dynamic library where the class * EMDipole is implemented. It may also include several, space-separated, * libraries if the class EMDipole depends on other classes (base classes * excepted). In this case the listed libraries will be dynamically * linked in the order they are specified. */ static string library() { return "libArCascade.so"; } }; /** @endcond */ } #include "EMDipole.icc" #ifndef ThePEG_TEMPLATES_IN_CC_FILE // #include "EMDipole.tcc" #endif #endif /* ARIADNE_EMDipole_H */ diff --git a/DipoleCascade/Emitter.h b/DipoleCascade/Emitter.h --- a/DipoleCascade/Emitter.h +++ b/DipoleCascade/Emitter.h @@ -1,456 +1,456 @@ // -*- C++ -*- #ifndef ARIADNE_Emitter_H #define ARIADNE_Emitter_H // // This is the declaration of the Emitter class. // #include "CascadeBase.h" #include "Emitter.fh" #include "Parton.fh" #include "MECorrBase.fh" namespace Ariadne { using namespace ThePEG; /** * Emitter is the base class of all classes able to perform parton * emissions according to the Dipole Cascade Model and its extensions. */ class Emitter: public CascadeBase { public: /** * A vector of dipolstates */ typedef vector DipoleStateVector; public: /** * The DipoleState is a friend. */ friend class DipoleState; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline Emitter(); /** * The copy constructor. */ inline Emitter(const Emitter &); /** * The destructor. */ inline virtual ~Emitter(); //@} public: /** @name The main virtual functions to be overridden by sub-classes. */ //@{ /** * Generate the variables needed to perform an emission. The * variables should be saved so that the emission can be performed * by a subsequent call to perform(). * * @param pt2min the minimum transverse momentum squared allowed. * * @param pt2max the minimum transverse momentum squared allowed. * * @return the transverse momentum squared of the generated * emission. If 0 is returned, no emission was generated. */ virtual Energy2 generate(Energy2 pt2min, Energy2 pt2max) = 0; /** * Perform an emission. Use the information previously generated by * generate(Energy2,Energy2) to perform the corresponding emission. * * @return the parton which is considered to have been emitted, or * the null pointer if the emission failed. */ virtual tParPtr perform() = 0; /** * Setup internal constants and prepare to be able to generate. \a * pt2max is the maximum possible squared transverse momentum * possible for this emitter. */ virtual void setup(Energy2 pt2max); //@} /** * Call perform and return true if the emission succeded and was not * vetoed by any reweighting. */ bool performEmission(); public: /** * Generate an squared invariant transverse momentum. The * distribution used is \f$C\alpha_S\frac{dp_\perp^2}{p_\perp^2}\f$ * multiplied with the corresponding Sudakov formfactor. The maximum * \f$p_\perp^2\f$ is \a pt2max and \a C is the constant. This * automatically takes care of whether we are using a running * \f$\alpha_S\f$ or whatever. */ Energy2 rndsud(double C, Energy2 pt2max, Energy2 pt2min) const; /** * Generate an squared invariant transverse momentum. The * distribution used is \f$C\alpha_{EM}\frac{dp_\perp^2}{p_\perp^2}\f$ * multiplied with the corresponding Sudakov formfactor. The maximum * \f$p_\perp^2\f$ is \a pt2max and \a C is the constant. This * automatically takes care of whether we are using a running * \f$\alpha_{EM}\f$ or whatever. */ Energy2 rndsudEM(double C, Energy2 pt2max, Energy2 pt2min) const; /** * Check if the given 3-parton kinematical configuration is * kinematically possible. * * @param x1 the energy fraction of parton 1 (times two). * @param x3 the energy fraction of parton 3 (times two). * @param y1 the squared mass fraction of parton 1. * @param y2 the squared mass fraction of parton 2. * @param y3 the squared mass fraction of parton 3. * * @rturn true if kinematically possible. */ bool check(double x1, double x3, double y1, double y2, double y3) const; public: /** @name Simple access functions. */ //@{ /** * The scale of the last generated emission. */ inline Energy2 lastPT2() const; /** * The constant \f$\alpha_S\f$ or the constant to be divided by the * log of the scale. */ inline double alpha0() const; /** * The \f$\lambda{QCD}^2\f$ used in the running \f$\alpha_S\f$. If * negative, a fixed coupling is used. */ inline Energy2 lambdaQCD2() const; /** * Set the scale of the last generated emission. */ inline void lastPT2(Energy2); /** * A MECorrBase object for leading-order matrix-element correction. * @return null if no MECorrBase is present. */ inline tcMECPtr MECorr() const; /** * Remove the matrix-element correction after it has been used once. */ inline void removeMECorr(); /** * The maximum scale allowed for an emission in this Emitter. */ inline Energy2 maxScale() const; /** * The maximum scale allowed for an emission in this Emitter. */ inline void maxScale(Energy2); //@} public: /** @name Functions used to construct a history.*/ //@{ /** * Construct the previous state in the cascade associated * with the emitter. This will remove one dipole and set * the values in the current dipole corresponding to the * emission needed to produce the state before * the function was called. * @returns a vector of possible reconstructions associated with * the emitter */ inline virtual DipoleStateVector constructStep(); /** * Returns the emission probability of the emission that was undone * in the constructStep method. */ inline virtual double emissionProbability(); /** * Returns the value of the coupling constant at the scale of the undone * emission. */ inline virtual double coupling(); /** * Returns the value of the pdf ratio used in the emission. */ inline virtual double PDFRatio(); //@} public: /** * This is a base class defining which kind of emission is under * consideration. Concrete classes inheriting from Emitter should * define one such class for each kind of emission which is * possible. */ struct EmissionType { /** A virtual destructor is needed to get the type id system to work. */ virtual ~EmissionType() {} }; /** * Check if the given EmissionType is of a specified kind. */ template static bool isType(const EmissionType & et) { return dynamic_cast(&et); } /** * Check if the last generated EmissionType is of a specified kind. */ template bool isType(const Type &) const { return dynamic_cast(theEType); } /** * Set the last emission type. */ template void lastEType(const Type &) { if ( theEType ) delete theEType; theEType = new Type(); } /** * Get the last emission type. */ const EmissionType * lastEType() const { return theEType; } /** @name Functions for external reweighting of emissions. */ //@{ /** * Return a factor to multiply the basic emission probability * for an emission of a parton with PDG number \a id from the given * \a dipole to ensure that a subsequent call to reweight() will * give a number less than unity. Besides the \a id, an emission \a * type need to be specified. */ double preweight(tcEmiPtr dipole, tcDipoleStatePtr state, long id, const EmissionType & type) const; /** * Return reweighting of an emission of a parton with PDG number \a * id and mass emass from the given dipole, \a dip. The transverse * momentum squared, \a pt2, and the vector of doubles that will be * stored in genVar must be given. Besides the \a id, an emission \a * type need to be specified. * */ double reweight(tcEmiPtr dip, tcDipoleStatePtr state, long id, Energy2 pt2, vector & genVar, const EmissionType & type) const; /** * In addition to the reweight function a final hit/miss veto may be * given after the emission has been performed. The arguments are * the original \a dipole, the final dipole \a state and the emitted * \a parton. Also the scale (\a pt2) and \a type of the emission * must be supplied. */ bool finalVeto(tcEmiPtr dipole, tcDipoleStatePtr state, ParPtr parton, Energy2 pt2, const EmissionType & type) const; //@} protected: /** @name Functions relating to the DipoleState to which this belongs. */ //@{ /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ inline virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ inline virtual void rebind(const TranslationMap & trans); //@} 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: /** * Exception class used if weights larger that one is encountered. */ struct WeightException: Exception {}; private: /** * The scale of the last generated emission. */ Energy2 theLastPT2; /** * The type of the last generated emission. */ const EmissionType * theEType; /** * The constant \f$\alpha_S\f$ or the constant to be divided by the * log of the scale. */ double theAlpha0; /** * The \f$\lambda{QCD}^2\f$ used in the running \f$\alpha_S\f$. If * negative, a fixed coupling is used. */ Energy2 theLambdaQCD2; /** * A MECorrBase object for leading-order matrix-element correction. */ tcMECPtr theMECorr; /** * The maximum scale allowed for an emission in this Emitter. */ Energy2 theMaxScale; protected: /** * Vector used to store data when generating emissions. */ vector genVar; public: /** * Print out debugging information on std::cerr. */ virtual void debugme() const; /** * Check integrety of the emitter. Return false if error is found. */ virtual bool checkIntegrety(); private: /** * The static object used to initialize the description of this class. * Indicates that this is an abstract class with persistent data. */ static AbstractClassDescription initEmitter; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - Emitter & operator=(const Emitter &); + Emitter & operator=(const Emitter &) = delete; }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of Emitter. */ template <> struct BaseClassTrait { /** Typedef of the first base class of Emitter. */ typedef Ariadne::CascadeBase NthBase; }; /** This template specialization informs ThePEG about the name of * the Emitter class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Ariadne::Emitter"; } /** Return the name of the shared library be loaded to get * access to the Emitter class and every other class it uses * (except the base class). */ static string library() { return "libArCascade.so"; } }; /** @endcond */ } #include "DipoleState.h" #include "Emitter.icc" #ifndef ThePEG_TEMPLATES_IN_CC_FILE // #include "Emitter.tcc" #endif #endif /* ARIADNE_Emitter_H */ diff --git a/DipoleCascade/ExtendedDipole.h b/DipoleCascade/ExtendedDipole.h --- a/DipoleCascade/ExtendedDipole.h +++ b/DipoleCascade/ExtendedDipole.h @@ -1,565 +1,565 @@ // -*- C++ -*- #ifndef ARIADNE_ExtendedDipole_H #define ARIADNE_ExtendedDipole_H // // This is the declaration of the ExtendedDipole class. // #include "Ariadne/DipoleCascade/DipoleState.h" #include "Ariadne/DipoleCascade/Dipole.h" #include "Ariadne/DipoleCascade/SoftRemnant.fh" #include "ExtendedDipole.fh" namespace Ariadne { using namespace ThePEG; /** * The ExtendedDipole class represents QCD dipoles between * Partons and is able to perform gluon emissions or * initial-state quark emissions according to the Dipole Cascade * Model. */ class ExtendedDipole: public Dipole { public: /** * The DipoleState is a friend. */ friend class DipoleState; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline ExtendedDipole(); /** * The copy constructor. */ inline ExtendedDipole(const ExtendedDipole &); /** * The destructor. */ inline virtual ~ExtendedDipole(); //@} public: /** @name The main virtual functions to be overridden by sub-classes. */ //@{ /** * Initialize this dipole. Given then incoming and outgoing partons, * \a ip and \a op, set up this dipole. If \a respectScales is true * the dipoles will get a maximum scale set by the minimum * scale of the original partons. */ virtual void init(tParPtr ip, tParPtr op, bool respectScale = false); /** * Generate the variables needed to perform an emission. The * variables should be saved so that the emission can be performed * by a subsequent call to perform(). * * @param pt2min the minimum transverse momentum squared allowed. * * @param pt2max the minimum transverse momentum squared allowed. * * @return the transverse momentum squared of the generated * emission. If pt2min is returned, no emission was generated. */ virtual Energy2 generate(Energy2 pt2min, Energy2 pt2max); /** * Perform an emission. Use the information previously generated by * generate(Energy2,Energy2) to perform the corresponding emission. * * @return the parton which is considered to have been emitted, or * the null pointer if the emission failed. */ virtual tParPtr perform(); //@} protected: /** * Generate a gluon emission from a dipole between the remnant and the * hard sub system. Saves rapidity in genVar. * * @param pt2min the minimum transverse momentum squared allowed. * * @param pt2max the minimum transverse momentum squared allowed. */ void genIniG(Energy2 pt2min, Energy2 pt2max); /** * Perform an emission. Use the information previously generated by * genIniG(Energy2,Energy2) to perform the corresponding emission. * * @return the emitted gluon or null if the emission failed. */ tParPtr performIniG(); /** * Generate a gluon emission from a remnant remnant dipole. Saves * rapidity in genVar. * * @param pt2min the minimum transverse momentum squared allowed. * * @param pt2max the minimum transverse momentum squared allowed. */ void genRemG(Energy2 pt2min, Energy2 pt2max); /** * Perform an emission. Use the information previously generated by * genRemG(Energy2,Energy2) to perform the corresponding emission. * * @return the emitted gluon or null if the emission failed. */ tParPtr performRemG(); /** * Creates a new gluon and a new dipole or extended dipole and * connects them together. */ virtual ParPtr emitGluon(const Lorentz5Momentum & pg); /** * Generate a sea quark emission. Saves xi, z and the quark mass in GeV * in genVar. * * @param pt2min the minimum transverse momentum squared allowed. * * @param pt2max the minimum transverse momentum squared allowed. */ void genSeaQ(Energy2 pt2min, Energy2 pt2max); /** * Generate a sea quark emission for the specified parton. */ void genSeaQ(tSoftRemPtr par, Energy2 pt2min, Energy2 pt2max); /** * Perform an emission. Use the information previously generated by * genSeaQ(Energy2,Energy2) to perform the corresponding emission. * * @return the emitted quark or null if the emission failed. */ tParPtr performSeaQ(); /** * Generate an initial state q->gq splitting. Saves z, x and the quark * mass in GeV in genVar. * * @param pt2min the minimum transverse momentum squared allowed. * * @param pt2max the minimum transverse momentum squared allowed. */ void genQtoGQ(Energy2 pt2min, Energy2 pt2max); /** * Generate an initial state q->gq splitting for the specified parton */ void genQtoGQ(tSoftRemPtr par, Energy2 pt2min, Energy2 pt2max); /** * Perform an emission. Use the information previously generated by * genSeaQ(Energy2,Energy2) to perform the corresponding emission. * * @return the emitted quark or null if the emission failed. */ tParPtr performQtoGQ(); /** * Perform an initial state quark emission. This contains the common * parts of performSeaQ and performQtoGQ. */ virtual tParPtr performInitialQ(); /** * Generate a gluon emission from a dipole between a hard remnant and * a parton. Saves x1 and x3 in genVar. * * @param pt2min the minimum transverse momentum squared allowed. * * @param pt2max the minimum transverse momentum squared allowed. */ void genHRemG(Energy2 pt2min, Energy2 pt2max); /** * Perform an emission. Use the information previously generated by * genG(Energy2,Energy2) to perform the corresponding emission. * * @return the emitted gluon or null if the emission failed. */ tParPtr performHRemG(); public: /** @name Simple access functions. */ //@{ /** * The anti-colour-carrying SoftRemnant in this dipole. May be * null. */ inline tSoftRemPtr iSoftRem() const; /** * The colour-carrying SoftRemnant in this dipole. May be * null. */ inline tSoftRemPtr oSoftRem() const; /** * Set the anti-colour-carrying SoftRemnant in this dipole. */ inline void iSoftRem(tSoftRemPtr); /** * Set the colour-carrying SoftRemnant in this dipole. */ inline void oSoftRem(tSoftRemPtr); /** * The anti-colour-carrying HardRemnant in this dipole. May be * null. */ inline tHardRemPtr iHardRem() const; /** * The colour-carrying HardRemnant in this dipole. May be * null. */ inline tHardRemPtr oHardRem() const; /** * Set the anti-colour-carrying HardRemnant in this dipole. */ inline void iHardRem(tHardRemPtr); /** * Set the colour-carrying HardRemnant in this dipole. */ inline void oHardRem(tHardRemPtr); //@} protected: /** * Return the ratio of pdfs. The pdf is taken from rem and the * nominator is sampled from flavor f1 at x/z and the denominator at x * for flavor f2. Returns zero in case of error. */ double PDFRatio(tSoftRemPtr rem, tcPDPtr f1, tcPDPtr f2, Energy2 pt2, double x, double z); /** * Return the maximum transverse momentum for a given rapidity and * soft suppression parameters. Assumes particle 1 has positive * rapidity and particles 3 has negative rapidity. */ Energy MaxPT(Energy2 S, double y, Energy mu1, Energy mu3, double alpha1, double alpha3); /** * Return the maximum transverse momentum for a given rapidity and * soft suppression parameters. Assumes soft suppresion only in * positive rapidity direction. */ Energy MaxPT(Energy2 S, double y, Energy mu, double alpha); public: /** * A class representing the initial-state gluon emission type from a * dipole between a remnant and a hard sub-system. */ struct RFGluon: public EmissionType {}; /** * A class representing the initial-state gluon emission type from a * dipole between two remnants. */ struct RRGluon: public EmissionType {}; /** * A class representing the initial-state quark emission type from * an initial state gluon. */ struct ISGtoQQ: public EmissionType {}; /** * A class representing the initial-state quark emission type from * an initial state quark. */ struct ISQtoGQ: public EmissionType {}; /** * A class representing the initial-state gluon emission type from a * dipole between a hard remnant and another parton.. */ struct HRGluon: public EmissionType {}; protected: /** * Generate a gluon emission. Saves x1, x3 and rotation angle in * genVar. * * @param pt2min the minimum transverse momentum squared allowed. * * @param pt2max the minimum transverse momentum squared allowed. */ virtual void genG(Energy2 pt2min, Energy2 pt2max); /** * Generate a \f$g\rightarrow q\bar{q}\f$ emission. Saves x1, x3 and * the quark mass in GeV in genVar. * * @param pt2min the minimum transverse momentum squared allowed. * * @param pt2max the minimum transverse momentum squared allowed. */ virtual void genQ(Energy2 pt2min, Energy2 pt2max); /** * Perform an emission. Use the information previously generated by * genG(Energy2,Energy2) to perform the corresponding emission. * * @return the emitted gluon or null if the emission failed. */ virtual tParPtr performG(); public: /** @name Functions used to construct a history.*/ //@{ /** * Construct the previous state in the cascade associated * with the emitter. This will remove one dipole and set * the values in the current dipole corresponding to the * emission needed to produce the state before * the function was called. In the modified dipole set x1, x3, * flav, qmass, and pT2. * @returns a vector of possible reconstructions associated with * the emitter */ virtual DipoleStateVector constructStep(); /** * Returns the emission probability of the emission that was undone * in the constructStep method. */ virtual double emissionProbability(); /** * Returns the value of the pdf ratio used in the emission. */ virtual double PDFRatio(); //@} protected: /** @name Functions used to undo emissions. */ //@{ /** * Undo a gluon emission with the gluon in OPart and both partons * connected to the gluon are remnants. */ bool undoRemOG(); /** * Undo an initial state gluon emission. */ bool undoIniG(); /** * Undo a final state gluon emission. */ bool undoG(); /** * Remove the gluon and one of its neighbouring dipoles. */ bool removeGluon(tParPtr g); /** * Undo an initial state sea quark emission. */ bool undoSeaQ(); /** * Undo an initial state q->gq emission. */ bool undoQtoGQ(tParPtr); /** * Undo an initial state quark emission. */ bool undoInitialQ(tSoftRemPtr rem, tParPtr q); //@} /** * Helper function to randomly choose the fraction of an emitter * taking part in the emission of a gluon with \a xt and \a y. \a a0 * is the default value used if a sharp cutoff is used, \a beta is * the power suppression and \a R is a random number between 0 and * 1. Note that this is not an exact formula but only approximately * gives the desired fraction. Note also that this is not used in * the emission probability but only in the generation of the * recoil gluons. */ static double newa(double xt, double y, double a0, double beta, double R); protected: /** @name Functions relating to the DipoleState to which this belongs. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual ClonePtr clone() const; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} 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(); private: /** * The anti-colour-carrying SoftRemnant in this dipole. May be * null. */ tSoftRemPtr theISoftRem; /** * The colour-carrying SoftRemnant in this dipole. May be * null. */ tSoftRemPtr theOSoftRem; /** * The anti-colour-carrying HardRemnant in this dipole. May be * null. */ tHardRemPtr theIHardRem; /** * The colour-carrying HardRemnant in this dipole. May be * null. */ tHardRemPtr theOHardRem; public: /** * Print out debugging information on std::cerr. */ virtual void debugme() const; /** * Check integrety of the emitter. Return false if error is found. */ virtual bool checkIntegrety(); private: /** * The static object used to initialize the description of this class. * Indicates that this is a concrete class with persistent data. */ static ClassDescription initExtendedDipole; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ExtendedDipole & operator=(const ExtendedDipole &); + ExtendedDipole & operator=(const ExtendedDipole &) = delete; }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of ExtendedDipole. */ template <> struct BaseClassTrait { /** Typedef of the first base class of ExtendedDipole. */ typedef Ariadne::Dipole NthBase; }; /** This template specialization informs ThePEG about the name of * the ExtendedDipole class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Ariadne::ExtendedDipole"; } /** Return the name of the shared library be loaded to get * access to the ExtendedDipole class and every other class it uses * (except the base class). */ static string library() { return "libArCascade.so"; } }; /** @endcond */ } #include "ExtendedDipole.icc" #ifndef ThePEG_TEMPLATES_IN_CC_FILE // #include "ExtendedDipole.tcc" #endif #endif /* ARIADNE_ExtendedDipole_H */ diff --git a/DipoleCascade/HardRemnant.h b/DipoleCascade/HardRemnant.h --- a/DipoleCascade/HardRemnant.h +++ b/DipoleCascade/HardRemnant.h @@ -1,177 +1,177 @@ // -*- C++ -*- #ifndef ARIADNE_HardRemnant_H #define ARIADNE_HardRemnant_H // // This is the declaration of the HardRemnant class. // #include "RemnantParton.h" #include "HardRemnant.fh" namespace Ariadne { using namespace ThePEG; /** * The HardRemnant class represent the struct quark in DIS. */ class HardRemnant: public RemnantParton { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline HardRemnant(); /** * The copy constructor. */ inline HardRemnant(const HardRemnant &); /** * The destructor. */ virtual ~HardRemnant(); //@} public: /** * Return Q2 associated with the parton. */ inline Energy2 Q2() const; /** * Set Q2 associated with the parton. */ inline void setQ2(Energy2 Q2); private: /** * Q2 associated with the parton. */ Energy2 theQ2; protected: /** @name Functions relating to the DipoleState to which this belongs. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual ClonePtr clone() const; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} 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(); public: /** * Print out debugging information on std::cerr. */ virtual void debugme() const; private: /** * The static object used to initialize the description of this class. * Indicates that this is a concrete class with persistent data. */ static ClassDescription initHardRemnant; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - HardRemnant & operator=(const HardRemnant &); + HardRemnant & operator=(const HardRemnant &) = delete; }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of HardRemnant. */ template <> struct BaseClassTrait { /** Typedef of the first base class of HardRemnant. */ typedef Ariadne::RemnantParton NthBase; }; /** This template specialization informs ThePEG about the name of * the HardRemnant class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Ariadne::HardRemnant"; } /** * The name of a file containing the dynamic library where the class * HardRemnant is implemented. It may also include several, space-separated, * libraries if the class HardRemnant depends on other classes (base classes * excepted). In this case the listed libraries will be dynamically * linked in the order they are specified. */ static string library() { return "libArCascade.so"; } }; /** @endcond */ } #include "HardRemnant.icc" #ifndef ThePEG_TEMPLATES_IN_CC_FILE // #include "HardRemnant.tcc" #endif #endif /* ARIADNE_HardRemnant_H */ diff --git a/DipoleCascade/HardSubSys.h b/DipoleCascade/HardSubSys.h --- a/DipoleCascade/HardSubSys.h +++ b/DipoleCascade/HardSubSys.h @@ -1,330 +1,330 @@ // -*- C++ -*- #ifndef ARIADNE_HardSubSys_H #define ARIADNE_HardSubSys_H // // This is the declaration of the HardSubSys class. // #include "ThePEG/Config/ThePEG.h" #include "CascadeBase.h" #include "DipoleState.fh" #include "Emitter.fh" #include "Parton.fh" #include "String.fh" #include "HardRemnant.fh" namespace Ariadne { using namespace ThePEG; /** * The HardSubSys class is used by DipoleState to store information * about the hard sub-system (i.e. outgoing particles from the hard * sub-process). The class also keeps track of added particles * (coloured or not) and possible Lorentz rotations. */ class HardSubSys: public CascadeBase { public: /** * The DipoleState is a friend. */ friend class DipoleState; /** * A set of Parton pointers. */ typedef set PartonSet; /** * A pair of hard remnants. */ typedef pair tHardRemPair; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline HardSubSys(); /** * The copy constructor. */ inline HardSubSys(const HardSubSys &); /** * The destructor. */ virtual ~HardSubSys(); //@} public: /** * Add a new particle to the set of active partons or the set of * produced colour-singlet particles. */ inline void add(tParPtr p); /** * Remove a particle from the set of active partons or the set of * produced colour-singlet particles. */ inline bool remove(tParPtr p); /** * Add a final state (colour-singlet) particle from the initial * sub-process. */ void add(tPPtr p); /** * Add an intermediate particle from the initial sub-process. */ inline void addIntermediate(tPPtr p); /** * Return the total momentum of this hard sub-system. */ inline const Lorentz5Momentum & momentum() const; /** * Set the total momentum of this hard sub-system. If posZDir is true * the value of the incoming particle with positive momentum along the * z axis is modified. */ void setMomentum(const LorentzMomentum & q, bool posZDir, double x = 1.0); /** * Perform a Lorentz transformation on the sub-system. */ void transform(const LorentzRotation & r); /** * Access the set of partons which are active in the cascade. */ inline const PartonSet & active() const; /** * Access the set of created (colour-singlet) particles from the cascade. */ inline const PartonSet & produced() const; /** * Access the vector of final state (colour-singlet) particles in * the initial sub-process. */ inline const tPVector & initial() const; /** * Access the vector of intermediate particles in the initial * sub-process. */ inline const tPVector & intermediates() const; /** * Return the aggregated LorentzRotation to be used on the * initial() and intermediates() to obtain their final momentum. */ inline const LorentzRotation & totalRotation() const; /** * Indicate whether the initial() particles have been rotated. */ inline bool rotated(); /** * Get the pair of hard remnant partons. */ inline const tHardRemPair & hardRemnants() const; /** * Set the a \a hard remnant partons. If it is not the \a first hard * remnant, it is the second. */ inline void hardRemnant(const tHardRemPtr & hard, bool first); /** * Return the sum of Q2 for the hard remnants. */ Energy2 Q2(); protected: /** * Recalculate the total momentum. Is called from momentum() when * necessary. */ void sumMomentum() const; /** @name Functions relating to the DipoleState to which this belongs. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual ClonePtr clone() const; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const CloneBase::TranslationMap & trans); //@} 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(); private: /** * The set of partons which are active in the cascade. */ PartonSet theActivePartons; /** * The set of created (colour-singlet) particles from the cascade. */ PartonSet theProducedParticles; /** * A vector of final state (colour-singlet) particles in the initial * sub-process. Coloured particles are stored in theActivePartons. */ tPVector theInitialParticles; /** * A vector of intermediate particles in the initial sub-process. */ tPVector theIntermediateParticles; /** * A pair of hard remnants. */ tHardRemPair theHardRemnants; /** * The total momentum of the hard sub-system. */ mutable Lorentz5Momentum theMomentum; /** * Indicate if the total momentum needs to be recalculated. */ mutable bool isModified; /** * The sum of the momenta of theInitialParticles. If the sub-system * is transformed only this is changed, while theInitialParicles are * untouched. Their momenta can instead be modified afterwards using * theRotation. */ Lorentz5Momentum theInitMomentum; /** * The accumulated LorentzRotation to be applied to * theInitialParticles and theIntermediateParticles. */ LorentzRotation theRotation; /** * Indicate if rotations have been done. */ bool isRotated; private: /** * The static object used to initialize the description of this class. * Indicates that this is a concrete class with persistent data. */ static ClassDescription initHardSubSys; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - HardSubSys & operator=(const HardSubSys &); + HardSubSys & operator=(const HardSubSys &) = delete; }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of HardSubSys. */ template <> struct BaseClassTrait { /** Typedef of the first base class of HardSubSys. */ typedef PersistentBase NthBase; }; /** This template specialization informs ThePEG about the name of * the HardSubSys class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Ariadne::HardSubSys"; } /** * The name of a file containing the dynamic library where the class * HardSubSys is implemented. It may also include several, space-separated, * libraries if the class HardSubSys depends on other classes (base classes * excepted). In this case the listed libraries will be dynamically * linked in the order they are specified. */ static string library() { return "libArCascade.so"; } }; /** @endcond */ } #include "HardSubSys.icc" #ifndef ThePEG_TEMPLATES_IN_CC_FILE // #include "HardSubSys.tcc" #endif #endif /* ARIADNE_HardSubSys_H */ diff --git a/DipoleCascade/MECorrBase.h b/DipoleCascade/MECorrBase.h --- a/DipoleCascade/MECorrBase.h +++ b/DipoleCascade/MECorrBase.h @@ -1,191 +1,191 @@ // -*- C++ -*- #ifndef ARIADNE_MECorrBase_H #define ARIADNE_MECorrBase_H // // This is the declaration of the MECorrBase class. // #include "ThePEG/Handlers/HandlerBase.h" #include "MECorrBase.fh" #include "Dipole.h" #include "DipoleState.fh" namespace Ariadne { using namespace ThePEG; /** * MECorrBase is the base class for implementing leading order * matrix-element corrections to the dipole emissions in * Ariadne. There are three virtual functions which may be overridden * in concrete sub-classes: canHandle() should check if the * matrix-element correction is applicable to a given Dipole in a * given DipoleState; preweight() should return a factor multiplying * the standard dipole emission before reweighting; and reweight() * should return the actual matrix-element weight. Alternatively the * finalVeto() function can be used to accept/reject an already * performed dipole emission. An object of a concrete sub-class can * inserted to a list in Ariadne::CascadeHandler. The object could * possibly be used for several different dipoles, and should * therefore not store any information in the preweigth() function to * be used in the subsequent reweigth() and finalVeto() calls. * * @see \ref MECorrBaseInterfaces "The interfaces" * defined for MECorrBase. */ class MECorrBase: public HandlerBase { public: /** Typedef for convenience. */ typedef Emitter::EmissionType EmissionType; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline MECorrBase() {}; /** * The destructor. */ virtual ~MECorrBase(); //@} public: /** @name Virtual functions to be overridden in sub-classes. */ //@{ /** * Check if the matrix-element correction can be applied to the * given \a dipole in the given dipole \a state. * @return true if this correction is applicable, false otherwise. */ virtual bool canHandle(tcEmiPtr dipole, tcDipoleStatePtr state) const = 0; /** * Return a factor to multiply the basic dipole emission probability * for an emission of a parton with PDG number \a id from the given * \a dipole to ensure that a subsequent call to reweight() will * give a number less than unity. Besides the \a id, an emission \a * type need to be specified. */ virtual double preweight(tcEmiPtr dipole, tcDipoleStatePtr state, long id, const EmissionType & type) const; /** * Return the matrix-element correction weight associated with an * emission of a parton with PDG number \a id and mass emass from * the given dipole, \a dip. The transverse momentum squared, \a * pt2, and the vector of doubles that will be stored in genVar must * be given. Besides the \a id, an emission \a type need to be * specified. * */ virtual double reweight(tcEmiPtr dip, tcDipoleStatePtr state, long id, Energy2 pt2, vector & genVar, const EmissionType & type) const; /** * In addition to the reweight function a final hit/miss veto may be * given after the emission has been performed. The arguments are * the original \a dipole, the final dipole \a state and the emitted * \a parton. Also the scale (\a pt2) and \a type of the emission * must be supplied. */ virtual bool finalVeto(tcEmiPtr dipole, tcDipoleStatePtr state, tcParPtr parton, Energy2 pt2, const EmissionType & type) 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); //@} /** * 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(); // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The static object used to initialize the description of this class. * Indicates that this is an abstract class with persistent data. */ static AbstractClassDescription initMECorrBase; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - MECorrBase & operator=(const MECorrBase &); + MECorrBase & operator=(const MECorrBase &) = delete; }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of MECorrBase. */ template <> struct BaseClassTrait { /** Typedef of the first base class of MECorrBase. */ typedef HandlerBase NthBase; }; /** This template specialization informs ThePEG about the name of * the MECorrBase class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Ariadne::MECorrBase"; } /** * The name of a file containing the dynamic library where the class * MECorrBase is implemented. It may also include several, space-separated, * libraries if the class MECorrBase depends on other classes (base classes * excepted). In this case the listed libraries will be dynamically * linked in the order they are specified. */ static string library() { return "libArCascade.so"; } }; /** @endcond */ } #endif /* ARIADNE_MECorrBase_H */ diff --git a/DipoleCascade/Parton.h b/DipoleCascade/Parton.h --- a/DipoleCascade/Parton.h +++ b/DipoleCascade/Parton.h @@ -1,350 +1,350 @@ // -*- C++ -*- #ifndef ARIADNE_Parton_H #define ARIADNE_Parton_H // // This is the declaration of the Parton class. // #include "CascadeBase.h" #include "Parton.fh" #include "Dipole.fh" #include "String.fh" #include "ThePEG/Vectors/Lorentz5Vector.h" namespace Ariadne { using namespace ThePEG; /** * The Parton class represents partons which are able to cascade * according to the Dipole Cascade Model. */ class Parton: public CascadeBase { public: /** * The DipoleState is a friend. */ friend class DipoleState; /** * A pair of partons. */ typedef pair tParPair; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ Parton(); /** * The copy constructor. */ Parton(const Parton &); /** * The destructor. */ virtual ~Parton(); //@} public: /** @name Simple access functions. */ //@{ /** * If this was an original parton, this points to the corresponding * Particle object. */ inline tcPPtr orig() const; /** * The final ThePEG::Particle produced for this parton with the * produceParticle() function. */ inline tPPtr particle() const; /** * Fill the given iterator with the original Particle objects * corresponding to the ultimate parents. */ template void getOriginalParents(OIterator it) const; /** * If this parton was created during the cascade, return the * pointers to the parent partons. */ inline tParPair parents() const; /** * The corresponding ParticleData object. */ inline tcPDPtr dataPtr() const; /** * The corresponding ParticleData object. */ inline const ParticleData & data() const; /** * Return true if this parton is a gluon. */ inline bool isG() const; /** * Return true if this parton is coloured. */ inline bool coloured() const; /** * The momentum of this Parton. */ inline const Lorentz5Momentum & momentum() const; /** * The momentum of this Parton. */ inline Lorentz5Momentum & momentum(); /** * The string to which this parton belongs. */ inline tStrPtr string() const; /** * The dipole connecting to the anti-colour line. */ inline tDipPtr iDip() const; /** * The previous parton in the string. Returns iDip()->iPart(). */ tParPtr prev() const; /** * The dipole connecting to the colour line. */ inline tDipPtr oDip() const; /** * The next parton in the string. Returns oDip()->oPart(). */ tParPtr next() const; /** * If this was an original parton, set the pointer to the * corresponding Particle object. Also set the momentum and the * ParticleData pointer. */ void orig(tcPPtr); /** * If this parton was created during the cascade, set the pointers * to the parent partons. */ inline void parents(tParPair); /** * Set the data pointer for this parton. */ void data(tcPDPtr); /** * Set the string to which this parton belongs. */ inline void string(tStrPtr); /** * The dipole connecting to the anti-colour line. */ inline void iDip(tDipPtr); /** * The dipole connecting to the colour line. */ inline void oDip(tDipPtr); //@} /** * Produce a ThePEG::Particle corresponding to this parton. The * momentum of the produced particle is rotated with \a r w.r.t. the * parton. */ virtual tPPtr produceParticle(const LorentzRotation & r); /** * Calculate the invatiant pt2 of the parton. */ Energy2 invPT2() const; protected: /** @name Functions relating to the DipoleState to which this belongs. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual ClonePtr clone() const; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const ; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} 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(); private: /** * If this was an original parton, this points to the corresponding * Particle object. */ tcPPtr theOrig; /** * The final ThePEG::Particle produced for this parton with the * produceParticle() function. */ PPtr theParticle; /** * If this parton was created during the cascade, these points to * the parent partons. */ tParPair theParents; /** * The corresponding ParticleData object. */ tcPDPtr theDataPtr; /** * True if this parton is a gluon. */ bool isGluon; /** * The momentum of this Parton. */ Lorentz5Momentum theMomentum; /** * The string to which this parton belongs. */ tStrPtr theString; /** * The dipole connecting to the incoming (anti-)colour line. */ tDipPtr theIDip; /** * The dipole connecting to the outgoing colour line. */ tDipPtr theODip; public: /** * Print out debugging information on std::cerr. */ virtual void debugme() const; private: /** * The static object used to initialize the description of this class. * Indicates that this is a concrete class with persistent data. */ static ClassDescription initParton; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - Parton & operator=(const Parton &); + Parton & operator=(const Parton &) = delete; }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of Parton. */ template <> struct BaseClassTrait { /** Typedef of the first base class of Parton. */ typedef Ariadne::CascadeBase NthBase; }; /** This template specialization informs ThePEG about the name of * the Parton class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Ariadne::Parton"; } /** Return the name of the shared library be loaded to get * access to the Parton class and every other class it uses * (except the base class). */ static string library() { return "libArCascade.so"; } }; /** @endcond */ } #include "Parton.icc" #ifndef ThePEG_TEMPLATES_IN_CC_FILE // #include "Parton.tcc" #endif #endif /* ARIADNE_Parton_H */ diff --git a/DipoleCascade/RemnantParton.h b/DipoleCascade/RemnantParton.h --- a/DipoleCascade/RemnantParton.h +++ b/DipoleCascade/RemnantParton.h @@ -1,217 +1,217 @@ // -*- C++ -*- #ifndef ARIADNE_RemnantParton_H #define ARIADNE_RemnantParton_H // // This is the declaration of the RemnantParton class. // #include "Parton.h" #include "RemnantParton.fh" namespace Ariadne { using namespace ThePEG; /** * The RemnantParton class represents the remnant left after a parton * has been extracted from an incoming particle. */ class RemnantParton: public Parton { public: /** * The DipoleState is a friend. */ friend class DipoleState; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline RemnantParton(); /** * The copy constructor. */ inline RemnantParton(const RemnantParton &); /** * The destructor. */ inline virtual ~RemnantParton(); //@} public: /** @name Simple access functions. */ //@{ /** * The ParticleData object corresponding to the particle from which * this parton was extracted. */ inline tcPDPtr parentDataPtr() const; /** * The ParticleData object corresponding to the particle from which * this parton was extracted. */ inline const ParticleData & parentData() const; /** * The momentum of the particle from which this parton was * extracted. */ inline const Lorentz5Momentum & parentMomentum() const; /** * Return the inverse extension of this remant. */ inline Energy mu() const; /** * Return the dimensionality of the extension of this remnant. */ inline double alpha() const; /** * Set the inverse extension of this remant. */ inline void mu(Energy); /** * Set the dimensionality of the extension of this remnant. */ inline void alpha(double); //@} protected: /** @name Functions relating to the DipoleState to which this belongs. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual ClonePtr clone() const; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} 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(); private: /** * The inverse extension of this remant. */ Energy theMu; /** * The dimensionality of the extension of this remnant. */ double theAlpha; public: /** * Print out debugging information on std::cerr. */ virtual void debugme() const; private: /** * The static object used to initialize the description of this class. * Indicates that this is a concrete class with persistent data. */ static ClassDescription initRemnantParton; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - RemnantParton & operator=(const RemnantParton &); + RemnantParton & operator=(const RemnantParton &) = delete; }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of RemnantParton. */ template <> struct BaseClassTrait { /** Typedef of the first base class of RemnantParton. */ typedef Ariadne::Parton NthBase; }; /** This template specialization informs ThePEG about the name of * the RemnantParton class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Ariadne::RemnantParton"; } /** Return the name of the shared library be loaded to get * access to the RemnantParton class and every other class it uses * (except the base class). */ static string library() { return "libArCascade.so"; } }; /** @endcond */ } #include "RemnantParton.icc" #ifndef ThePEG_TEMPLATES_IN_CC_FILE // #include "RemnantParton.tcc" #endif #endif /* ARIADNE_RemnantParton_H */ diff --git a/DipoleCascade/ReweightBase.h b/DipoleCascade/ReweightBase.h --- a/DipoleCascade/ReweightBase.h +++ b/DipoleCascade/ReweightBase.h @@ -1,183 +1,183 @@ // -*- C++ -*- #ifndef ARIADNE_ReweightBase_H #define ARIADNE_ReweightBase_H // // This is the declaration of the ReweightBase class. // #include "ThePEG/Handlers/HandlerBase.h" #include "ReweightBase.fh" #include "Dipole.h" #include "DipoleState.fh" namespace Ariadne { using namespace ThePEG; /** * ReweightBase is the base class for implementing different ways of * reweighting the dipole emissions in Ariadne. There are three * virtual functions which may be overridden in concrete sub-classes: * preweight() should return a factor multiplying the standard dipole * emission before reweighting and reweight() should return the actual * reweight. Alternatively the finalVeto() function can be used to * accept/reject an already performed dipole emission. Object of a * concrete sub-class can inserted to a list in * Ariadne::CascadeHandler and will then be applied to all dipole * emissions, even those which are already correced by an MECorrBase * object. The object could possibly be used for several different * dipoles, and should therefore not store any information in the * preweigth() function to be used in the subsequent reweigth() and * finalVeto() calls. * * @see \ref ReweightBaseInterfaces "The interfaces" * defined for ReweightBase. */ class ReweightBase: public HandlerBase { public: /** Typedef for convenience. */ typedef Emitter::EmissionType EmissionType; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ ReweightBase() {}; /** * The destructor. */ virtual ~ReweightBase(); //@} public: /** @name Virtual functions to be overridden in sub-classes. */ //@{ /** * Return a factor to multiply the basic dipole emission probability * for an emission of a parton with PDG number \a id from the given * \a dipole to ensure that a subsequent call to reweight() will * give a number less than unity. Besides the \a id, an emission \a * type need to be specified. */ virtual double preweight(tcEmiPtr dipole, tcDipoleStatePtr state, long id, const EmissionType & type) const; /** * Return the weight associated with an emission of a parton with * PDG number \a id and mass emass from the given dipole, \a * dip. The transverse momentum squared, \a pt2, and the vector of * doubles that will be stored in genVar must be given. Besides the * \a id, an emission \a type need to be specified. Must return a * number between zero and one. * */ virtual double reweight(tcEmiPtr dip, tcDipoleStatePtr state, long id, Energy2 pt2, vector & genVar, const EmissionType & type) const; /** * In addition to the reweight function a final hit/miss veto may be * given after the emission has been performed. The arguments are * the original \a dipole, the final dipole \a state and the emitted * \a parton. Also the scale (\a pt2) and \a type of the emission * must be supplied. */ virtual bool finalVeto(tcEmiPtr dipole, tcDipoleStatePtr state, tcParPtr parton, Energy2 pt2, const EmissionType & type) 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); //@} /** * 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(); // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The static object used to initialize the description of this class. * Indicates that this is an abstract class with persistent data. */ static AbstractClassDescription initReweightBase; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ReweightBase & operator=(const ReweightBase &); + ReweightBase & operator=(const ReweightBase &) = delete; }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of ReweightBase. */ template <> struct BaseClassTrait { /** Typedef of the first base class of ReweightBase. */ typedef HandlerBase NthBase; }; /** This template specialization informs ThePEG about the name of * the ReweightBase class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Ariadne::ReweightBase"; } /** * The name of a file containing the dynamic library where the class * ReweightBase is implemented. It may also include several, space-separated, * libraries if the class ReweightBase depends on other classes (base classes * excepted). In this case the listed libraries will be dynamically * linked in the order they are specified. */ static string library() { return "libArCascade.so"; } }; /** @endcond */ } #endif /* ARIADNE_ReweightBase_H */ diff --git a/DipoleCascade/SoftRemnant.h b/DipoleCascade/SoftRemnant.h --- a/DipoleCascade/SoftRemnant.h +++ b/DipoleCascade/SoftRemnant.h @@ -1,241 +1,241 @@ // -*- C++ -*- #ifndef ARIADNE_SoftRemnant_H #define ARIADNE_SoftRemnant_H // // This is the declaration of the SoftRemnant class. // #include "RemnantParton.h" #include "SoftRemnant.fh" namespace Ariadne { using namespace ThePEG; /** * The SoftRemnant class represents the remnant left after a parton * has been extracted from an incoming particle. */ class SoftRemnant: public RemnantParton { public: /** * The DipoleState is a friend. */ friend class DipoleState; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline SoftRemnant(); /** * The copy constructor. */ inline SoftRemnant(const SoftRemnant &); /** * The destructor. */ inline virtual ~SoftRemnant(); //@} public: /** @name Simple access functions. */ //@{ /** * The ParticleData object corresponding to the particle from which * this parton was extracted. */ inline tcPDPtr parentDataPtr() const; /** * The ParticleData object corresponding to the particle from which * this parton was extracted. */ inline const ParticleData & parentData() const; /** * The momentum of the particle from which this parton was * extracted. */ inline const Lorentz5Momentum & parentMomentum() const; /** * The momentum of the incoming parton */ inline LorentzMomentum incomingMomentum() const; /** * The momentum of the particle from which this parton was * extracted. */ inline void parentMomentum(const Lorentz5Momentum & p); /** * Set the data pointer for the particle from which this parton was * extracted. */ void parentData(tcPDPtr); /** * Get the pdf associated with the parent. */ inline const PDF & pdf() const; /** * Set the pdf associated with the parent. */ inline void pdf(PDF); //@} /** * Calculate x of the extracted parton. */ double partonx() const; /** * Produce a ThePEG::Particle corresponding to this parton. The * momentum of the produced particle is rotated with \a r w.r.t. the * parton. */ virtual tPPtr produceParticle(const LorentzRotation & r); protected: /** @name Functions relating to the DipoleState to which this belongs. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual ClonePtr clone() const; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} 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(); private: /** * The corresponding ParticleData object. */ tcPDPtr theParentDataPtr; /** * The momentum of this Parton. */ Lorentz5Momentum theParentMomentum; /** * The PDF associated with the parent. */ PDF thePdf; public: /** * Print out debugging information on std::cerr. */ virtual void debugme() const; private: /** * The static object used to initialize the description of this class. * Indicates that this is a concrete class with persistent data. */ static ClassDescription initSoftRemnant; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - SoftRemnant & operator=(const SoftRemnant &); + SoftRemnant & operator=(const SoftRemnant &) = delete; }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of SoftRemnant. */ template <> struct BaseClassTrait { /** Typedef of the first base class of SoftRemnant. */ typedef Ariadne::RemnantParton NthBase; }; /** This template specialization informs ThePEG about the name of * the SoftRemnant class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Ariadne::SoftRemnant"; } /** Return the name of the shared library be loaded to get * access to the SoftRemnant class and every other class it uses * (except the base class). */ static string library() { return "libArCascade.so"; } }; /** @endcond */ } #include "SoftRemnant.icc" #ifndef ThePEG_TEMPLATES_IN_CC_FILE // #include "SoftRemnant.tcc" #endif #endif /* ARIADNE_SoftRemnant_H */ diff --git a/DipoleCascade/String.h b/DipoleCascade/String.h --- a/DipoleCascade/String.h +++ b/DipoleCascade/String.h @@ -1,236 +1,236 @@ // -*- C++ -*- #ifndef ARIADNE_String_H #define ARIADNE_String_H // // This is the declaration of the String class. // #include "CascadeBase.h" #include "String.fh" #include "Parton.fh" #include "EMDipole.fh" namespace Ariadne { using namespace ThePEG; /** * The String class respresentsa set of colour-connected Parton * objects. These are represented by the first and last Parton in the * string, where the first has anti-colour and the last has colour. */ class String: public CascadeBase { public: /** * The DipoleState is a friend. */ friend class DipoleState; /** * A pair of partons. */ typedef pair tParPair; public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline String(); /** * The copy constructor. */ inline String(const String &); /** * The destructor. */ inline virtual ~String(); //@} public: /** * Split the gluon, \a g, in this string into \a q and \a qbar. In * case this is not a closed string split the it into two. Also * connect the dipoles and partons correctly. The function also * removes the EM dipole connecting the endpoints of the string if * such a dipole exits. If \a remg is true the gluon will be from * the dipole state. */ void split(tParPtr g, tParPtr q, tParPtr qbar, bool remg = false); /** * Move the endpoint of the string. The first argument is the old * endpoint and the second the new endpoint. */ void moveEndpoint(tParPtr, tParPtr); /** * Join the current string to the string with the endpoint q and * replace the endpoints with the parton g. This function does not * remove the previous endpoints from the dipole state. */ void join(tParPtr q, tParPtr g); /** * Return the EM dipole connected to the first and last parton * of the string. If none exists return NULL. */ inline tEMDipPtr EMDip(); /** * Set the EM dipole connected to the first and last parton * of the string. */ inline void EMDip(tEMDipPtr x); protected: /** @name Access the endpoints. */ //@{ /** * The first and last parton in this string. The first parton is * always anti-coloured, while the second is always coloured. */ inline tParPair endpoints() const; /** * Set the \a first and \a last parton in this string. The first parton is * always anti-coloured, while the second is always coloured. */ inline void endpoints(tParPtr first, tParPtr last); //@} /** @name Functions relating to the DipoleState to which this belongs. */ //@{ /** * Return a simple clone of this object. Should be implemented as * return new_ptr(*this); by a derived class. */ virtual ClonePtr clone() const; /** * Fill the provided set with all pointers to CloneBase objects used * in this object. */ inline virtual void fillReferences(CloneSet &) const; /** * Rebind pointers to other CloneBase objects. Called after a number * of interconnected CloneBase objects have been cloned, so that * the cloned objects will refer to the cloned copies afterwards. * * @param trans a TranslationMap relating the original objects to * their respective clones. */ virtual void rebind(const TranslationMap & trans); //@} 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(); private: /** * The first and last parton in this string. The first parton is * always anti-coloured, while the second is always coloured. */ tParPair theEndpoints; /** * A pointer to the EM Dipole connected to the first and * last parton in the string if such a dipole exits. */ tEMDipPtr theEMDipole; public: /** * Print out debugging information on std::cerr. */ virtual void debugme() const; private: /** * The static object used to initialize the description of this class. * Indicates that this is a concrete class with persistent data. */ static ClassDescription initString; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - String & operator=(const String &); + String & operator=(const String &) = delete; }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of String. */ template <> struct BaseClassTrait { /** Typedef of the first base class of String. */ typedef Ariadne::CascadeBase NthBase; }; /** This template specialization informs ThePEG about the name of * the String class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Ariadne::String"; } /** Return the name of the shared library be loaded to get * access to the String class and every other class it uses * (except the base class). */ static string library() { return "libArCascade.so"; } }; /** @endcond */ } #include "String.icc" #ifndef ThePEG_TEMPLATES_IN_CC_FILE // #include "String.tcc" #endif #endif /* ARIADNE_String_H */ diff --git a/src/DISAnalysis.h b/src/DISAnalysis.h --- a/src/DISAnalysis.h +++ b/src/DISAnalysis.h @@ -1,222 +1,222 @@ // -*- C++ -*- #ifndef THEPEG_DISAnalysis_H #define THEPEG_DISAnalysis_H // // This is the declaration of the DISAnalysis class. // #include "ThePEG/Handlers/AnalysisHandler.h" #include "ThePEG/Vectors/LorentzVector.h" namespace Ariadne { using namespace ThePEG; /** * Plots several histograms related to DIS. * * @see \ref DISAnalysisInterfaces "The interfaces" * defined for DISAnalysis. */ class DISAnalysis: public AnalysisHandler { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline DISAnalysis(); /** * The copy constructor. */ inline DISAnalysis(const DISAnalysis &); /** * The destructor. */ virtual ~DISAnalysis(); //@} public: /** @name Virtual functions required by the AnalysisHandler class. */ //@{ /** * Analyze a given Event. Note that a fully generated event * may be presented several times, if it has been manipulated in * between. The default version of this function will call transform * to make a lorentz transformation of the whole event, then extract * all final state particles and call analyze(tPVector) of this * analysis object and those of all associated analysis objects. The * default version will not, however, do anything on events which * have not been fully generated, or have been manipulated in any * way. * @param event pointer to the Event to be analyzed. * @param ieve the event number. * @param loop the number of times this event has been presented. * If negative the event is now fully generated. * @param state a number different from zero if the event has been * manipulated in some way since it was last presented. */ virtual void analyze(tEventPtr event, long ieve, int loop, int state); /** * Transform the event to the desired Lorentz frame and return the * corresponding LorentzRotation. * @param event a pointer to the Event to be transformed. * @return the LorentzRotation used in the transformation. */ virtual LorentzRotation transform(tEventPtr event) const; /** * 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 */ virtual void analyze(const tPVector & particles); /** * Analyze the given particle. * @param particle pointer to the particle to be analyzed. */ virtual void analyze(tPPtr particle); //@} 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. */ 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. */ //@{ /** * Initialize this object after the setup phase before saving and * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ virtual void doinit(); /** * 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: tH1DPtr histY, histQ2, histX, histYQ, histPTQ, histYG, histPTG, histW; /** * Proton and boson momentum. */ LorentzMomentum pp, pq; private: /** * The static object used to initialize the description of this class. * Indicates that this is a concrete class with persistent data. */ static ClassDescription initDISAnalysis; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - DISAnalysis & operator=(const DISAnalysis &); + DISAnalysis & operator=(const DISAnalysis &) = delete; }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of DISAnalysis. */ template <> struct BaseClassTrait { /** Typedef of the first base class of DISAnalysis. */ typedef AnalysisHandler NthBase; }; /** This template specialization informs ThePEG about the name of * the DISAnalysis class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Ariadne::DISAnalysis"; } /** * The name of a file containing the dynamic library where the class * DISAnalysis is implemented. It may also include several, space-separated, * libraries if the class DISAnalysis depends on other classes (base classes * excepted). In this case the listed libraries will be dynamically * linked in the order they are specified. */ static string library() { return "DISAnalysis.so"; } }; /** @endcond */ } #include "DISAnalysis.icc" #ifndef ThePEG_TEMPLATES_IN_CC_FILE // #include "DISAnalysis.tcc" #endif #endif /* THEPEG_DISAnalysis_H */ diff --git a/src/DYAnalysis.h b/src/DYAnalysis.h --- a/src/DYAnalysis.h +++ b/src/DYAnalysis.h @@ -1,214 +1,214 @@ // -*- C++ -*- #ifndef THEPEG_DYAnalysis_H #define THEPEG_DYAnalysis_H // // This is the declaration of the DYAnalysis class. // #include "ThePEG/Handlers/AnalysisHandler.h" namespace Ariadne { using namespace ThePEG; /** * The DYAnalysis class collects a number of histograms related to * Drell-Yan production. * */ class DYAnalysis: public AnalysisHandler { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ inline DYAnalysis(); /** * The copy constructor. */ inline DYAnalysis(const DYAnalysis &); /** * The destructor. */ virtual ~DYAnalysis(); //@} public: /** @name Virtual functions required by the AnalysisHandler class. */ //@{ /** * Analyze a given Event. Note that a fully generated event * may be presented several times, if it has been manipulated in * between. The default version of this function will call transform * to make a lorentz transformation of the whole event, then extract * all final state particles and call analyze(tPVector) of this * analysis object and those of all associated analysis objects. The * default version will not, however, do anything on events which * have not been fully generated, or have been manipulated in any * way. * @param event pointer to the Event to be analyzed. * @param ieve the event number. * @param loop the number of times this event has been presented. * If negative the event is now fully generated. * @param state a number different from zero if the event has been * manipulated in some way since it was last presented. */ virtual void analyze(tEventPtr event, long ieve, int loop, int state); /** * Transform the event to the desired Lorentz frame and return the * corresponding LorentzRotation. * @param event a pointer to the Event to be transformed. * @return the LorentzRotation used in the transformation. */ virtual LorentzRotation transform(tEventPtr event) const; /** * 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 */ virtual void analyze(const tPVector & particles); /** * Analyze the given particle. * @param particle pointer to the particle to be analyzed. */ virtual void analyze(tPPtr particle); //@} 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. */ 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. */ //@{ /** * Initialize this object after the setup phase before saving and * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ virtual void doinit(); /** * 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: tH1DPtr histPt, histEta, histY, histYQ, histYG, histMass, histCPt; tH1DPtr histNG, histPTG, histPTQ; private: /** * The static object used to initialize the description of this class. * Indicates that this is a concrete class with persistent data. */ static ClassDescription initDYAnalysis; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - DYAnalysis & operator=(const DYAnalysis &); + DYAnalysis & operator=(const DYAnalysis &) = delete; }; } // CLASSDOC OFF #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of DYAnalysis. */ template <> struct BaseClassTrait { /** Typedef of the first base class of DYAnalysis. */ typedef AnalysisHandler NthBase; }; /** This template specialization informs ThePEG about the name of * the DYAnalysis class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Ariadne::DYAnalysis"; } /** Return the name of the shared library be loaded to get * access to the DYAnalysis class and every other class it uses * (except the base class). */ static string library() { return "DYAnalysis.so"; } }; /** @endcond */ } #include "DYAnalysis.icc" #ifndef ThePEG_TEMPLATES_IN_CC_FILE // #include "DYAnalysis.tcc" #endif #endif /* THEPEG_DYAnalysis_H */ diff --git a/src/ETFlow.h b/src/ETFlow.h --- a/src/ETFlow.h +++ b/src/ETFlow.h @@ -1,132 +1,132 @@ // -*- C++ -*- #ifndef ThePEG_ETFlow_H #define ThePEG_ETFlow_H // // This is the declaration of the ETFlow class. // #include "ThePEG/Handlers/AnalysisHandler.h" namespace ThePEG { /** * Here is the documentation of the ETFlow class. * * @see \ref ETFlowInterfaces "The interfaces" * defined for ETFlow. */ class ETFlow: public AnalysisHandler { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ ETFlow(); /** * The destructor. */ virtual ~ETFlow(); //@} 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 weight of the current event. */ virtual void analyze(const tPVector & particles, double weight); //@} 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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). 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: tH1DPtr lox; tH1DPtr hix; double low; double hiw; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ETFlow & operator=(const ETFlow &); + ETFlow & operator=(const ETFlow &) = delete; }; } #endif /* ThePEG_ETFlow_H */ diff --git a/src/MEee2Z2gg.h b/src/MEee2Z2gg.h --- a/src/MEee2Z2gg.h +++ b/src/MEee2Z2gg.h @@ -1,108 +1,108 @@ // -*- C++ -*- #ifndef Ariadne5_MEee2Z2gg_H #define Ariadne5_MEee2Z2gg_H // // This is the declaration of the MEee2Z2gg class. // #include "ThePEG/MatrixElement/MEee2gZ2qq.h" namespace Ariadne5 { using namespace ThePEG; /** * The MEee2Z2gg class implements the same matrix element as e+e- to * qqbar, but produces gluons instead. Only used for testing purposes * of true gluon jets. * * @see \ref MEee2Z2ggInterfaces "The interfaces" * defined for MEee2Z2gg. */ class MEee2Z2gg: public MEee2gZ2qq { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ MEee2Z2gg(); /** * The destructor. */ virtual ~MEee2Z2gg(); //@} public: /** * Add all possible diagrams with the add() function. */ virtual void getDiagrams() const; Selector diagrams(const DiagramVector & diags) const; Selector MEee2Z2gg::colourGeometries(tcDiagPtr) const; /** @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; //@} // If needed, insert declarations of virtual function defined in the // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs). private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - MEee2Z2gg & operator=(const MEee2Z2gg &); + MEee2Z2gg & operator=(const MEee2Z2gg &) = delete; }; } #endif /* Ariadne5_MEee2Z2gg_H */ diff --git a/src/MEqq2gZ2ll.h b/src/MEqq2gZ2ll.h --- a/src/MEqq2gZ2ll.h +++ b/src/MEqq2gZ2ll.h @@ -1,128 +1,128 @@ // -*- C++ -*- #ifndef ThePEG_MEqq2gZ2ll_H #define ThePEG_MEqq2gZ2ll_H // // This is the declaration of the MEqq2gZ2ll class. // // CLASSDOC SUBSECTION Description: // // The MEqq2gZ2ll class implements the // e+e- -> gamma/Z0 -> // q+qbar matrix element. Both the continuum and // Z0 pole term as well as the interference term is // included. Although not a strict QCD matrix element the cass // inherits from ME2to2Base, mainly to inherit the // parameter for the number of active quark flavours. // // CLASSDOC SUBSECTION See also: // // ME2to2QCD.h. // #include "ThePEG/MatrixElement/ME2to2QCD.h" using namespace ThePEG; namespace Herwig { class MEqq2gZ2ll: public ME2to2QCD { public: MEqq2gZ2ll(); MEqq2gZ2ll(const MEqq2gZ2ll &); virtual ~MEqq2gZ2ll(); // Standard ctors and dtor public: virtual unsigned int orderInAlphaS() const; virtual unsigned int orderInAlphaEW() const; // Return the order in respective couplings in which this matrix // element is given. Returns 0 and 2 respectively. virtual double me2() const; // Return the matrix element for the kinematical configuation // previously provided by the last call to setKinematics(). virtual void getDiagrams() const; // Add all possible diagrams with the add() function. virtual Selector colourGeometries(tcDiagPtr diag) const; // Return a Selector with possible colour geometries for the selected // diagram weighted by their relative probabilities. virtual Selector diagrams(const DiagramVector &) const; // Weight the given diagrams with their relative probabilities. virtual Energy2 scale() const; // Return the scale associated with the last set phase space point. public: void persistentOutput(PersistentOStream &) const; void persistentInput(PersistentIStream &, int); // Standard functions for writing and reading from persistent streams. static void Init(); // Standard Init function used to initialize the interface. protected: virtual IBPtr clone() const; virtual IBPtr fullclone() const; // Standard clone methods virtual void doinit(); // Standard Interfaced virtual functions. protected: vector coefs; // Constants for the different terms set from the StandardModel in // the init() function. Energy2 mZ2; Energy2 GZ2; // The mass squared and width squared of the Z0. mutable double lastCont; mutable double lastBW; // The last continuum and Breit-Wigner terms to be used to select // primary diagram. private: static ClassDescription initMEqq2gZ2ll; - MEqq2gZ2ll & operator=(const MEqq2gZ2ll &); + MEqq2gZ2ll & operator=(const MEqq2gZ2ll &) = delete; // Private and non-existent assignment operator. }; } namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ template <> struct BaseClassTrait: public ClassTraitsType { typedef ME2to2QCD NthBase; }; template <> struct ClassTraits : public ClassTraitsBase { static string className() { return "Herwig::MEqq2gZ2ll"; } static string library() { return "MEqq2gZ2ll.so"; } }; /** @endcond */ } #include "MEqq2gZ2ll.icc" #endif /* ThePEG_MEqq2gZ2ll_H */