ColourFlowBasis.h

// -*- C++ -*-
//
// ColourFlowBasis.h is a part of CVolver
// Copyright (C) 2013-2019 Simon Platzer, The Herwig Collaboration
//
// CVolver is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef CVOLVER_ColourFlowBasis_H
#define CVOLVER_ColourFlowBasis_H
//
// This is the declaration of the ColourFlowBasis class.
//
 
#include "Herwig/MatrixElement/Matchbox/Utility/ColourBasis.h"
#include "ColourFlows.h"
 
namespace CVolver {
 
using namespace ThePEG;
using namespace Herwig;
 
template<>
struct ParticleDataTraits<ThePEG::PDT::Colour> {
 
  static bool isSinglet(const ThePEG::PDT::Colour& pd) { 
    return pd == PDT::Colour0;
  }
 
  static bool isAntiFundamental(const ThePEG::PDT::Colour& pd) {
    return pd == PDT::Colour3bar;
  }
 
  static bool isFundamental(const ThePEG::PDT::Colour& pd) {
    return pd == PDT::Colour3;
  }
 
  static bool isAdjoint(const ThePEG::PDT::Colour& pd) {
    return pd == PDT::Colour8;
  }
 
};
 
class ColourFlowBasis: public Herwig::ColourBasis {
 
public:
 
  ColourFlowBasis();
 
  virtual ~ColourFlowBasis();
 
public:
 
  virtual void clear();
 
  virtual map<size_t,vector<vector<size_t> > > basisList(const vector<PDT::Colour>&) const;
 
  virtual size_t prepareBasis(const vector<PDT::Colour>&);
 
  virtual void readBasisDetails(const vector<PDT::Colour>&);
 
  virtual double scalarProduct(size_t a, size_t b,
                               const vector<PDT::Colour>& abBasis) const;
 
  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;
 
  virtual bool canSplitGluons() const {
    return false;
  }
 
  virtual double sMatrixElement(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;
 
  virtual bool haveColourFlows() const { return true; }
 
  virtual bool colourConnected(const cPDVector&,
                               const vector<PDT::Colour>&,
                               const pair<int,bool>&, 
                               const pair<int,bool>&, 
                               size_t) const;
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
 
// If needed, insert declarations of virtual function defined in the
// InterfacedBase class here (using ThePEG-interfaced-decl in Emacs).
 
private:
 
  map<vector<PDT::Colour>,ColourFlowCrossing> theCrossings;
 
  map<size_t,vector<ColourFlow> > theFlows;
 
private:
 
  ColourFlowBasis & operator=(const ColourFlowBasis &) = delete;
 
};
 
}
 
#endif /* CVOLVER_ColourFlowBasis_H */