Decay/General/GeneralFourBodyDecayer.h

0001 // -*- C++ -*-
0002 #ifndef HERWIG_GeneralFourBodyDecayer_H
0003 #define HERWIG_GeneralFourBodyDecayer_H
0004 //
0005 // This is the declaration of the GeneralFourBodyDecayer class.
0006 //
0007
0008 #include "Herwig/Decay/DecayIntegrator.h"
0009 #include "Herwig/Models/General/PrototypeVertex.h"
0010
0011 namespace Herwig {
0012
0013 using namespace ThePEG;
0014
0015 /**
0016  * Here is the documentation of the GeneralFourBodyDecayer class.
0017  *
0018  * @see \ref GeneralFourBodyDecayerInterfaces "The interfaces"
0019  * defined for GeneralFourBodyDecayer.
0020  */
0021 class GeneralFourBodyDecayer: public DecayIntegrator {
0022
0023 public:
0024
0025   /**
0026    * The default constructor.
0027    */
0028   GeneralFourBodyDecayer(): nflow_(999), widthOpt_(1),
0029                 refTag_(), refTagCC_(), iflow_(999)
0030   {}
0031
0032   /** @name Virtual functions required by the Decayer class. */
0033   //@{
0034   /**
0035    * For a given decay mode and a given particle instance, perform the
0036    * decay and return the decay products. As this is the base class this
0037    * is not implemented.
0038    * @return The vector of particles produced in the decay.
0039    */
0040   virtual ParticleVector decay(const Particle & parent,
0041                    const tPDVector & children) const;
0042
0043   /**
0044    * Which of the possible decays is required
0045    * @param cc Is this mode the charge conjugate
0046    * @param parent The decaying particle
0047    * @param children The decay products
0048    */
0049   virtual int modeNumber(bool & cc, tcPDPtr parent,
0050              const tPDVector & children) const;
0051
0052   /**
0053    *  Set the diagrams
0054    */
0055   bool setDecayInfo(PDPtr incoming,vector<PDPtr> outgoing,
0056             const vector<NBDiagram> & process,
0057             double symfac);
0058   //@}
0059
0060   /**
0061    * Function to return partial Width
0062    * @param inpart Pointer to incoming particle data object
0063    * @param outgoing the decay products
0064    */
0065   virtual Energy partialWidth(tPDPtr inpart,
0066                   OrderedParticles outgoing) const;
0067
0068 public:
0069
0070   /** @name Functions used by the persistent I/O system. */
0071   //@{
0072   /**
0073    * Function used to write out object persistently.
0074    * @param os the persistent output stream written to.
0075    */
0076   void persistentOutput(PersistentOStream & os) const;
0077
0078   /**
0079    * Function used to read in object persistently.
0080    * @param is the persistent input stream read from.
0081    * @param version the version number of the object when written.
0082    */
0083   void persistentInput(PersistentIStream & is, int version);
0084   //@}
0085
0086   /**
0087    * The standard Init function used to initialize the interfaces.
0088    * Called exactly once for each class by the class description system
0089    * before the main function starts or
0090    * when this class is dynamically loaded.
0091    */
0092   static void Init();
0093
0094 protected:
0095
0096   /**
0097    *  Incoming particle
0098    */
0099   PDPtr incoming() const { return incoming_; }
0100
0101   /**
0102    *  Outgoing particles
0103    */
0104   const tPDVector & outgoing() const {  return outgoing_; }
0105
0106   /**
0107    *  Number of colour flows
0108    */
0109   unsigned int numberOfFlows() const { return nflow_; }
0110
0111   /**
0112    * Set up the colour factors
0113    */
0114   bool setColourFactors(double symfac);
0115
0116   /**
0117    * Return the matrix of colour factors
0118    */
0119   const vector<DVector> & getColourFactors() const {  return colour_; }
0120
0121   /**
0122    * Return the matrix of colour factors
0123    */
0124   const vector<DVector> & getLargeNcColourFactors() const {
0125     return colourLargeNC_;
0126   }
0127
0128   /**
0129    *  Option for the handling of the widths of the intermediate particles
0130    */
0131   unsigned int widthOption() const { return widthOpt_; }
0132
0133   /**
0134    * Set colour connections
0135    * @param parent Parent particle
0136    * @param out Particle vector containing particles to
0137    * connect colour lines
0138    */
0139   void colourConnections(const Particle & parent,
0140              const ParticleVector & out) const;
0141
0142   /**
0143    *  Set the colour flow
0144    * @param flow The value for the colour flow
0145    */
0146   void colourFlow(unsigned int flow) const { iflow_ = flow; }
0147
0148   /**
0149    *  Set the colour flow
0150    */
0151   unsigned int const & colourFlow() const { return iflow_; }
0152
0153   /**
0154    * Access the TBDiagrams that store the required information
0155    * to create the diagrams
0156    */
0157   const vector<NBDiagram> & getProcessInfo() const {
0158     return diagrams_;
0159   }
0160
0161   /**
0162    *  Get the mapping between the phase-space channel and the diagram
0163    */
0164   const vector<unsigned int> & diagramMap() const {
0165     return diagmap_;
0166   }
0167
0168 protected:
0169
0170   /** @name Standard Interfaced functions. */
0171   //@{
0172   /**
0173    * Initialize this object after the setup phase before saving an
0174    * EventGenerator to disk.
0175    * @throws InitException if object could not be initialized properly.
0176    */
0177   virtual void doinit();
0178   //@}
0179
0180 private:
0181
0182   /**
0183    * The assignment operator is private and must never be called.
0184    * In fact, it should not even be implemented.
0185    */
0186   GeneralFourBodyDecayer & operator=(const GeneralFourBodyDecayer &) = delete;
0187
0188 private:
0189
0190   /**
0191    *  Store the incoming particle
0192    */
0193   PDPtr incoming_;
0194
0195   /**
0196    *  Outgoing particles
0197    */
0198   tPDVector outgoing_;
0199
0200   /**
0201    *  Store the diagrams for the decay
0202    */
0203   vector<NBDiagram> diagrams_;
0204
0205   /**
0206    *  Map between the diagrams and the phase-space channels
0207    */
0208   vector<unsigned int> diagmap_;
0209
0210   /**
0211    * Store colour factors for ME calc.
0212    */
0213   vector<DVector> colour_;
0214
0215   /**
0216    *  Store cololur factors for ME calc at large N_c
0217    */
0218   vector<DVector> colourLargeNC_;
0219
0220   /**
0221    * The number of colourflows.
0222    */
0223   unsigned int nflow_;
0224
0225   /**
0226    *  Option for the treatment of the widths
0227    */
0228   unsigned int widthOpt_;
0229
0230   /**
0231    * Store a decay tag for this mode that can be tested when
0232    * trying to determine whether it can be generated by
0233    * this Decayer
0234    */
0235   string refTag_;
0236
0237   /**
0238    * Store a decay tag for the cc-mode that can be tested when
0239    * trying to determine whether it can be generated by
0240    * this Decayer
0241    */
0242   string refTagCC_;
0243
0244   /**
0245    *  The colour flow
0246    */
0247   mutable unsigned int iflow_;
0248 };
0249
0250 }
0251
0252 #endif /* HERWIG_GeneralFourBodyDecayer_H */