EIC code displayed by LXR master/​include/​Herwig/​MatrixElement/​Matchbox/​Utility/​SimpleColourBasis2.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-08-06 09:24:15

 // -*- C++ -*-
 //
 // SimpleColourBasis2.h is a part of Herwig - A multi-purpose Monte Carlo event generator
 // Copyright (C) 2002-2019 The Herwig Collaboration
 //
 // Herwig is licenced under version 3 of the GPL, see COPYING for details.
 // Please respect the MCnet academic guidelines, see GUIDELINES for details.
 //
 #ifndef Herwig_SimpleColourBasis2_H
 #define Herwig_SimpleColourBasis2_H
 //
 // This is the declaration of the SimpleColourBasis2 class.
 //
 
 #include "Herwig/MatrixElement/Matchbox/Utility/ColourBasis.h"
 
 namespace Herwig {
 
 using namespace ThePEG;
 
 /**
  * \ingroup Matchbox
  * \author Simon Platzer
  *
  * \brief SimpleColourBasis2 implements the colour algebra needed for
  * processes with four coloured legs at NLO. It mainly serves as an
  * example for the general ColourBasis interface.
  *
  */
 class SimpleColourBasis2: public ColourBasis {
 
 public:
 
   /**
    * Prepare the basis for the normal ordered legs and return the
    * dimensionality of the basis.
    */
   virtual size_t prepareBasis(const vector<PDT::Colour>&);
 
   /**
    * Return the scalar product of basis tensors labelled a and b in
    * the basis used for the given normal ordered legs.
    */
   virtual double scalarProduct(size_t a, size_t b,
                    const vector<PDT::Colour>& abBasis) const;
 
   /**
    * Return the matrix element of a colour charge
    * <c_{n+1,a}|T_i|c_{n,b}> between basis tensors a and b, with
    * respect to aBasis and bBasis
    */
   virtual double tMatrixElement(size_t i, size_t a, size_t b,
                 const vector<PDT::Colour>& aBasis,
                 const vector<PDT::Colour>& bBasis,
                 size_t k, size_t l,
                 const map<size_t,size_t>& dict) const;
 
   /*
    * Temporary to make it compile
    */
   virtual double sMatrixElement(size_t, size_t, size_t,
                 const vector<PDT::Colour>&,
                 const vector<PDT::Colour>&,
                 size_t, size_t,
                 const map<size_t,size_t>&
                 ) const {
     assert( 0 == 1 );
     return 0;
   }
 
   /**
    * Return true, if this colour basis supports gluon splittings.
    */
   virtual bool canSplitGluons() const {
     return false;
   }
 
   /**
    * Return true, if a large-N colour connection exists for the
    * given external legs and basis tensor.
    */
   virtual bool colourConnected(const cPDVector&,
                    const vector<PDT::Colour>&,
                    const pair<int,bool>&, 
                    const pair<int,bool>&, 
                    size_t) const;
 
   /**
    * Return true, if the colour basis is capable of assigning colour
    * flows.
    */
   virtual bool haveColourFlows() const { return true; }
 
   /**
    * Create ids for bases
    */
   void makeIds() const;
 
   /**
    * Return a map of basis tensor indices to vectors identifying a
    * certain ordering corresponding to the given colour structure. May
    * not be supported by all colour basis implementations.
    */
   virtual map<size_t,vector<vector<size_t> > > basisList(const vector<PDT::Colour>&) const;
 
 public:
 
   /** @name Functions used by the persistent I/O system. */
   //@{
   /**
    * Function used to write out object persistently.
    * @param os the persistent output stream written to.
    */
   void persistentOutput(PersistentOStream & os) const;
 
   /**
    * Function used to read in object persistently.
    * @param is the persistent input stream read from.
    * @param version the version number of the object when written.
    */
   void persistentInput(PersistentIStream & is, int version);
   //@}
 
   /**
    * The standard Init function used to initialize the interfaces.
    * Called exactly once for each class by the class description system
    * before the main function starts or
    * when this class is dynamically loaded.
    */
   static void Init();
 
 protected:
 
   /** @name Clone Methods. */
   //@{
   /**
    * Make a simple clone of this object.
    * @return a pointer to the new object.
    */
   virtual IBPtr clone() const;
 
   /** Make a clone of this object, possibly modifying the cloned object
    * to make it sane.
    * @return a pointer to the new object.
    */
   virtual IBPtr fullclone() const;
   //@}
 
 
 // If needed, insert declarations of virtual function defined in the
 // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs).
 
 
 private:
 
   /**
    * id for 88
    */
   mutable vector<PDT::Colour> id88;
 
   /**
    * id for 33bar
    */
   mutable vector<PDT::Colour> id33bar;
 
   /**
    * id for 888
    */
   mutable vector<PDT::Colour> id888;
 
   /**
    * id for 33bar8
    */
   mutable vector<PDT::Colour> id33bar8;
 
   /**
    * id for 8888
    */
   mutable vector<PDT::Colour> id8888;
 
   /**
    * id for 33bar88
    */
   mutable vector<PDT::Colour> id33bar88;
 
   /**
    * id for 33bar33bar
    */
   mutable vector<PDT::Colour> id33bar33bar;
 
   /**
    * id for 88888
    */
   mutable vector<PDT::Colour> id88888;
 
   /**
    * id for 33bar888
    */
   mutable vector<PDT::Colour> id33bar888;
 
   /**
    * id for 33bar33bar8
    */
   mutable vector<PDT::Colour> id33bar33bar8;
 
 private:
 
   /**
    * The assignment operator is private and must never be called.
    * In fact, it should not even be implemented.
    */
   SimpleColourBasis2 & operator=(const SimpleColourBasis2 &) = delete;
 
 };
 
 }
 
 #endif /* Herwig_SimpleColourBasis2_H */

This page was automatically generated by the 2.3.7 LXR engine. The LXR team