TBDiagram.h

// -*- C++ -*-
//
// TBDiagram.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_TBDiagram_H
#define HERWIG_TBDiagram_H
//
// This is the declaration of the TBDiagram struct.
//
 
#include "ThePEG/Persistency/PersistentOStream.h"
#include "ThePEG/Persistency/PersistentIStream.h"
#include "ThePEG/Helicity/Vertex/VertexBase.h"
#include "ThePEG/Utilities/EnumIO.h"
#include "PrototypeVertex.h"
 
namespace Herwig {
using namespace ThePEG;
using Helicity::VertexBasePtr;
 
typedef pair<long, long> IDPair;
  
typedef pair<bool, bool> BPair;
 
typedef VertexBasePtr VBPtr;
 
typedef pair<VBPtr, VBPtr> VBPair;
  
typedef pair<unsigned int, double> CFPair;
  
struct TBDiagram {
 
  enum Channel {UNDEFINED = -1, channel23=0, channel13=1, channel12=2, fourPoint=3};
 
  TBDiagram()  
    : incoming(0), outgoing(0), outgoingPair(make_pair(0, 0)),
      channelType(UNDEFINED), colourFlow(0), ids(4, 0) 
  {}
 
  TBDiagram(long a, long b, IDPair c)
    : incoming(a), outgoing(b), outgoingPair(c),        
      channelType(UNDEFINED), colourFlow(0), ids(4, 0) {
    ids[0] = a;
    ids[1] = b;
    ids[2] = c.first;
    ids[3] = c.second;
  }
  
  long incoming;
  
  long outgoing;
 
  IDPair outgoingPair;
 
  PDPtr intermediate;
 
  VBPair vertices;
  
  Channel channelType;
 
  mutable vector<CFPair> colourFlow;
 
  mutable vector<CFPair> largeNcColourFlow;
 
  vector<long> ids;
 
  bool sameDecay(const TBDiagram & x) const {
    if(ids[0] != x.ids[0]) return false;
    bool used[4]={false,false,false,false};
    for(unsigned int ix=1;ix<4;++ix) {
      bool found=false;
      for(unsigned int iy=1;iy<4;++iy) {
        if(used[iy]) continue;
        if(ids[ix]==x.ids[iy]) {
          used[iy]=true;
          found=true;
          break;
        }
      }
      if(!found) return false;
    }
    return true;
  }
 
  TBDiagram(const NBDiagram & diagram) 
    : channelType(UNDEFINED),
      colourFlow       (diagram.colourFlow),
      largeNcColourFlow(diagram.largeNcColourFlow), ids(4,0) {
    incoming = diagram.incoming->id();
    if(diagram.vertices.size()==2) {
      const NBVertex & child = (++diagram.vertices.begin())->second;
      outgoing = diagram.vertices.begin()->first->id();
      unsigned int iloc=0;
      for(OrderedParticles::const_iterator it = child.outgoing.begin();
          it!=child.outgoing.end();++it) {
        if (iloc==0)      outgoingPair.first  = (**it).id();
        else if (iloc==1) outgoingPair.second = (**it).id();
        ++iloc;
      }
      intermediate = child.incoming;
      vertices.second = child.vertex;
    }
    else {
      unsigned int iloc=0;
      for(OrderedParticles::const_iterator it = diagram.outgoing.begin();
          it!=diagram.outgoing.end();++it) {
        if(iloc==0)       outgoing            = (**it).id();
        else if (iloc==1) outgoingPair.first  = (**it).id();
        else if (iloc==2) outgoingPair.second = (**it).id();
        ++iloc;
      }
    }
    vertices.first = diagram.vertex;
    ids[0] = incoming;
    ids[1] = outgoing;
    ids[2] = outgoingPair.first;
    ids[3] = outgoingPair.second;
  }
 
};
 
inline bool operator==(const TBDiagram & x, const TBDiagram & y) {
  if( x.incoming     != y.incoming) return false;
  if( x.outgoing     != y.outgoing) return false;
  if( x.intermediate != y.intermediate) return false;
  if( x.vertices     != y.vertices    ) return false;
  if( (x.outgoingPair.first  == y.outgoingPair.first  &&
       x.outgoingPair.second == y.outgoingPair.second ) ||
      (x.outgoingPair.first  == y.outgoingPair.second &&
       x.outgoingPair.second == y.outgoingPair.first  ) ) return true;
  else return false;
}
 
inline ostream & operator<<(ostream & os, const TBDiagram & diag) {
  os << diag.incoming << " -> ";
  os << diag.outgoing << " + ( ";
  if(diag.intermediate) os << diag.intermediate->id();
  os << " ) -> ";
  os << diag.outgoingPair.first << " " << diag.outgoingPair.second
     << "  channel: " << diag.channelType << "  ";
  for(size_t cf = 0; cf < diag.colourFlow.size(); ++cf) 
    os << "(" << diag.colourFlow[cf].first << "," 
       <<diag.colourFlow[cf].second << ")";
  os << '\n';
  return os;
}
 
inline PersistentOStream & operator<<(PersistentOStream & os, 
                                      const TBDiagram  & x) {
  os << x.incoming << x.outgoing << x.outgoingPair << x.intermediate
     << x.vertices << oenum(x.channelType) << x.colourFlow 
     << x.largeNcColourFlow << x.ids;
  return os;
}
  
inline PersistentIStream & operator>>(PersistentIStream & is,
                                      TBDiagram & x) {
  is >> x.incoming >> x.outgoing >> x.outgoingPair >> x.intermediate
     >> x.vertices >> ienum(x.channelType) >> x.colourFlow 
     >> x.largeNcColourFlow >> x.ids;
  return is;
}
 
}
 
#endif /* HERWIG_TBDiagram_H */