Tree2toNGenerator.h

// -*- C++ -*-
//
// Tree2toNGenerator.h is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2019 The Herwig Collaboration
//
// Herwig is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef Herwig_Tree2toNGenerator_H
#define Herwig_Tree2toNGenerator_H
//
// This is the declaration of the Tree2toNGenerator class.
//
 
#include "ThePEG/Handlers/HandlerBase.h"
#include "ThePEG/Helicity/Vertex/VertexBase.h"
#include "ThePEG/MatrixElement/Tree2toNDiagram.h"
 
#include "ThePEG/Persistency/PersistentOStream.h"
#include "ThePEG/Persistency/PersistentIStream.h"
 
namespace Herwig {
 
using namespace ThePEG;
 
class Tree2toNGenerator: public HandlerBase {
 
public:
 
  Tree2toNGenerator();
 
public:
 
  vector<Ptr<Tree2toNDiagram>::ptr> generate(const PDVector&,
                                             unsigned int orderInGs,
                                             unsigned int orderInGem);
 
  typedef vector<Ptr<Helicity::VertexBase>::ptr> VertexVector;
 
  VertexVector& vertices() { return theVertices; }
 
  const VertexVector& vertices() const { return theVertices; }
 
  PDVector& excludeInternal() { return theExcludeInternal; }
 
  const PDVector& excludeInternal() const { return theExcludeInternal; }
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
public:
 
  struct Vertex {
 
    vector<Vertex> children;
 
    PDPtr parent;
 
    bool spacelike;
 
    int externalId;
 
    int parentId;
 
    Vertex()
      : spacelike(false), externalId(-1), parentId(-1) {}
 
    void print(ostream& os, const string& prefix = "") const {
      os << prefix << parent->PDGName()
         << "[" << (spacelike ? "s" : "t") << "] (";
      if ( externalId < 0 )
        os << "x)\n";
      else
        os << externalId << ")\n";
      if ( !children.empty() ) {
        os << prefix << "|__\n";
        children[0].print(os,prefix + "|  ");
        os << prefix << "|__\n";
        children[1].print(os,prefix + "|  ");
      }
    }
 
    int nspace() const {
      if ( children.empty() )
        return 1;
      int ret = 1;
      ret += children[0].nspace();
      return ret;
    }
 
    void update(Tree2toNDiagram& diag,
                map<int,pair<int,PDPtr> >& outgoing,
                int& lastUsed) {
      if ( externalId == 0 ) {
        assert(lastUsed==0);
        ++lastUsed;
        diag.operator,(parent);
        children[0].parentId = lastUsed;
        children[1].parentId = lastUsed;
        children[0].update(diag,outgoing,lastUsed);
        children[1].update(diag,outgoing,lastUsed);
        for ( map<int,pair<int,PDPtr> >::iterator out =
                outgoing.begin(); out != outgoing.end(); ++out ) {
          diag.operator,(out->second.first);
          diag.operator,(out->second.second);
        }
        return;
      }
      if ( spacelike ) {
        ++lastUsed;
        diag.operator,(parent);
        if ( externalId == 1 )
          return;
        children[0].parentId = lastUsed;
        children[1].parentId = lastUsed;
        children[0].update(diag,outgoing,lastUsed);
        children[1].update(diag,outgoing,lastUsed);
        return;
      }
      if ( children.empty() ) {
        outgoing[externalId] =
          make_pair(parentId,parent);
        return;
      }
      diag.operator,(parentId);
      diag.operator,(parent);
      ++lastUsed;
      children[0].parentId = lastUsed;
      children[1].parentId = lastUsed;
      children[0].update(diag,outgoing,lastUsed);
      children[1].update(diag,outgoing,lastUsed);
    }
 
    Tree2toNDiagram generate(int id) {
      int nsp = nspace();
      Tree2toNDiagram res(nsp);
      int diagid = 0;
      map<int,pair<int,PDPtr> > out;
      update(res,out,diagid);
      res.operator,(-id);
      return res;
    }
 
  };
 
  list<vector<Vertex> > cluster(const vector<Vertex>& children,
                                unsigned int orderInGs,
                                unsigned int orderInGem) const;
  
  list<vector<Vertex> > clusterAll(const list<vector<Vertex> >& current,
                                   unsigned int orderInGs,
                                   unsigned int orderInGem) const;
 
  list<vector<Vertex> > clusterAll(const PDVector& external,
                                   unsigned int orderInGs,
                                   unsigned int orderInGem);
 
  struct LineMatcher {
 
    set<tcPDPtr> particles;
 
    pair<int,int> range;
 
    int count;
 
    LineMatcher()
      : range(0,0), count(0) {}
 
    LineMatcher(const PDVector& p,
                const pair<int,int>& r)
      : range(r), count(0) {
      copy(p.begin(),p.end(),inserter(particles,particles.begin()));
    }
 
    void rebind(Tree2toNGenerator* g) {
      set<tcPDPtr> oldp = particles;
      particles.clear();
      for ( set<tcPDPtr>::const_iterator p = oldp.begin();
            p != oldp.end(); ++p )
        particles.insert(g->getParticleData((**p).id()));
    }
 
    void reset() {
      count = 0;
    }
 
    void add(tcPDPtr p, int n) {
      if ( particles.find(p) == particles.end() )
        return;
      count += n;
    }
 
    bool check() const {
      return
        count >= range.first && count <= range.second;
    }
 
  };
  
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
 
// If needed, insert declarations of virtual function defined in the
// InterfacedBase class here (using ThePEG-interfaced-decl in Emacs).
 
private:
 
  VertexVector theVertices;
 
  PDVector theExcludeInternal;
 
  unsigned int maxOrderGs;
 
  unsigned int maxOrderGem;
 
  bool prepared;
 
  VertexVector theExcludeVertices;
 
  vector<LineMatcher> spaceLikeAllowed;
 
  vector<LineMatcher> timeLikeAllowed;
 
  PDVector theRestrictLines;
 
  string doSpaceLikeRange(string);
 
  string doTimeLikeRange(string);
 
  string doClearRestrictLines(string);
 
private:
 
  Tree2toNGenerator & operator=(const Tree2toNGenerator &) = delete;
 
};
 
inline PersistentOStream& operator<<(PersistentOStream& os, const Tree2toNGenerator::LineMatcher& m) {
  os << m.particles << m.range << m.count;
  return os;
}
 
inline PersistentIStream& operator>>(PersistentIStream& is, Tree2toNGenerator::LineMatcher& m) {
  is >> m.particles >> m.range >> m.count;
  return is;
}
 
}
 
#endif /* Herwig_Tree2toNGenerator_H */