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