PhysicalQty.h

Go to the documentation of this file.

// -*- C++ -*-
//
// PhysicalQty.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 2006-2019 David Grellscheid, 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 Physical_Qty_H
#define Physical_Qty_H
#include "TemplateTools.h"
#include <sstream>
#include <ratio>
#include <type_traits>
 
namespace ThePEG {
 
struct ZeroUnit {
  constexpr operator double() const { return 0.0; }
};
 
constexpr ZeroUnit ZERO = ZeroUnit();
 
// only specialization is with std::ratio below
template <typename L, typename E, typename T>
class Qty;
 
template <typename T, typename U>
struct qty_equal {
  static constexpr bool value = false;
};
 
template<typename L1, typename L2, typename E1, typename E2, typename Q1, typename Q2>
struct qty_equal<Qty<L1,E1,Q1>, Qty<L2,E2,Q2>> {
  static constexpr bool value
    =  std::ratio_equal<L1,L2>::value 
    && std::ratio_equal<E1,E2>::value
    && std::ratio_equal<Q1,Q2>::value;
};
 
template <typename T>
struct is_qty {
  static constexpr bool value = qty_equal<T,T>::value;
};
 
template <typename ResultT, typename T, typename U = T>
using enable_if_same_qty = typename std::enable_if<qty_equal<T,U>::value, ResultT>::type;
 
template<long int L, long int E, long int Q, long int DL, long int DE, long int DQ>
class Qty<std::ratio<L,DL>, std::ratio<E,DE>, std::ratio<Q,DQ>>
{
private:
  constexpr Qty(double val) : rawValue_(val) {}
 
public:
 
  static std::string className() {
    std::ostringstream os;
    os << "Qty<" 
       <<  L << ','
       <<  E << ','
       <<  Q << ','
       << DL << ','
       << DE << ','
       << DQ << '>';
      
    return os.str();
  }
 
  template <long int Num, long int Den>
  using Power = Qty<typename std::ratio<Num*L,Den*DL>::type, 
                    typename std::ratio<Num*E,Den*DE>::type, 
                    typename std::ratio<Num*Q,Den*DQ>::type>;
  using Type    = Power<1,1>;
  using Squared = Power<2,1>;
  using Inverse = Power<-1,1>;
  using Sqrt    = Power<1,2>;
 
  static constexpr Type baseunit() 
  {
    return Type(1.0);
  }
 
  constexpr Qty() : rawValue_(0.0) {}
 
  constexpr Qty(ZeroUnit) : rawValue_(0.0) {}
 
  template <typename U>
  constexpr Qty(const U & q, double factor = 1.0, 
                enable_if_same_qty<void,Type,U> * = nullptr)
    : rawValue_(q.rawValue() * factor) {}
 
  constexpr double rawValue() const { return rawValue_; }
 
  Type & operator*=(double x) { rawValue_ *= x; return *this; }
 
  Type & operator/=(double x) { rawValue_ /= x; return *this; }
 
  Type & operator+=(const Type & x) 
  { 
    rawValue_ += x.rawValue(); 
    return *this; 
  }
 
  Type & operator-=(const Type & x) 
  { 
    rawValue_ -= x.rawValue(); 
    return *this; 
  }
 
private:
  double rawValue_;
};
 
template<>
class Qty<std::ratio<0>,std::ratio<0>,std::ratio<0>>
{
public:
  using Type    = Qty<std::ratio<0>,std::ratio<0>,std::ratio<0>>;
  template <long int Num, long int Den>
  using Power   = Type;
  using Squared = Type;
  using Inverse = Type;
  using Sqrt    = Type;
 
 
  static constexpr Type baseunit() {
    return 1.0;
  }
 
  constexpr Qty(ZeroUnit) : rawValue_(0.0) {}
 
  constexpr Qty(double x = 0.0, double factor=1.0) 
        : rawValue_(x * factor) {}
 
  template <typename U>
  constexpr Qty(const U & q, double factor=1.0, 
                enable_if_same_qty<void,Type,U> * = nullptr)
   : rawValue_(q.rawValue() * factor) {}
 
  constexpr double rawValue() const { return rawValue_; }
 
  constexpr operator double() const { return rawValue_; }
 
  Type & operator*=(double x) { rawValue_ *= x; return *this; }
 
  Type & operator/=(double x) { rawValue_ /= x; return *this; }
 
  Type & operator+=(const Type & x) { 
    rawValue_ += x.rawValue(); 
    return *this; 
  }
 
  Type & operator-=(const Type & x) { 
    rawValue_ -= x.rawValue(); 
    return *this; 
  }
 
  Type & operator+=(double x) { 
    rawValue_ += x; 
    return *this; 
  }
 
  Type & operator-=(double x) { 
    rawValue_ -= x; 
    return *this; 
  }
 
private:
  double rawValue_;
};
 
using QtyDouble = Qty<std::ratio<0>,std::ratio<0>,std::ratio<0>>;
 
 
 
template <typename T, typename U> 
struct BinaryOpTraits;
 
template<typename L1, typename L2, 
         typename E1, typename E2, 
         typename Q1, typename Q2>
struct BinaryOpTraits<Qty<L1,E1,Q1>, Qty<L2,E2,Q2>> {
  typedef Qty<std::ratio_add<L1,L2>,
              std::ratio_add<E1,E2>,
              std::ratio_add<Q1,Q2>> MulT;
  typedef Qty<std::ratio_subtract<L1,L2>,
              std::ratio_subtract<E1,E2>,
              std::ratio_subtract<Q1,Q2>> DivT;
};
 
template<typename L, typename E, typename Q>
struct BinaryOpTraits<double, Qty<L,E,Q>> {
  typedef Qty<L,E,Q> MulT;
  typedef typename BinaryOpTraits<QtyDouble, Qty<L,E,Q>>::DivT DivT;
};
 
template<typename L, typename E, typename Q>
struct BinaryOpTraits<Qty<L,E,Q>, double> {
  typedef Qty<L,E,Q> MulT;
  typedef Qty<L,E,Q> DivT;
};
 
 
 
template <typename L, typename E, typename Q>
struct TypeTraits<Qty<L,E,Q>>
{
  enum { hasDimension = true };
  typedef DimensionT DimType;
  static constexpr Qty<L,E,Q> baseunit() 
        { return Qty<L,E,Q>::baseunit(); }
};
 
template <> 
struct TypeTraits<QtyDouble>
{
  enum { hasDimension = false };
  typedef StandardT DimType;
  static constexpr QtyDouble baseunit() { return 1.0; }
};
 
 
}
 
#endif