SR.H

Go to the documentation of this file.

 
#ifndef _SR_H_
#define _SR_H_
 
#include <cmath>
#include "Types.H"
#include "PartTypes.H"
 
namespace criptic {
 
  namespace sr {
    
    static inline Real gamma_from_p(const Real m, const Real p) {
      Real pm = p/m;
      return pm < 1.0e-6 ? 1.0 + pm*pm / 2.0 : std::sqrt(1.0 + pm*pm);
    }
    
    static inline Real gamma_from_T(const Real m, const Real T) {
      return 1.0 + T/m;
    }
    
    static inline Real gamma_from_E(const Real m, const Real E) {
      return E/m;
    }
    
    static inline Real p_from_gamma(const Real m, const Real gamma) {
      Real g = gamma-1.0;
      if (g < 1.0e-6)
    return m * (std::sqrt(2.0)*g + (g/2.0)*std::sqrt(g/2.0));
      else
    return m * std::sqrt(gamma*gamma - 1.0);
    }
    
    static inline Real p_from_T(const Real m, const Real T) {
      Real Tm = T/m;
      if (Tm < 1.0e-6)
    return std::sqrt(2.0*Tm) + m * (Tm/2.0) * std::sqrt(Tm/2.0);
      else
    return m * std::sqrt(Tm * (2.0+Tm));
    }
    
    static inline Real p_from_E(const Real m, const Real E) {
      Real Tm = E / m - 1.0;
      if (Tm < 1.0e-6)
    return std::sqrt(2.0*Tm) + m * (Tm/2.0) * std::sqrt(Tm/2.0);
      else
    return m * std::sqrt(Tm * (2.0+Tm));
    }
    
    static inline Real T_from_gamma(const Real m, const Real gamma) {
      return m * (gamma-1.0);
    }
    
    static inline Real T_from_p(const Real m, const Real p) {
      Real pm = p / m;
      if (pm < 1.0e-6)
    return p*p / (2.0*m) * (1.0 - pm*pm/4.0);
      else
    return m * (std::sqrt(1.0 + pm*pm) - 1.0);
    }
    
    static inline Real E_from_gamma(const Real m, const Real gamma) {
      return m * gamma;
    }
    
    static inline Real E_from_p(const Real m, const Real p) {
      Real pm = p / m;
      if (pm < 1.0e-6)
    return m + p*p / (2.0*m) * (1.0 - pm*pm/4.0);
      else
    return m * std::sqrt(1.0 + pm*pm);
    }
    
    static inline Real dT_dp(const Real m, const Real p) {
      Real pm = p / m;
      if (pm < 1.0e-6)
    return pm * (1.0 - pm*pm/2.0);
      else
    return pm / std::sqrt(1.0 + pm*pm);
    }
    
    static inline Real v_from_p(const Real m, const Real p) {
      Real pm = p / m;
      if (pm < 1.0e-6)
    return pm - 0.5 / (pm*pm*pm);
      else
    return 1.0 / std::sqrt(1.0 + 1.0/(pm*pm));
    }
    
    static inline Real gamma_from_p(const partTypes::pType pt,
                    const Real p) {
      return gamma_from_p(partTypes::mass[pt], p);
    }
    
    static inline Real gamma_from_T(const partTypes::pType pt, const Real T) {
      return gamma_from_T(partTypes::mass[pt], T);
    }
    
    static inline Real p_from_gamma(const partTypes::pType pt,
                    const Real gamma) {
      return p_from_gamma(partTypes::mass[pt], gamma);
    }
    
    static inline Real p_from_T(const partTypes::pType pt, const Real T) {
      return p_from_T(partTypes::mass[pt], T);
    }
    
    static inline Real T_from_gamma(const partTypes::pType pt,
                    const Real gamma) {
      return T_from_gamma(partTypes::mass[pt], gamma);
    }
    
    static inline Real T_from_p(const partTypes::pType pt, const Real p) {
      return T_from_p(partTypes::mass[pt], p);
    }
    
    static inline Real dT_dp(const partTypes::pType pt, const Real p) {
      return dT_dp(partTypes::mass[pt], p);
    }
    
    static inline Real v_from_p(const partTypes::pType pt, const Real p) {
      return v_from_p(partTypes::mass[pt], p);
    }
 
    static inline Real ECM(const Real mt, const Real mp, const Real T) {
      return std::sqrt( mt*mt + mp*mp + 2*mt*(mp*mp+T) );
    }
    
    static inline Real ECM(const partTypes::pType ptt,
               const partTypes::pType ptp,
               const Real T) {
      return ECM(partTypes::mass[ptt], partTypes::mass[ptp], T);
    }
  }
}
 
#endif
// _SR_H_