SpinInfo.h

// -*- C++ -*-
//
// SpinInfo.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 2003-2007 Peter Richardson, Leif Lonnblad
//
// ThePEG is licenced under version 2 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/SpinBase.h"
#include "ThePEG/PDT/PDT.h"
#include "ThePEG/Interface/ClassDocumentation.h"
#include "ThePEG/Helicity/HelicityVertex.h"
#include "SpinInfo.fh"
// #include "SpinInfo.xh"

namespace ThePEG {
namespace Helicity {

class SpinInfo: public SpinBase {

public:

  enum DevelopedStatus {
    Undeveloped=0,
    Developed=1,
    NeedsUpdate=2
  };
  
public:


  SpinInfo() 
    : _timelike(false), _prodloc(-1), _decayloc(-1), 
      _decayed(false), _developed(Undeveloped) {}

  SpinInfo(PDT::Spin s, 
           const Lorentz5Momentum & p = Lorentz5Momentum(), 
           bool time = false)
    : _timelike(time), _prodloc(-1), _decayloc(-1),
      _decayed(false), _developed(Undeveloped),
      _rhomatrix(s), _Dmatrix(s), _spin(s),
      _productionmomentum(p), _currentmomentum(p) {}

  SpinInfo(const SpinInfo &);

public:

  static void Init();

  virtual void rebind(const EventTranslationMap & trans);

  virtual EIPtr clone() const;

  void update() const;

  virtual void transform(const LorentzMomentum &, const LorentzRotation & r) {
    _currentmomentum.transform(r);
  }

public:


  void setProductionVertex(VertexPtr in) const {
    _production=in;
    // add to the list of outgoing if timelike
    int temp;
    if(_timelike) in->addOutgoing(this,temp); 
    // or incoming if spacelike
    else          in->addIncoming(this,temp);
    _prodloc=temp;
  }

  tcVertexPtr getProductionVertex() const { return _production; }

  void setDecayVertex(VertexPtr in) const {
    _decay=in;
    int temp;
    in->addIncoming(this,temp);
    _decayloc=temp;
    assert(temp==0);
    //if(temp!=0){cout << "something dodgy here can only decay once" << endl;}
  }

  tcVertexPtr getDecayVertex() const { return _decay; }

  bool decayed() const { return _decayed; }

  void decayed(bool b) const { _decayed = b; }

  DevelopedStatus developed() const { return _developed; }

  void needsUpdate() const { _developed = NeedsUpdate; }

  void decay() const;


  void develop() const;

  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; }

protected:

  bool isNear(const Lorentz5Momentum & p) {
    return currentMomentum().isNear(p,_eps);
  }

private:

  static NoPIOClassDescription<SpinInfo> initSpinInfo;

  SpinInfo & operator=(const SpinInfo &);

private:

  void redevelop() const ;
  
private:

  mutable VertexPtr _production;

  mutable VertexPtr _decay;

  bool _timelike;

  mutable int _prodloc;

  mutable int _decayloc;

  mutable bool _decayed;

  mutable DevelopedStatus _developed;

  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::Helicity::SpinInfo,1>: public ClassTraitsType {
  typedef SpinBase NthBase;
};

template <>
struct ClassTraits<ThePEG::Helicity::SpinInfo>
  : public ClassTraitsBase<ThePEG::Helicity::SpinInfo> {
  static string className() { return "ThePEG::Helicity::SpinInfo"; }
};

}

#endif /* ThePEG_SpinInfo_H */

---