Decay/ScalarMeson/ScalarMesonFactorizedDecayer.h

0001 // -*- C++ -*-
0002 //
0003 // ScalarMesonFactorizedDecayer.h is a part of Herwig - A multi-purpose Monte Carlo event generator
0004 // Copyright (C) 2002-2019 The Herwig Collaboration
0005 //
0006 // Herwig 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 HERWIG_ScalarMesonFactorizedDecayer_H
0010 #define HERWIG_ScalarMesonFactorizedDecayer_H
0011 //
0012 // This is the declaration of the ScalarMesonFactorizedDecayer class.
0013 //
0014
0015 #include "Herwig/Decay/DecayIntegrator.h"
0016 #include "Herwig/Decay/WeakCurrents/WeakCurrent.h"
0017 #include "Herwig/Decay/FormFactors/ScalarFormFactor.h"
0018 #include "ThePEG/StandardModel/StandardModelBase.h"
0019 #include "ThePEG/Helicity/LorentzPolarizationVector.h"
0020 #include "Herwig/Models/StandardModel/StandardCKM.h"
0021
0022 namespace Herwig {
0023 using namespace ThePEG;
0024
0025 /** \ingroup Decay
0026  *
0027  * The <code>ScalarMesonFactorizedDecayer</code> class is a class which combines a
0028  * WeakCurrent and a ScalarFormFactor in the naive factorization approximation
0029  * to perform the non-leptonic weak decays of scalar mesons.
0030  *
0031  * @see DecayIntegrator
0032  * @see WeakCurrent
0033  * @see ScalarFormFactor
0034  *
0035  */
0036
0037 class ScalarMesonFactorizedDecayer: public DecayIntegrator {
0038
0039 public:
0040
0041   /**
0042    * The default constructor.
0043    */
0044   ScalarMesonFactorizedDecayer();
0045
0046 public:
0047
0048   /** @name Virtual functions required by the Decayer and DecayIntegrator classes. */
0049   //@{
0050   /**
0051    * Which of the possible decays is required
0052    * @param cc Is this mode the charge conjugate
0053    * @param parent The decaying particle
0054    * @param children The decay products
0055    */
0056   virtual int modeNumber(bool & cc, tcPDPtr parent,
0057              const tPDVector & children) const;
0058
0059   /**
0060    * Check if this decayer can perfom the decay for a particular mode.
0061    * Uses the modeNumber member but can be overridden
0062    * @param parent The decaying particle
0063    * @param children The decay products
0064    */
0065   virtual bool accept(tcPDPtr parent, const tPDVector & children) const;
0066
0067   /**
0068    * Return the matrix element squared for a given mode and phase-space channel.
0069    * @param ichan The channel we are calculating the matrix element for.
0070    * @param part The decaying Particle.
0071    * @param outgoing The particles produced in the decay
0072    * @param momenta  The momenta of the particles produced in the decay
0073    * @param meopt Option for the calculation of the matrix element
0074    * @return The matrix element squared for the phase-space configuration.
0075    */
0076   double me2(const int ichan,const Particle & part,
0077          const tPDVector & outgoing,
0078          const vector<Lorentz5Momentum> & momenta,
0079          MEOption meopt) const;
0080
0081   /**
0082    *   Construct the SpinInfos for the particles produced in the decay
0083    */
0084   virtual void constructSpinInfo(const Particle & part,
0085                  ParticleVector outgoing) const;
0086   //@}
0087
0088   /**
0089    * Output the setup information for the particle database
0090    * @param os The stream to output the information to
0091    * @param header Whether or not to output the information for MySQL
0092    */
0093   virtual void dataBaseOutput(ofstream & os,bool header) const;
0094
0095 public:
0096
0097   /** @name Functions used by the persistent I/O system. */
0098   //@{
0099   /**
0100    * Function used to write out object persistently.
0101    * @param os the persistent output stream written to.
0102    */
0103   void persistentOutput(PersistentOStream & os) const;
0104
0105   /**
0106    * Function used to read in object persistently.
0107    * @param is the persistent input stream read from.
0108    * @param version the version number of the object when written.
0109    */
0110   void persistentInput(PersistentIStream & is, int version);
0111   //@}
0112
0113   /**
0114    * The standard Init function used to initialize the interfaces.
0115    * Called exactly once for each class by the class description system
0116    * before the main function starts or
0117    * when this class is dynamically loaded.
0118    */
0119   static void Init();
0120
0121 protected:
0122
0123   /** @name Clone Methods. */
0124   //@{
0125   /**
0126    * Make a simple clone of this object.
0127    * @return a pointer to the new object.
0128    */
0129   virtual IBPtr clone() const {return new_ptr(*this);}
0130
0131   /** Make a clone of this object, possibly modifying the cloned object
0132    * to make it sane.
0133    * @return a pointer to the new object.
0134    */
0135   virtual IBPtr fullclone() const {return new_ptr(*this);}
0136   //@}
0137
0138 protected:
0139
0140   /** @name Standard Interfaced functions. */
0141   //@{
0142   /**
0143    * Initialize this object after the setup phase before saving and
0144    * EventGenerator to disk.
0145    * @throws InitException if object could not be initialized properly.
0146    */
0147   virtual void doinit();
0148
0149   /**
0150    * Initialize this object. Called in the run phase just before
0151    * a run begins.
0152    */
0153   virtual void doinitrun();
0154
0155   /**
0156    * Rebind pointer to other Interfaced objects. Called in the setup phase
0157    * after all objects used in an EventGenerator has been cloned so that
0158    * the pointers will refer to the cloned objects afterwards.
0159    * @param trans a TranslationMap relating the original objects to
0160    * their respective clones.
0161    * @throws RebindException if no cloned object was found for a given
0162    * pointer.
0163    */
0164   virtual void rebind(const TranslationMap & trans)
0165    ;
0166
0167   /**
0168    * Return a vector of all pointers to Interfaced objects used in this
0169    * object.
0170    * @return a vector of pointers.
0171    */
0172   virtual IVector getReferences();
0173   //@}
0174
0175
0176 private:
0177
0178   /**
0179    * Find duplicate modes in the list of particles
0180    * @param imode The mode we are studying
0181    * @param incoming The incoming particles for the different modes
0182    * @param outgoing The outgoing particles for the different modes
0183    * @param loc The location of the duplicate mode
0184    * @param cc  If the duplicate is the charge conjugate
0185    */
0186   void findModes(unsigned int imode, tPDVector & incoming,
0187          vector<tPDVector> & outgoing,
0188          vector<unsigned int> & loc,vector<bool> & cc);
0189
0190 private:
0191
0192   /**
0193    * The assignment operator is private and must never be called.
0194    * In fact, it should not even be implemented.
0195    */
0196   ScalarMesonFactorizedDecayer & operator=(const ScalarMesonFactorizedDecayer &) = delete;
0197
0198 private:
0199
0200   /**
0201    *  The weak decay current
0202    */
0203   vector<WeakCurrentPtr> _current;
0204
0205   /**
0206    * The baryon form factor
0207    */
0208   vector<ScalarFormFactorPtr> _form;
0209
0210   /**
0211    *  The perturbative coefficients
0212    */
0213   //@{
0214   /**
0215    *  The perturbative \f$a_1\f$ coefficient for b decays.
0216    */
0217   double _a1b;
0218
0219   /**
0220    *  The perturbative \f$a_2\f$ coefficient for b decays.
0221    */
0222   double _a2b;
0223
0224   /**
0225    *  The perturbative \f$a_1\f$ coefficient for c decays.
0226    */
0227   double _a1c;
0228
0229   /**
0230    *  The perturbative \f$a_2\f$ coefficient for c decays.
0231    */
0232   double _a2c;
0233   //@}
0234
0235   /**
0236    * Mapping of the modes to the currents
0237    */
0238   //@{
0239   /**
0240    *  First map
0241    */
0242   vector<vector<unsigned int> > _currentmapA;
0243
0244   /**
0245    *  Second map
0246    */
0247   vector<vector<unsigned int> > _currentmapB;
0248   //@}
0249
0250   /**
0251    * Mapping of the modes to the form factors
0252    */
0253   //@{
0254   /**
0255    *  First map
0256    */
0257   vector<vector<unsigned int> > _formmapA;
0258
0259   /**
0260    *  Second map
0261    */
0262   vector<vector<unsigned int> > _formmapB;
0263   //@}
0264   /**
0265    *  Outgoing particle from the form factor
0266    */
0267   vector<vector<unsigned int> > _formpart;
0268
0269   /**
0270    * The CKM factors
0271    */
0272   vector<vector<Complex> > _CKMfact;
0273
0274   /**
0275    * location of the weights
0276    */
0277   vector<int> _wgtloc;
0278
0279   /**
0280    * the maximum weights
0281    */
0282   vector<double> _wgtmax;
0283
0284   /**
0285    *  Weights for the different channels
0286    */
0287   vector<double> _weights;
0288
0289   /**
0290    * Pointer to the CKM object.
0291    */
0292   Ptr<StandardCKM>::pointer _ckm;
0293
0294   /**
0295    *  Spin density matrix
0296    */
0297   mutable RhoDMatrix _rho;
0298
0299   /**
0300    *  Polarization vectors for the decay products
0301    */
0302   mutable vector<vector<Helicity::LorentzPolarizationVector> > _vectors;
0303
0304   /**
0305    *  Polarization tensors for the decay products
0306    */
0307   mutable vector<vector<Helicity::LorentzTensor<double>    > > _tensors;
0308
0309 };
0310
0311 }
0312
0313 #endif /* HERWIG_ScalarMesonFactorizedDecayer_H */