UtilityBase.h

// -*- C++ -*-
//
// UtilityBase.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_UtilityBase_H
#define ThePEG_UtilityBase_H
 
#include "ThePEG/Config/ThePEG.h"
#include "ThePEG/EventRecord/ParticleTraits.h"
#include "ThePEG/Utilities/Triplet.h"
 
namespace ThePEG {
 
struct UtilityBase {
 
  template <typename Cont>
  static LorentzMomentum sumMomentum(const Cont & c) {
    return sumMomentum(c.begin(), c.end());
  }
 
  template <typename Iterator>
  static LorentzMomentum sumMomentum(Iterator first, Iterator last) {
    LorentzMomentum sum;
    typedef typename std::iterator_traits<Iterator>::value_type PType;
    typedef ParticleTraits<PType> Traits;
    
    while ( first != last ) sum += Traits::momentum(*first++);
    return sum;
  }
 
  template <typename Iterator>
  static void transform(Iterator first, Iterator last,
                        const LorentzRotation & boost) {
    typedef typename std::iterator_traits<Iterator>::value_type PType;
    typedef ParticleTraits<PType> Traits;
    
    while ( first != last ) Traits::transform(*first++, boost);
  }
 
  template <typename Cont>
  static void transform(Cont & cont, const LorentzRotation & boost) {
    transform(cont.begin(), cont.end(), boost);
  }
 
  template <typename PType>
  static LorentzRotation boostToCM(const pair<PType,PType> & pp);
 
  template <typename PType>
  static LorentzRotation boostToCM(const Triplet<PType,PType,PType> & pt);
 
  template <typename PType>
  static LorentzRotation getBoostToCM(const pair<PType,PType> & pp);
 
  template <typename PType>
  static LorentzRotation getBoostToCM(const Triplet<PType,PType,PType> & pt);
 
  template <typename PType>
  static LorentzRotation getBoostFromCM(const pair<PType,PType> & pp);
 
  template <typename PType>
  static LorentzRotation getBoostFromCM(const Triplet<PType,PType,PType> & pt);
 
  template <typename Iterator>
  static LorentzRotation boostToCM(Iterator first, Iterator last) {
    return boostToCM(first, last, last, last);
  }
 
  template <typename Iterator>
  static LorentzRotation boostToCM(Iterator first, Iterator last, Iterator zAxis) {
    return boostToCM(first, last, zAxis, last);
  }
 
  template <typename Iterator>
  static LorentzRotation boostToCM(Iterator first, Iterator last,
                                   Iterator zAxis, Iterator xzPlane);
 
  template <typename PType>
  static void setMomentum(PType & p, const Momentum3 & q);
 
  template <typename PType>
  static void setMomentumFromCMS(PType & p, const Momentum3 & q);
 
  template <typename Iter>
  static void setMomentum(Iter first, Iter last, const Momentum3 & q);
 
  template <typename Iter>
  static void setMomentum(Iter first, Iter last,
                          const Momentum3 & q, double eps);
 
  template <typename Iter>
  static void setMomentumFromCMS(Iter first, Iter last,
                                 Energy2 m2, const Momentum3 & q);
 
  template <typename PType>
  static LorentzRotation transformToMomentum(const PType & p, 
                                             const Momentum3 & q) {
    typedef ParticleTraits<PType> Traits;
    LorentzMomentum q4(q, sqrt(q.mag2() + Traits::momentum(p).m2()));
    return transformToMomentum(p, q4);
  }
 
  template <typename PType>
  static LorentzRotation transformToMomentum(const PType & p, 
                                             const LorentzMomentum & q) {
    return transformFromCMS(q)*transformToCMS(p);
  }
 
  template <typename PType>
  static LorentzRotation getTransformToMomentum(const PType & p, 
                                                const LorentzMomentum & q,
                                                const LorentzMomentum & k) {
    typedef ParticleTraits<PType> Traits;
    LorentzMomentum k0 = Traits::momentum(p) - k;
    LorentzMomentum k1 = Traits::momentum(q) - k;
    return getBoostFromCM(make_pair(k1, k))*getBoostToCM(make_pair(k0, k));
  }
 
  template <typename PType>
  static LorentzRotation getTransformToMomentum(const PType & p, 
                                                const Momentum3 & q,
                                                const LorentzMomentum & k) {
    typedef ParticleTraits<PType> Traits;
    LorentzMomentum q4(q, sqrt(q.mag2() + Traits::momentum(p).m2()));
    return getTransformToMomentum(p, q4, k);
  }
 
  template <typename LV>
  static LorentzRotation transformFromCMS(const LV & p);
 
  template <typename LV>
  static LorentzRotation transformFromCMS(const LV & sum, LV zAxis);
 
  template <typename LV>
  static LorentzRotation transformFromCMS(const LV & sum,
                                          const LV & zAxis, LV xyPlane);
 
  template <typename LV>
  static LorentzRotation transformToCMS(const LV & sum, LV zAxis);
 
  template <typename LV>
  static LorentzRotation transformToCMS(const LV & p);
 
  template <typename LV>
  static LorentzRotation transformToCMS(const LV & sum,
                                        const LV & zAxis, LV xyPlane);
 
  template <typename Cont1, typename Cont2>
  static void add(Cont1 & c1, const Cont2 & c2);
 
};
 
struct Utilities: public UtilityBase {};
 
}
 
#ifndef ThePEG_TEMPLATES_IN_CC_FILE
#include "UtilityBase.tcc"
#endif
 
#endif /* ThePEG_UtilityBase_H */