HPDiagram.h

// -*- C++ -*-
//
// HPDiagram.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_HPDiagram_H
#define HERWIG_HPDiagram_H
//
// This is the declaration of the HPDiagram struct.
//
 
#include "ThePEG/Persistency/PersistentOStream.h"
#include "ThePEG/Persistency/PersistentIStream.h"
#include "ThePEG/Helicity/Vertex/VertexBase.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 HPDiagram {
 
  enum Channel {UNDEFINED = -1, sChannel, tChannel, fourPoint};
 
  HPDiagram() : incoming(make_pair(0, 0)), outgoing(make_pair(0, 0)),
                ordered(make_pair(true,true)), channelType(UNDEFINED),
                colourFlow(0), ids(4, 0) {}
  
  HPDiagram(IDPair a, IDPair b) 
  : incoming(a), outgoing(b), ordered(make_pair(true,true)), 
    channelType(UNDEFINED), colourFlow(0), ids(4, 0){
    ids[0] = incoming.first;
    ids[1] = incoming.second;
    ids[2] = outgoing.first;
    ids[3] = outgoing.second;
  }
  
  IDPair incoming;
  
  IDPair outgoing;
 
  BPair ordered;
 
  PDPtr intermediate;
 
  VBPair vertices;
  
  Channel channelType;
 
  vector<CFPair> colourFlow;
 
  vector<long> ids;
 
  bool sameProcess(const HPDiagram & x) const  {
    return ( x.incoming == incoming && x.outgoing == outgoing );
  }
};
 
  inline bool operator==(const HPDiagram & x, const HPDiagram & y)  {
    // check incoming
    if( x.incoming != y.incoming) return false;
    // check type of diagram
    if( x.channelType != y.channelType ) return false;
    if( x.outgoing == y.outgoing &&
        x.ordered == y.ordered ) {
      // 4 point
      if(x.channelType==HPDiagram::fourPoint) {
        // check vertex
        return x.vertices.first==y.vertices.first;
      }
      // all others
      else {
        // check vertex
        if(x.vertices.first  != y.vertices.first ||
           x.vertices.second != y.vertices.second )
          return false;
        // check intermediate
        return x.intermediate == y.intermediate;
      }
    }
    //diagram is also the same if the outgoing particles are
    //swapped and the ordering is opposite
    else if( x.outgoing.first != x.outgoing.second &&
             y.outgoing.first != y.outgoing.second &&
             x.outgoing.first == y.outgoing.second && 
             x.outgoing.second == y.outgoing.first &&
            x.channelType == y.channelType) {
      // 4 point
      if(x.channelType==HPDiagram::fourPoint) {
        // check vertex
        return x.vertices.first==y.vertices.first;
      }
      // t/u channel
      else if(x.channelType==HPDiagram::tChannel) {
        // check vertex and intermediate
        if(x.vertices.first  == y.vertices.first  &&
           x.vertices.second == y.vertices.second &&
           x.intermediate == y.intermediate )
            return true;
        tPDPtr inter = x.intermediate;
        if(inter->CC()) inter = inter->CC();
        if(x.vertices.first  == y.vertices.second &&
           x.vertices.second == y.vertices.first  &&
           inter == y.intermediate )
            return true;
      }
      // s-channel
      else {
        // check vertex
        if(x.vertices.first  != y.vertices.first ||
           x.vertices.second != y.vertices.second )
          return false;
        // check intermediate
        return x.intermediate == y.intermediate;
      }
    }
    return false;
  }
  
  inline bool operator<(const HPDiagram & x, const HPDiagram & y) {
    for( size_t i = 0; i < 4; ++i ) {
      if( x.ids[i] < y.ids[i] )
        return true;
      else if( x.ids[i] > y.ids[i] )
        return false;
    }
    return false;
  }
  
  inline ostream & operator<<(ostream & os, const HPDiagram & diag) {
    os << diag.incoming.first << " " << diag.incoming.second << " -> ";
    if(diag.intermediate)
      os << diag.intermediate->id() << " -> ";
    os << diag.outgoing.first << " " << diag.outgoing.second
       << "  channel: " << diag.channelType << "  ";
    if(diag.channelType == HPDiagram::tChannel)
      os << "ordering " << diag.ordered.first << " " 
         << diag.ordered.second << "  ";
    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 HPDiagram  & x) {
    os << x.incoming << x.outgoing << x.ordered << x.intermediate
       << x.vertices << x.channelType << x.colourFlow << x.ids;
    return os;
  }
 
  inline PersistentIStream & operator>>(PersistentIStream & is,
                                        HPDiagram & x) {
    int chan = -1;
    is >> x.incoming >> x.outgoing >> x.ordered >> x.intermediate
       >> x.vertices >> chan >> x.colourFlow >> x.ids;
    x.channelType = HPDiagram::Channel(chan);
    return is;
  }
}
 
#endif /* HERWIG_HPDiagram_H */