HelicityVertex.h

// -*- C++ -*-
//
// HelicityVertex.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 2003-2019 Peter Richardson, 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_HelicityVertex_H
#define ThePEG_HelicityVertex_H
// This is the declaration of the HelicityVertex class.
 
#include "HelicityVertex.fh"
#include "ThePEG/EventRecord/EventConfig.h"
#include "ThePEG/Utilities/ClassDescription.h"
#include "RhoDMatrix.h"
#include "ThePEG/Utilities/Rebinder.h"
#include "ThePEG/Helicity/HelicityDefinitions.h"
 
namespace ThePEG {
 
class HelicityVertex: public EventInfoBase {
 
public:
 
  friend ostream & operator<<(ostream & os, const HelicityVertex & vert);
 
public:
 
  typedef vector<tcSpinPtr> SpinVector;
 
public:
 
  static void Init();
 
  virtual void rebind(const EventTranslationMap & trans);
 
public:
 
  const SpinVector & incoming() const {return _incoming;}
 
  const SpinVector & outgoing() const {return _outgoing;}
 
  void addIncoming(tcSpinPtr spin, int & loc) {
    if(loc<0) {
      _incoming.push_back(spin);
      loc=_incoming.size()-1;
    }
    else {
      _incoming[loc] = spin;
    }
  }
 
  void addOutgoing(tcSpinPtr spin, int & loc) {
    if(loc<0) {
      _outgoing.push_back(spin);
      loc=_outgoing.size()-1;
    }
    else {
      _outgoing[loc]= spin;
    }
  }
 
  void resetIncoming(tcSpinPtr spin, int loc) {
    assert( loc < int(_incoming.size()) && loc >= 0 );
    _incoming[loc]=spin;
  }
 
  void resetOutgoing(tcSpinPtr spin, int loc) {
    assert( loc < int(_outgoing.size()) && loc >= 0 );
    _outgoing[loc]=spin;
  }
 
public:
 
  virtual RhoDMatrix getRhoMatrix(int loc,bool recursive) const = 0;
 
  virtual RhoDMatrix getDMatrix(int loc) const = 0;
 
private:
 
  static AbstractNoPIOClassDescription<HelicityVertex> initHelicityVertex;
 
  HelicityVertex & operator=(const HelicityVertex &) = delete;
 
private:
 
  SpinVector _incoming;
 
  SpinVector _outgoing;
 
};
 
inline ostream & operator<<(ostream & os, const HelicityVertex & vert) {
  os << "the incoming particles at the vertex are" << endl;
  for(unsigned int ix=0;ix<vert._incoming.size();++ix) {
    os << "the " << ix << " th incoming particle " << vert._incoming[ix] << "\n";
  }
  os << "the outgoing particles at the vertex are" << endl;
  for(unsigned int ix=0;ix<vert._outgoing.size();++ix) {
    os << "the " << ix << " th outgoing particle " << vert._outgoing[ix] << "\n";
  }
  return os;
}
  
}
 
 
namespace ThePEG {
 
  template <>
  struct BaseClassTrait<ThePEG::HelicityVertex,1>
    : public ClassTraitsType {
    typedef EventInfoBase NthBase;
  };
 
template <>
struct ClassTraits<ThePEG::HelicityVertex>
  : public ClassTraitsBase<ThePEG::HelicityVertex> {
  static string className() { return "ThePEG::HelicityVertex"; }
};
 
}
 
#endif /* ThePEG_HelicityVertex_H */