Matchbox/ColorFull/TraceBasis.h

0001 // -*- C++ -*-
0002 //
0003 // TraceBasis.h is a part of ColorFull
0004 // Copyright (C) 2010-2011 Simon Platzer & Malin Sjodahl
0005 //
0006 // ColorFull 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 COLORFULL_TraceBasis_H
0010 #define COLORFULL_TraceBasis_H
0011 //
0012 // This is the declaration of the TraceBasis class.
0013 //
0014
0015 #include "Herwig/MatrixElement/Matchbox/Utility/ColourBasis.h"
0016 #include "Trace_basis.h"
0017
0018 namespace ColorFull {
0019
0020 using namespace ThePEG;
0021 using namespace Herwig;
0022
0023 /**
0024  * TraceBasis implements the trace colour basis.
0025  *
0026  * @see \ref TraceBasisInterfaces "The interfaces"
0027  * defined for TraceBasis.
0028  */
0029 class TraceBasis: public Herwig::ColourBasis {
0030
0031 public:
0032
0033   /** @name Standard constructors and destructors. */
0034   //@{
0035   /**
0036    * The default constructor.
0037    */
0038   TraceBasis();
0039
0040   /**
0041    * The destructor.
0042    */
0043   virtual ~TraceBasis();
0044   //@}
0045
0046 public:
0047
0048   /**
0049    * Clear this colour basis
0050    */
0051   virtual void clear();
0052
0053   /**
0054    * Return a map of basis tensor indices to vectors identifying a
0055    * certain ordering corresponding to the given colour structure. May
0056    * not be supported by all colour basis implementations.
0057    */
0058   virtual map<size_t,vector<vector<size_t> > > basisList(const vector<PDT::Colour>&) const;
0059
0060   /**
0061    * Prepare the basis for the normal ordered legs and return the
0062    * dimensionality of the basis.
0063    */
0064   virtual size_t prepareBasis(const vector<PDT::Colour>&);
0065
0066   /**
0067    * Gather any implementation dependend details when reading a basis
0068    */
0069   virtual void readBasisDetails(const vector<PDT::Colour>&);
0070
0071   /**
0072    * Return the scalar product of basis tensors labelled a and b in
0073    * the basis used for the given normal ordered legs.
0074    */
0075   virtual double scalarProduct(size_t a, size_t b,
0076                    const vector<PDT::Colour>& abBasis) const;
0077
0078   /**
0079    * Return true, if this colour basis supports gluon splittings.
0080    */
0081   virtual bool canSplitGluons() const {
0082     return false;
0083   }
0084
0085   /**
0086    * Return the matrix element of a colour charge
0087    * <c_{n+1,a}|T_i|c_{n,b}> between basis tensors a and b, with
0088    * respect to aBasis and bBasis
0089    */
0090   virtual double tMatrixElement(size_t i, size_t a, size_t b,
0091                 const vector<PDT::Colour>& aBasis,
0092                 const vector<PDT::Colour>& bBasis,
0093                 size_t k, size_t l,
0094                 const map<size_t,size_t>& dict) const;
0095
0096   /**
0097    * Return the matrix element of a quark splitting matrix
0098    * <c_{n+1,a}|T_i|c_{n,b}> between basis tensors a and b, with
0099    * respect to aBasis and bBasis. Here
0100    * m is splitting gluon,
0101    * i is the new vector number in the new large aBasis,
0102    * j is the old vector number in the old small bBasis,
0103    * k is the number of the new q,
0104    * l is the number of the new qbar,
0105    * and dict contains the map from old to new numbers, of the partons not participating.
0106    * All parton numbers are given in Herwig conventions.
0107    */
0108   virtual double sMatrixElement(size_t i, size_t a, size_t b,
0109                 const vector<PDT::Colour>& aBasis,
0110                 const vector<PDT::Colour>& bBasis,
0111                 size_t k, size_t l,
0112                 const map<size_t,size_t>& dict) const;
0113
0114   /**
0115    * Return true, if the colour basis is capable of assigning colour
0116    * flows.
0117    */
0118   virtual bool haveColourFlows() const { return true; }
0119
0120   /**
0121    * Return true, if a large-N colour connection exists for the
0122    * given external legs and basis tensor.
0123    */
0124   virtual bool colourConnected(const cPDVector&,
0125                    const vector<PDT::Colour>&,
0126                    const pair<int,bool>&,
0127                    const pair<int,bool>&,
0128                    size_t) const;
0129
0130   /**
0131    * Returns a map of how the order of the vectors of a colour basis are
0132    * changed when the indices are changed.
0133    */
0134   virtual map<size_t,size_t> indexChange(const vector<PDT::Colour>& basis,
0135                      const size_t dim,
0136                      const map<size_t,size_t>& legPerm) const;
0137
0138
0139 public:
0140
0141   /** @name Functions used by the persistent I/O system. */
0142   //@{
0143   /**
0144    * Function used to write out object persistently.
0145    * @param os the persistent output stream written to.
0146    */
0147   void persistentOutput(PersistentOStream & os) const;
0148
0149   /**
0150    * Function used to read in object persistently.
0151    * @param is the persistent input stream read from.
0152    * @param version the version number of the object when written.
0153    */
0154   void persistentInput(PersistentIStream & is, int version);
0155   //@}
0156
0157   /**
0158    * The standard Init function used to initialize the interfaces.
0159    * Called exactly once for each class by the class description system
0160    * before the main function starts or
0161    * when this class is dynamically loaded.
0162    */
0163   static void Init();
0164
0165 protected:
0166
0167   /** @name Clone Methods. */
0168   //@{
0169   /**
0170    * Make a simple clone of this object.
0171    * @return a pointer to the new object.
0172    */
0173   virtual IBPtr clone() const;
0174
0175   /** Make a clone of this object, possibly modifying the cloned object
0176    * to make it sane.
0177    * @return a pointer to the new object.
0178    */
0179   virtual IBPtr fullclone() const;
0180   //@}
0181
0182
0183 // If needed, insert declarations of virtual function defined in the
0184 // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs).
0185
0186 private:
0187
0188   /**
0189    * The color functions object to be used
0190    */
0191   mutable Col_functions colorFunctions;
0192
0193   /**
0194    * Map legs to known basis vectors.
0195    */
0196   mutable map<vector<PDT::Colour>,Trace_basis> theBasisMap;
0197
0198   /**
0199    * Memorize scalar product intermediate results.
0200    */
0201   mutable map<string,Polynomial> theScalarProducts;
0202
0203 private:
0204
0205   /**
0206    * The assignment operator is private and must never be called.
0207    * In fact, it should not even be implemented.
0208    */
0209   TraceBasis & operator=(const TraceBasis &) = delete;
0210
0211 };
0212
0213 }
0214
0215 #endif /* COLORFULL_TraceBasis_H */