ParticleTraits.h

// -*- C++ -*-
//
// ParticleTraits.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 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_ParticleTraits_H
#define ThePEG_ParticleTraits_H
// This is the declaration of the ParticleTraits class.
 
#include "ThePEG/Config/ThePEG.h"
// #include "ParticleTraits.fh"
// #include "ParticleTraits.xh"
 
namespace ThePEG {
 
template <typename PType>
struct ParticleTraits: public TraitsType {
 
  static PType & ref(PType & p) {
    return p;
  }
 
  static LorentzMomentum momentum(const PType & p) {
    return p.momentum();
  }
 
  static Energy mass(const PType & p) {
    return p.mass();
  }
 
  static void transform(PType & p, const LorentzRotation & r) {
    p.transform(r);
  }
 
  static void set5Momentum(PType & p, const Lorentz5Momentum & q) {
    p.set5Momentum(q);
  }
 
  static void set3Momentum(PType & p, const Momentum3 & q) {
    p.set3Momentum(q);
  }
 
  static int iCharge(const PType & p) {
    return p.data().iCharge();
  }
 
};
 
template <>
struct ParticleTraits<PPtr>: public TraitsType {
 
  static Particle & ref(tPPtr p) {
    return *p;
  }
 
  static const LorentzMomentum & momentum(tPPtr p) {
    return p->momentum();
  }
 
  static Energy mass(tPPtr p) {
    return p->mass();
  }
 
  static void transform(tPPtr p, const LorentzRotation & r) {
    p->transform(r);
  }
 
  static void set5Momentum(tPPtr p, const Lorentz5Momentum & q) {
    p->set5Momentum(q);
  }
 
  static void set3Momentum(tPPtr p, const Momentum3 & q) {
    p->set3Momentum(q);
  }
 
  static int iCharge(tPPtr p) {
    return p->data().iCharge();
  }
};  
 
template <>
struct ParticleTraits<cPPtr>: public TraitsType {
 
  static const Particle & ref(tcPPtr p) {
    return *p;
  }
 
  static const LorentzMomentum & momentum(tcPPtr & p) {
    return p->momentum();
  }
 
  static Energy mass(tcPPtr p) {
    return p->mass();
  }
 
  static int iCharge(tcPPtr & p) {
    return p->data().iCharge();
  }
};  
 
template <>
struct ParticleTraits<tPPtr>: public TraitsType {
 
  static Particle & ref(tPPtr p) {
    return *p;
  }
 
  static const LorentzMomentum & momentum(tPPtr p) {
    return p->momentum();
  }
 
  static Energy mass(tPPtr p) {
    return p->mass();
  }
 
  static void transform(tPPtr p, const LorentzRotation & r) {
    p->transform(r);
  }
 
  static void set5Momentum(tPPtr p, const Lorentz5Momentum & q) {
    p->set5Momentum(q);
  }
 
  static void set3Momentum(tPPtr p, const Momentum3 & q) {
    p->set3Momentum(q);
  }
 
  static int iCharge(tPPtr p) {
    return p->data().iCharge();
  }
};  
 
template <>
struct ParticleTraits<tcPPtr>: public TraitsType {
 
  static const Particle & ref(tcPPtr p) {
    return *p;
  }
 
  static const LorentzMomentum & momentum(tcPPtr p) {
    return p->momentum();
  }
 
  static Energy mass(tcPPtr p) {
    return p->mass();
  }
 
  static int iCharge(tcPPtr p) {
    return p->data().iCharge();
  }
};
 
template <typename T>
struct ParticleTraits<T*>: public TraitsType {
 
  static Particle & ref(T * p) {
    return *p;
  }
 
  static const LorentzMomentum & momentum(T * p) {
    return ParticleTraits<T>::momentum(*p);
  }
 
  static Energy mass(T * p) {
    return ParticleTraits<T>::mass(*p);
  }
 
  static void transform(T * p, const LorentzRotation & r) {
    ParticleTraits<T>::transform(*p, r);
  }
 
  static void set5Momentum(T * p, const Lorentz5Momentum & q) {
    ParticleTraits<T>::set5Momentum(*p, q);
  }
 
  static void set3Momentum(T * p, const Momentum3 & q) {
    ParticleTraits<T>::set3Momentum(*p, q);
  }
 
  static int iCharge(T * p) {
    return ParticleTraits<T>::iCharge(*p);
  }
};  
 
template <typename T>
struct ParticleTraits<const T *>: public TraitsType {
 
  static const Particle & ref(const T * p) {
    return *p;
  }
 
  static const LorentzMomentum & momentum(const T * p) {
    return ParticleTraits<T>::momentum(*p);
  }
 
  static Energy mass(const T * p) {
    return ParticleTraits<T>::mass(*p);
  }
 
  static int iCharge(const T * p) {
    return ParticleTraits<T>::iCharge(*p);
  }
};
 
template <>
struct ParticleTraits<LorentzMomentum>: public TraitsType {
 
  static LorentzMomentum & ref(LorentzMomentum & p) {
    return p;
  }
 
  static const LorentzMomentum & momentum(const LorentzMomentum & p) {
    return p;
  }
 
  static Energy mass(const LorentzMomentum & p) {
    return p.m();
  }
 
  static void transform(LorentzMomentum & p, const LorentzRotation & r) {
    p.transform(r);
  }
 
  static void set5Momentum(LorentzMomentum & p, const Lorentz5Momentum & q) {
    p = q;
  }
 
  static void set3Momentum(LorentzMomentum & p, const Momentum3 & q) {
    p = LorentzMomentum(q, sqrt(q.mag2() + p.m2()));
  }
};  
 
template <>
struct ParticleTraits<Lorentz5Momentum>: public TraitsType {
 
  static Lorentz5Momentum & ref(Lorentz5Momentum & p) {
    return p;
  }
 
  static const LorentzMomentum & momentum(const Lorentz5Momentum & p) {
    return p;
  }
 
  static Energy mass(const Lorentz5Momentum & p) {
    return p.mass();
  }
 
  static void transform(Lorentz5Momentum & p, const LorentzRotation & r) {
    p.transform(r);
  }
 
  static void set5Momentum(Lorentz5Momentum & p, const Lorentz5Momentum & q) {
    p = q;
  }
 
  static void set3Momentum(Lorentz5Momentum & p, const Momentum3 & q) {
    p = Lorentz5Momentum(p.mass(), q);
  }
};  
 
struct Transformer {
  Transformer(const LorentzRotation & rin) : r(rin) {}
  Transformer(const Transformer & t) : r(t.r) {}
  template <typename PType>
  void operator()(const PType & p) {
    ParticleTraits<PType>::transform(p, r);
  }
  const LorentzRotation & r;
};
 
}
 
// #include "ParticleTraits.icc"
#ifndef ThePEG_TEMPLATES_IN_CC_FILE
// #include "ParticleTraits.tcc"
#endif
 
#endif /* ThePEG_ParticleTraits_H */