ColourLine.h

// -*- C++ -*-
//
// ColourLine.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_ColourLine_H
#define ThePEG_ColourLine_H
// This is the declaration of the ColourLine class.

#include "EventConfig.h"
#include "ThePEG/Utilities/ClassDescription.h"
#include "ThePEG/EventRecord/ColourSinglet.h"

namespace ThePEG {

class ColourLine: public EventRecordBase {

public:

  static tColinePtr create(tPPtr col, tPPtr anti);

  static tColinePtr create(tPPtr p, bool anti = false);

  static tColinePtr createAnti(tPPtr p) { return create(p, true); }

  static tColinePtr create(tColinePtr son1, tColinePtr son2,
                           tColinePtr sin1, tColinePtr sin2);

  virtual ~ColourLine();

public:

  const tPVector & coloured() const { return theColoured; }

  const tPVector & antiColoured() const { return theAntiColoured; }

  tPPtr startParticle() const;

  tPPtr endParticle() const;


  void addAntiColoured(tPPtr);

  void addColoured(tPPtr p, bool anti = false);

  void addAntiColouredIndexed(tPPtr p, int index);

  void addColouredIndexed(tPPtr p, int index, bool anti=false);

  void removeAntiColoured(tPPtr);

  void removeColoured(tPPtr p, bool anti = false);


  tColinePair sinkNeighbours() const { return theSinkNeighbours; }

  tColinePair sourceNeighbours(bool anti = false) const {
    return anti? theSinkNeighbours: theSourceNeighbours;
  }

  void setSinkNeighbours(tColinePtr l1, tColinePtr l2) {
    theSinkNeighbours.second = l1->theSinkNeighbours.second = l2;
    l2->theSinkNeighbours.second = theSinkNeighbours.first = l1;
    l1->theSinkNeighbours.first = l2->theSinkNeighbours.first = this;
  }

  void setSourceNeighbours(tColinePtr l1, tColinePtr l2) {
    theSourceNeighbours.second = l1->theSourceNeighbours.second = l2;
    l2->theSourceNeighbours.second = theSourceNeighbours.first = l1;
    l1->theSourceNeighbours.first = l2->theSourceNeighbours.first = this;
  }


  bool join(ColinePtr line);

  template <typename Iterator>
  typename std::iterator_traits<Iterator>::value_type
  getColouredParticle(Iterator first, Iterator last, bool anti = false) const {
    typedef typename std::iterator_traits<Iterator>::value_type ParticlePointer;
    for ( ; first != last; ++first )
      if ( (**first).coloured() && (**first).hasColourLine(this, anti) )
        return *first;
    return ParticlePointer();
  }

  void write(ostream & os, tcEventPtr event, bool anti) const;

public:

  void persistentOutput(PersistentOStream &) const;

  void persistentInput(PersistentIStream &, int);

private:

  tPVector theColoured;

  tPVector theAntiColoured;

  tColinePair theSourceNeighbours;

  tColinePair theSinkNeighbours;

  vector<ColinePtr> orphanedConnectors;

private:

  static ClassDescription<ColourLine> initColourLine;

  ColourLine & operator=(const ColourLine &) = delete;

};

}


namespace ThePEG {

template <>
struct BaseClassTrait<ColourLine,1>: public ClassTraitsType {
  typedef EventRecordBase NthBase;
};

template <>
struct ClassTraits<ColourLine>: public ClassTraitsBase<ColourLine> {
  static string className() { return "ThePEG::ColourLine"; }
  static string library() { return "ColourLine.so"; }
};

}

#endif /* ThePEG_ColourLine_H */