ColourSinglet.h

// -*- C++ -*-
//
// ColourSinglet.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
//
// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef ThePEG_ColourSinglet_H
#define ThePEG_ColourSinglet_H
 
#include "ThePEG/EventRecord/EventConfig.h"
 
namespace ThePEG {
 
class ColourSinglet {
 
public:
 
  typedef deque<tcPPtr> StringPiece;
  typedef StringPiece::size_type Index;
  typedef pair<Index,Index> Junction;
 
public:
 
  ColourSinglet() {}
 
  ColourSinglet(tcColinePtr cl, tcParticleSet & left);
 
protected:
 
  ColourSinglet(const ColourSinglet & cs, Index si);
 
public:
 
  tcPVector & partons() { return thePartons; }
 
  const tcPVector & partons() const { return thePartons; }
 
  tcPPtr parton(tcPVector::size_type i) const { return thePartons[i]; }
 
  LorentzMomentum momentum() const;
 
  Index nPieces() const { return thePieces.size(); }
 
  StringPiece & piece(Index i) { return thePieces[i - 1]; }
 
  const StringPiece & piece(Index i) const { return thePieces[i - 1]; }
 
  Junction & junction(Index i, bool forward) {
    return forward ? sink(i) : source(i);
  }
 
  const Junction & junction(Index i, bool forward) const {
    return forward ? sink(i) : source(i);
  }
 
  Junction & sink(Index i) { return theSinks[i - 1]; }
 
  const Junction & sink(Index i) const { return theSinks[i - 1]; }
 
  Junction & source(Index i) { return theSources[i - 1]; }
  const Junction & source(Index i) const { return theSources[i - 1]; }
 
  static vector<ColourSinglet> getSinglets(tcParticleSet & left);
 
  template <typename Iterator>
  static vector<ColourSinglet>
  getSinglets(Iterator first, Iterator last) {
    tcParticleSet pset(first, last);
    return getSinglets(pset);
  }
 
  tcPDVector getTripletData() const;
 
  ColourSinglet splitInternal(Index sp = 0);
 
  ColourSinglet splitInternal(Index sp, Index sa, Index sc,
                              const vector<bool> & assing);
 
  ColourSinglet
  splitDiQuarkJunction(Index sp, tcPPtr diq, tcPPair qq,
                       const vector<bool> & assign = vector<bool>());
 
  ColourSinglet splitDiDiQuark(tcPPair qq1, tcPPair qq2,
                               const vector<bool> & assign = vector<bool>());
 
  void swap(ColourSinglet & x) {
    thePartons.swap(x.thePartons);
    thePieces.swap(x.thePieces);
    theSources.swap(x.theSources);
    theSinks.swap(x.theSinks);
  }
 
private:
 
  bool fill(Index s0, bool forward, tcColinePtr first, tcParticleSet & left);
 
  void fill(Index i0, bool forward, const ColourSinglet & cs, Index i1);
 
  Index addPiece() {
    thePieces.push_back(StringPiece());
    theSinks.push_back(Junction());
    theSources.push_back(Junction());
    return nPieces();
  }
 
  Junction addJunction(Index s0, bool forward);
 
public:
 
  class ColourSingletException: public Exception {};
private:
 
  tcPVector thePartons;
 
  vector<StringPiece> thePieces;
 
  vector<Junction> theSources;
 
  vector<Junction> theSinks;
 
};
 
}
 
#endif /* ThePEG_ColourSinglet_H */