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 */