PDT.h

// -*- C++ -*-
//
// PDT.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_PDT_H
#define ThePEG_PDT_H
// This is the declaration of the PDT class.

#include "ThePEG/Config/ThePEG.h"

namespace ThePEG {

class PDT {

public:

  enum Spin {
    SpinNA = -1,       
    SpinUnknown = 0,   
    SpinUndefined = 0, 
    Spin0 = 1,         
    Spin1Half = 2,     
    Spin1 = 3,         
    Spin3Half = 4,     
    Spin2 = 5,         
    Spin5Half = 6,     
    Spin3 = 7,         
    Spin7Half = 8,     
    Spin4 = 9          
  };

  enum Charge {
    ChargeUnknown = -999999,   
    ChargeUndefined = -999999, 
    Charged = 999990,          
    Positive = 900000,         
    Negative = -900000,        
    ChargeNeutral = 0,         
    Charge0 = 0,               
    Plus1Third = 1,            
    Plus2Third = 2,            
    Plus1 = 3,                 
    Minus1Third = -1,          
    Minus2Third = -2,          
    Minus1 = -3,               
    Plus4Third = 4,            
    Plus5Third = 5,            
    Plus2 = 6,                 
    Minus4Third = -4,          
    Minus5Third = -5,          
    Minus2 = -6,               
    Plus7Third = 7,            
    Plus8Third = 8,            
    Plus3 = 9,                 
    Minus7Third = -7,          
    Minus8Third = -8,          
    Minus3 = -9,               
    Plus4 = 12,                
    Plus5 = 15,                
    Plus6 = 18,                
    Plus7 = 21,                
    Plus8 = 24,                
    Minus4 = -12,              
    Minus5 = -15,              
    Minus6 = -18,              
    Minus7 = -21,              
    Minus8 = -24               
  };

  enum Colour {
    ColourUnknown = -1,   
    ColourUndefined = -1, 
    ColourNeutral = 0,    
    Colour0 = 0,          
    Coloured = 1,         
    Colour3 = 3,          
    Colour3bar = -3,      
    Colour6 = 6,          
    Colour6bar = -6,      
    Colour8 = 8           
  };

  static bool charged(Charge c) {
    return c != ChargeNeutral && c != ChargeUndefined;
  }

  static bool positive(Charge c) {
    return c > ChargeNeutral && c != Charged;
  }

  static bool negative(Charge c) {
    return c < ChargeNeutral && c != ChargeUndefined;
  }

  static bool coloured(Colour c) {
    return c != ColourNeutral && c != ColourUnknown;
  }

  static Colour antiColour(Colour c) {
    if ( c == Colour3 || c == Colour3bar ) return Colour(-c);
    if ( c == Colour6 || c == Colour6bar ) return Colour(-c);
    return c;
  }

  static vector<long> flavourContent(long id);

  static vector<long> flavourContent(tcPDPtr);

  static vector<long> flavourContent(tcPPtr);

  static vector<long> flavourContent(const ParticleData &);

  static vector<long> flavourContent(const Particle &);

};

template <typename IStream>
IStream & operator>>(IStream & is, PDT::Colour & c) {
  int ci;
  is >> ci;
  c = PDT::Colour(ci);
  return is;
}

template <typename IStream>
IStream & operator>>(IStream & is, PDT::Charge & c) {
  int ci;
  is >> ci;
  c = PDT::Charge(ci);
  return is;
}

template <typename IStream>
IStream & operator>>(IStream & is, PDT::Spin & s) {
  int si;
  is >> si;
  s = PDT::Spin(si);
  return is;
}

template <> 
struct TypeTraits<PDT::Spin>
{
  enum { hasDimension = false };
  typedef EnumT DimType;
  static constexpr PDT::Spin baseunit() { return PDT::Spin(1); }
};

template <> 
struct TypeTraits<PDT::Charge>
{
  enum { hasDimension = false };
  typedef EnumT DimType;
  static constexpr PDT::Charge baseunit() { return PDT::Charge(1); }
};

template <> 
struct TypeTraits<PDT::Colour>
{
  enum { hasDimension = false };
  typedef EnumT DimType;
  static constexpr PDT::Colour baseunit() { return PDT::Colour(3); }
};

}

#endif /* ThePEG_PDT_H */