Decay/Baryon/BaryonFactorizedDecayer.h

0001 // -*- C++ -*-
0002 #ifndef HERWIG_BaryonFactorizedDecayer_H
0003 #define HERWIG_BaryonFactorizedDecayer_H
0004 //
0005 // This is the declaration of the BaryonFactorizedDecayer class.
0006 //
0007
0008 #include "Herwig/Decay/DecayIntegrator.h"
0009 #include "Herwig/Decay/WeakCurrents/WeakCurrent.h"
0010 #include "Herwig/Decay/FormFactors/BaryonFormFactor.h"
0011 #include "ThePEG/StandardModel/StandardModelBase.h"
0012 #include "ThePEG/Helicity/LorentzPolarizationVector.h"
0013 #include "Herwig/Decay/PhaseSpaceMode.h"
0014 #include "Herwig/Models/StandardModel/StandardCKM.h"
0015 #include "ThePEG/Helicity/LorentzRSSpinorBar.h"
0016
0017 namespace Herwig {
0018 using namespace ThePEG;
0019
0020 /** \ingroup Decay
0021  *
0022  * The BaryonFactorizedDecayer class is designed to combine the form factor
0023  * for a weak baryon transition and a weak decay current to produce a decayer.
0024  * It is mainly based on the results of PRD56, 2799.
0025  *
0026  * @see BaryonFactorizedDecayer
0027  * @see BaryonFormFactor
0028  * @see WeakCurrent
0029  */
0030 class BaryonFactorizedDecayer: public DecayIntegrator {
0031
0032 public:
0033
0034   /**
0035    * The default constructor.
0036    */
0037   BaryonFactorizedDecayer();
0038
0039   /**
0040    * Check if this decayer can perfom the decay for a particular mode.
0041    * @param parent The decaying particle
0042    * @param children The decay products
0043    */
0044   virtual bool accept(tcPDPtr parent, const tPDVector & children) const;
0045
0046   /**
0047    * Which of the possible decays is required
0048    * @param cc Is this mode the charge conjugate
0049    * @param parent The decaying particle
0050    * @param children The decay products
0051    */
0052   virtual int modeNumber(bool & cc, tcPDPtr parent,
0053              const tPDVector & children) const;
0054
0055   /**
0056    * Return the matrix element squared for a given mode and phase-space channel.
0057    * @param ichan The channel we are calculating the matrix element for.
0058    * @param part The decaying Particle.
0059    * @param outgoing The particles produced in the decay
0060    * @param momenta  The momenta of the particles produced in the decay
0061    * @param meopt Option for the calculation of the matrix element
0062    * @return The matrix element squared for the phase-space configuration.
0063    */
0064   double me2(const int ichan,const Particle & part,
0065          const tPDVector & outgoing,
0066          const vector<Lorentz5Momentum> & momenta,
0067          MEOption meopt) const;
0068
0069   /**
0070    *   Construct the SpinInfos for the particles produced in the decay
0071    */
0072   virtual void constructSpinInfo(const Particle & part,
0073                  ParticleVector outgoing) const;
0074
0075   /**
0076    * Output the setup information for the particle database
0077    * @param os The stream to output the information to
0078    * @param header Whether or not to output the information for MySQL
0079    */
0080   virtual void dataBaseOutput(ofstream & os,bool header) const;
0081
0082 protected:
0083
0084   /**
0085    * Matrix element for \f$\frac12\to\frac12\f$.
0086    * @param ichan The channel we are calculating the matrix element for.
0087    * @param part The decaying Particle.
0088    * @param outgoing The particles produced in the decay
0089    * @param momenta  The momenta of the particles produced in the decay
0090    * @param meopt Option for the calculation of the matrix element
0091    * @return The matrix element squared for the phase-space configuration.
0092    */
0093   double halfHalf(const int ichan,
0094           const Particle & part,
0095           const tPDVector & outgoing,
0096           const vector<Lorentz5Momentum> & momenta,
0097           MEOption meopt) const;
0098
0099   /**
0100    * Matrix element for \f$\frac12\to\frac32\f$.
0101    * @param ichan The channel we are calculating the matrix element for.
0102    * @param part The decaying Particle.
0103    * @param outgoing The particles produced in the decay
0104    * @param momenta  The momenta of the particles produced in the decay
0105    * @param meopt Option for the calculation of the matrix element
0106    * @return The matrix element squared for the phase-space configuration.
0107    */
0108   double halfThreeHalf(const int ichan,
0109                const Particle & part,
0110                const tPDVector & outgoing,
0111                const vector<Lorentz5Momentum> & momenta,
0112                MEOption meopt) const;
0113
0114 public:
0115
0116   /** @name Functions used by the persistent I/O system. */
0117   //@{
0118   /**
0119    * Function used to write out object persistently.
0120    * @param os the persistent output stream written to.
0121    */
0122   void persistentOutput(PersistentOStream & os) const;
0123
0124   /**
0125    * Function used to read in object persistently.
0126    * @param is the persistent input stream read from.
0127    * @param version the version number of the object when written.
0128    */
0129   void persistentInput(PersistentIStream & is, int version);
0130   //@}
0131
0132   /**
0133    * The standard Init function used to initialize the interfaces.
0134    * Called exactly once for each class by the class description system
0135    * before the main function starts or
0136    * when this class is dynamically loaded.
0137    */
0138   static void Init();
0139
0140 protected:
0141
0142   /** @name Clone Methods. */
0143   //@{
0144   /**
0145    * Make a simple clone of this object.
0146    * @return a pointer to the new object.
0147    */
0148   virtual IBPtr clone() const {return new_ptr(*this);}
0149
0150   /** Make a clone of this object, possibly modifying the cloned object
0151    * to make it sane.
0152    * @return a pointer to the new object.
0153    */
0154   virtual IBPtr fullclone() const {return new_ptr(*this);}
0155   //@}
0156
0157 protected:
0158
0159   /** @name Standard Interfaced functions. */
0160   //@{
0161
0162   /**
0163    * Initialize this object after the setup phase before saving and
0164    * EventGenerator to disk.
0165    * @throws InitException if object could not be initialized properly.
0166    */
0167   virtual void doinit();
0168
0169   /**
0170    * Initialize this object. Called in the run phase just before
0171    * a run begins.
0172    */
0173   virtual void doinitrun();
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,
0187          tPDVector & incoming,
0188          vector<tPDVector> & outgoing,
0189          vector<unsigned int> & loc,vector<bool> & cc);
0190
0191 private:
0192
0193   /**
0194    * The assignment operator is private and must never be called.
0195    * In fact, it should not even be implemented.
0196    */
0197   BaryonFactorizedDecayer & operator=(const BaryonFactorizedDecayer &) = delete;
0198
0199 private:
0200
0201   /**
0202    *  The weak decay current
0203    */
0204   WeakCurrentPtr _current;
0205
0206   /**
0207    * The baryon form factor
0208    */
0209   BaryonFormFactorPtr _form;
0210
0211   /**
0212    *  The perturbative coefficients
0213    */
0214   //@{
0215   /**
0216    *  The perturbative \f$a_1\f$ coefficient for b decays.
0217    */
0218   double _a1b;
0219
0220   /**
0221    *  The perturbative \f$a_2\f$ coefficient for b decays.
0222    */
0223   double _a2b;
0224
0225   /**
0226    *  The perturbative \f$a_1\f$ coefficient for c decays.
0227    */
0228   double _a1c;
0229
0230   /**
0231    *  The perturbative \f$a_2\f$ coefficient for c decays.
0232    */
0233   double _a2c;
0234   //@}
0235
0236   /**
0237    * Mapping of the modes to the currents
0238    */
0239   vector<vector<unsigned int> > _currentmap;
0240
0241   /**
0242    * Mapping of the modes to the form factors
0243    */
0244   vector<vector<unsigned int> > _formmap;
0245
0246   /**
0247    * The CKM factors
0248    */
0249   vector<vector <Complex> > _factCKM;
0250
0251   /**
0252    * location of the weights
0253    */
0254   vector<int> _wgtloc;
0255
0256   /**
0257    * the maximum weights
0258    */
0259   vector<double> _wgtmax;
0260
0261   /**
0262    *  weights for the different channels
0263    */
0264   vector<double> _weights;
0265
0266   /**
0267    * Pointer to the CKM object.
0268    */
0269   Ptr<StandardCKM>::pointer _theCKM;
0270
0271   /**
0272    *  Spin density matrix
0273    */
0274   mutable RhoDMatrix _rho;
0275
0276   /**
0277    *   Spin-\f$\frac12\f$ spinors
0278    */
0279   mutable vector<LorentzSpinor<SqrtEnergy> > _inHalf;
0280
0281   /**
0282    *   Spin-\f$\frac12\f$ barred spinors
0283    */
0284   mutable vector<LorentzSpinorBar<SqrtEnergy> > _inHalfBar;
0285
0286   /**
0287    *   Spin-\f$\frac32\f$ spinors
0288    */
0289   mutable vector<LorentzRSSpinor<SqrtEnergy> > _inThreeHalf;
0290
0291   /**
0292    *   Spin-\f$\frac32\f$ barred spinors
0293    */
0294   mutable vector<LorentzRSSpinorBar<SqrtEnergy> > _inThreeHalfBar;
0295 };
0296
0297 }
0298
0299 #endif /* HERWIG_BaryonFactorizedDecayer_H */