Tree2toNDiagram.h

// -*- C++ -*-
//
// Tree2toNDiagram.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_Tree2toNDiagram_H
#define ThePEG_Tree2toNDiagram_H
// This is the declaration of the Tree2toNDiagram class.

#include "ThePEG/MatrixElement/DiagramBase.h"
#include "ThePEG/MatrixElement/ColourLines.h"
#include "ThePEG/Handlers/StandardXComb.fh"
#include "Tree2toNDiagram.xh"

namespace ThePEG {

class Tree2toNDiagram: public DiagramBase {

public:

  typedef cPDVector::size_type size_type;
  typedef multiset<tcPDPtr> PDMSet;

public:

  Tree2toNDiagram()
    : theNSpace(0), theNOutgoing(0), nextOrig(0) {}

  ~Tree2toNDiagram();

  explicit Tree2toNDiagram(int space) 
    : theNSpace(space), theNOutgoing(0), nextOrig(-1) {}

public:

  Tree2toNDiagram & operator,(int o) {
    nextOrig = o - 1;
    if ( o < 0 ) check();
    return *this;
  }

  Tree2toNDiagram & operator,(PDPtr pd) { return add(pd); }

  Tree2toNDiagram & operator,(cPDPtr pd) { return add(pd); }

  Tree2toNDiagram & operator,(tPDPtr pd) { return add(pd); }

  Tree2toNDiagram & operator,(tcPDPtr pd) { return add(pd); }

  virtual tPVector construct(SubProPtr sb, const StandardXComb &,
                             const ColourLines &) const;

  tcPDPair incoming() const;

  const cPDVector & allPartons() const { return thePartons; }

  tcPDVector outgoing() const;

  tcPDVector external() const;

  int parent(int i) const { return theParents[i]; }

  pair<int,int> children(int) const;

  int nSpace() const { return theNSpace; }

  void resize(size_type nSpace) {
    theNSpace = max(nSpace,theNSpace);
  }

  int nOutgoing() const { return theNOutgoing; }

private:

  void check();

  void addSpacelike(tcPDPtr pd) {
    if ( thePartons.size() >= theNSpace ) throw Tree2toNDiagramError();
    theParents.push_back(thePartons.size() - 1);
    thePartons.push_back(pd);
  }
  void addTimelike(tcPDPtr);

  void addTimelike(tcPDPtr, size_type origin);

  Tree2toNDiagram & add(tcPDPtr);

public:

  virtual bool isSame(tcDiagPtr) const;

  virtual bool isSame(tcDiagPtr, map<int,int>&) const;

  bool equals(Ptr<Tree2toNDiagram>::tcptr, int start=0, int startCmp=0) const;

  bool equals(Ptr<Tree2toNDiagram>::tcptr, 
              map<int,int>&,
              int start=0, int startCmp=0) const;

  int mergeEmission(int emitter, int id, map<int,int>& remap);

  int externalId(int id) const;

  int diagramId(int id) const;

public:

  void persistentOutput(PersistentOStream & os) const;

  void persistentInput(PersistentIStream & is, int version);

private:

  size_type theNSpace;

  int theNOutgoing;

  int nextOrig;

  cPDVector thePartons;

  vector<int> theParents;

private:

  static ClassDescription<Tree2toNDiagram> initTree2toNDiagram;

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

};

}

namespace ThePEG {

template <>
struct BaseClassTrait<Tree2toNDiagram,1>: public ClassTraitsType {
  typedef DiagramBase NthBase;
};

template <>
struct ClassTraits<Tree2toNDiagram>: public ClassTraitsBase<Tree2toNDiagram> {
  static string className() { return "ThePEG::Tree2toNDiagram"; }
};

}

#endif /* ThePEG_Tree2toNDiagram_H */