ThePEG/PDT/DalitzDecayer.h

0001 // -*- C++ -*-
0002 //
0003 // DalitzDecayer.h is a part of ThePEG - Toolkit for HEP Event Generation
0004 // Copyright (C) 1999-2019 Leif Lonnblad
0005 //
0006 // ThePEG is licenced under version 3 of the GPL, see COPYING for details.
0007 // Please respect the MCnet academic guidelines, see GUIDELINES for details.
0008 //
0009 #ifndef THEPEG_DalitzDecayer_H
0010 #define THEPEG_DalitzDecayer_H
0011 // This is the declaration of the DalitzDecayer class.
0012
0013 #include "ThePEG/PDT/Decayer.h"
0014 // #include "DalitzDecayer.fh"
0015 // #include "DalitzDecayer.xh"
0016
0017 namespace ThePEG {
0018
0019 /**
0020  * The DalitzDecayer inherits from the Decayer class and performs
0021  * Dalitz decays into \f$\gamma e^+ e^-\f$.
0022  *
0023  * @see \ref DalitzDecayerInterfaces "The interfaces"
0024  * defined for DalitzDecayer.
0025  */
0026 class DalitzDecayer: public Decayer {
0027
0028 public:
0029
0030   /** @name Virtual functions required by the Decayer class.
0031    */
0032   //@{
0033   /**
0034    * Check if this decayer can perfom the decay specified by the
0035    * given decay mode.
0036    * @param dm the DecayMode describing the decay.
0037    * @return true if this decayer can handle the given mode, otherwise false.
0038    */
0039   virtual bool accept(const DecayMode & dm) const;
0040
0041   /**
0042    * Perform a decay for a given DecayMode and a given Particle instance.
0043    * @param dm the DecayMode describing the decay.
0044    * @param p the Particle instance to be decayed.
0045    * @return a ParticleVector containing the decay products.
0046    */
0047   virtual ParticleVector decay(const DecayMode & dm, const Particle & p) const;
0048   //@}
0049
0050 public:
0051
0052   /** @name Functions used by the persistent I/O system. */
0053   //@{
0054   /**
0055    * Function used to write out object persistently.
0056    * @param os the persistent output stream written to.
0057    */
0058   void persistentOutput(PersistentOStream & os) const;
0059
0060   /**
0061    * Function used to read in object persistently.
0062    * @param is the persistent input stream read from.
0063    * @param version the version number of the object when written.
0064    */
0065   void persistentInput(PersistentIStream & is, int version);
0066   //@}
0067
0068   /**
0069    * Standard Init function used to initialize the interfaces.
0070    */
0071   static void Init();
0072
0073 protected:
0074
0075   /** @name Clone Methods. */
0076   //@{
0077   /**
0078    * Make a simple clone of this object.
0079    * @return a pointer to the new object.
0080    */
0081   virtual IBPtr clone() const;
0082
0083   /** Make a clone of this object, possibly modifying the cloned object
0084    * to make it sane.
0085    * @return a pointer to the new object.
0086    */
0087   virtual IBPtr fullclone() const;
0088   //@}
0089
0090 protected:
0091
0092   /** @name Standard Interfaced functions. */
0093   //@{
0094   /**
0095    * Initialize this object after the setup phase before saving an
0096    * EventGenerator to disk.
0097    * @throws InitException if object could not be initialized properly.
0098    */
0099   virtual void doinit();
0100
0101   /**
0102    * Rebind pointer to other Interfaced objects. Called in the setup phase
0103    * after all objects used in an EventGenerator has been cloned so that
0104    * the pointers will refer to the cloned objects afterwards.
0105    * @param trans a TranslationMap relating the original objects to
0106    * their respective clones.
0107    * @throws RebindException if no cloned object was found for a given
0108    * pointer.
0109    */
0110   virtual void rebind(const TranslationMap & trans)
0111    ;
0112
0113   /**
0114    * Return a vector of all pointers to Interfaced objects used in this
0115    * object.
0116    * @return a vector of pointers.
0117    */
0118   virtual IVector getReferences();
0119   //@}
0120
0121 private:
0122
0123   /**
0124    * Quick access to the rho particle data.
0125    */
0126   PDPtr rho;
0127
0128 private:
0129
0130   /**
0131    * Describe a concrete class with persistent data.
0132    */
0133   static ClassDescription<DalitzDecayer> initDalitzDecayer;
0134
0135   /**
0136    * Private and non-existent assignment operator.
0137    */
0138   DalitzDecayer & operator=(const DalitzDecayer &) = delete;
0139
0140 };
0141
0142 }
0143
0144
0145 namespace ThePEG {
0146
0147 /** @cond TRAITSPECIALIZATIONS */
0148
0149 /** This template specialization informs ThePEG about the base classes
0150  *  of DalitzDecayer. */
0151 template <>
0152 struct BaseClassTrait<DalitzDecayer,1>: public ClassTraitsType {
0153   /** Typedef of the first base class of DalitzDecayer. */
0154   typedef Decayer NthBase;
0155 };
0156
0157 /** This template specialization informs ThePEG about the name of the
0158  *  DalitzDecayer class and the shared object where it is
0159  *  defined. */
0160 template <>
0161 struct ClassTraits<DalitzDecayer>
0162   : public ClassTraitsBase<DalitzDecayer> {
0163   /** Return a platform-independent class name */
0164   static string className() { return "ThePEG::DalitzDecayer"; }
0165   /** Return the name of the shared library be loaded to get access to
0166    *  the DalitzDecayer class and every other class it uses
0167    *  (except the base class). */
0168   static string library() { return "DalitzDecayer.so"; }
0169
0170 };
0171
0172 /** @endcond */
0173
0174 }
0175
0176 #endif /* THEPEG_DalitzDecayer_H */