SpinInfo.h

// -*- C++ -*-
//
// SpinInfo.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_SpinInfo_H
#define ThePEG_SpinInfo_H
// This is the declaration of the SpinInfo class.
 
#include "ThePEG/EventRecord/EventInfoBase.h"
#include "ThePEG/PDT/PDT.h"
#include "ThePEG/Interface/ClassDocumentation.h"
#include "HelicityVertex.h"
 
namespace ThePEG {
 
class SpinInfo: public EventInfoBase {
 
public:
 
  enum DevelopedStatus {
    Undeveloped=0, 
    Developed=1,   
    NeedsUpdate=2,  
    StopUpdate=3     
  };
 
public:
 
  SpinInfo() 
    : _timelike(false), _prodloc(-1), _decayloc(-1), 
      _decayed(false), _developed(Undeveloped),
      _oldDeveloped(Undeveloped) {}
 
  SpinInfo(PDT::Spin s, 
           const Lorentz5Momentum & p = Lorentz5Momentum(), 
           bool time = false)
    : _timelike(time), _prodloc(-1), _decayloc(-1),
      _decayed(false),
      _developed(Undeveloped), _oldDeveloped(Undeveloped),
      _rhomatrix(s), _Dmatrix(s), _spin(s),
      _productionmomentum(p), _currentmomentum(p) {}
 
  SpinInfo(const SpinInfo &);
 
public:
 
  virtual bool hasPolarization() const { return false; }
 
  virtual DPair polarization() const { return DPair(); }
 
public:
 
  static void Init();
 
  virtual void rebind(const EventTranslationMap & trans);
 
  virtual EIPtr clone() const;
 
  void update() const;
 
  virtual void transform(const LorentzMomentum & m, const LorentzRotation & r) {
    _currentmomentum = m;
    _currentmomentum.transform(r);
  }
 
  virtual void reset() {
    _currentmomentum = _productionmomentum;
  }
  
public:
 
 
  void productionVertex(VertexPtr in) const {
    _production=in;
    // add to the list of outgoing if timelike
    int temp(-1);
    if(_timelike) in->addOutgoing(this,temp); 
    // or incoming if spacelike
    else          in->addIncoming(this,temp);
    _prodloc=temp;
  }
 
  tcVertexPtr productionVertex() const { return _production; }
 
  void decayVertex(VertexPtr in) const {
    if(in) {
      _decay=in;
      if(_timelike) {
        int temp(-1);
        in->addIncoming(this,temp);
        _decayloc=temp;
        assert(temp==0);
      }
      else {
        int temp(-1);
        in->addOutgoing(this,temp);
        _decayloc=temp;
      }
    }
    else {
      _decay=VertexPtr();
      _decayloc=-1;
    }
  }
 
  tcVertexPtr decayVertex() const { return _decay; }
 
  bool decayed() const { return _decayed; }
 
  void decayed(bool b) const { _decayed = b; }
 
  DevelopedStatus developed() const { return _developed; }
 
  void decay(bool recursive=false) const ;
 
  virtual void undecay() const ;
 
  void develop() const ;
 
  void needsUpdate() const {
    if(_developed!=NeedsUpdate) _oldDeveloped = _developed;
    _developed=NeedsUpdate;
  }
 
  void stopUpdate() const {_developed=StopUpdate;}
 
  PDT::Spin iSpin() const { return _spin; }
 
  const Lorentz5Momentum & productionMomentum() const {
    return _productionmomentum;
  }
 
  const Lorentz5Momentum & currentMomentum() const {
    return _currentmomentum;
  }
 
  bool timelike() const { return _timelike; }
 
  int productionLocation() const {return _prodloc;}
 
  int decayLocation() const {return _decayloc;}
 
public:
 
  RhoDMatrix rhoMatrix() const { return _rhomatrix; }
 
  RhoDMatrix & rhoMatrix() { return _rhomatrix; }
 
  RhoDMatrix DMatrix() const { return _Dmatrix; }
 
  RhoDMatrix & DMatrix() { return _Dmatrix; }
 
public:
 
  bool isNear(const Lorentz5Momentum & p) {
    return currentMomentum().isNear(p,_eps);
  }
 
private:
 
  static NoPIOClassDescription<SpinInfo> initSpinInfo;
 
  SpinInfo & operator=(const SpinInfo &) = delete;
 
private:
 
  void redevelop() const ;
 
  void redecay() const ;
 
private:
 
  mutable VertexPtr _production;
 
  mutable VertexPtr _decay;
 
  bool _timelike;
 
  mutable int _prodloc;
 
  mutable int _decayloc;
 
  mutable bool _decayed;
 
  mutable DevelopedStatus _developed;
 
  mutable DevelopedStatus _oldDeveloped;
 
  mutable RhoDMatrix _rhomatrix;
 
  mutable RhoDMatrix _Dmatrix;
 
  PDT::Spin _spin;
 
  Lorentz5Momentum _productionmomentum;
 
  mutable Lorentz5Momentum _decaymomentum;
  
  Lorentz5Momentum _currentmomentum;
 
  static const double _eps;
};
 
}
 
 
namespace ThePEG {
 
template <>
struct BaseClassTrait<ThePEG::SpinInfo,1>: public ClassTraitsType {
  typedef EventInfoBase NthBase;
};
 
template <>
struct ClassTraits<ThePEG::SpinInfo>
  : public ClassTraitsBase<ThePEG::SpinInfo> {
  static string className() { return "ThePEG::SpinInfo"; }
};
 
}
 
#endif /* ThePEG_SpinInfo_H */