ParticleTraits.h

// -*- C++ -*-
//
// ParticleTraits.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2007 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_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 */

---