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