IFMassiveDecayKinematics.h

// -*- C++ -*-
//
// IFMassiveDecayKinematics.h is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2019 The Herwig Collaboration
//
// Herwig is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef HERWIG_IFMassiveDecayKinematics_H
#define HERWIG_IFMassiveDecayKinematics_H
//
// This is the declaration of the IFMassiveDecayKinematics class.
//
 
#include "DipoleSplittingKinematics.h"
#include "ThePEG/EventRecord/Particle.h"
#include "ThePEG/Utilities/UtilityBase.h"
 
namespace Herwig {
 
  using namespace ThePEG;
 
  class IFMassiveDecayKinematics: public DipoleSplittingKinematics {
 
  public:
 
    IFMassiveDecayKinematics();
 
  public:
 
    virtual pair<double,double> kappaSupport(const DipoleSplittingInfo& dIndex) const;
 
    virtual pair<double,double> xiSupport(const DipoleSplittingInfo& dIndex) const;
 
    virtual pair<double,double> zBoundaries(Energy,
                                            const DipoleSplittingInfo&,
                                            const DipoleSplittingKernel&) const {
      return {0.0,1.0};
    }
 
    virtual Energy dipoleScale(const Lorentz5Momentum& pEmitter,
                               const Lorentz5Momentum& pSpectator) const;
 
    virtual Energy recoilMassKin(const Lorentz5Momentum& pEmitter,
                              const Lorentz5Momentum& pSpectator) const;
 
    virtual Energy ptMax(Energy dScale, 
                         double emX, double specX,
                         const DipoleSplittingInfo& dInfo,
                         const DipoleSplittingKernel& split) const;
 
    virtual Energy QMax(Energy dScale, 
                        double emX, double specX,
                        const DipoleSplittingInfo& dInfo,
                        const DipoleSplittingKernel& split) const;
 
    virtual Energy ptMax(Energy, 
                         double, double,
                         const DipoleIndex&,
                         const DipoleSplittingKernel&) const {
      // Only the DipoleSplittingInfo version should be used for the decays.
      assert(false);
      return 0.0;
    }
 
    virtual Energy QMax(Energy, 
                        double, double,
                        const DipoleIndex&,
                        const DipoleSplittingKernel&) const { 
      // Only the DipoleSplittingInfo version should be used for the decays.
      assert(false);
      return 0.0;
    }
 
 
    virtual Energy PtFromQ(Energy scale, const DipoleSplittingInfo&) const;
 
    virtual Energy QFromPt(Energy scale, const DipoleSplittingInfo&) const;
 
    virtual double ptToRandom(Energy pt, Energy dScale,
                              double emX, double specX,
                              const DipoleIndex& dIndex,
                              const DipoleSplittingKernel& split) const;
 
    virtual bool generateSplitting(double kappa, double xi, double phi,
                                   DipoleSplittingInfo& info,
                                   const DipoleSplittingKernel& split);
 
    virtual void generateKinematics(const Lorentz5Momentum& pEmitter,
                                    const Lorentz5Momentum& pSpectator,
                                    const DipoleSplittingInfo& dInfo);
 
    /*
     * Return true if this splitting is of a dipole which contains
     * a decayed parton and requires the remnant to absorb the recoil.
     */
    virtual bool isDecay() const { return true; }
  
    virtual void decayRecoil ( PList& recoilSystem ) {
      PList::iterator beginRecoil = recoilSystem.begin();
      PList::iterator endRecoil = recoilSystem.end();
      const ThreeVector<double> transformMom = splitRecoilMomentum().vect();
      ThePEG::UtilityBase::setMomentum(beginRecoil, endRecoil, transformMom );
    }
  
 
  public:
  
    template <class T>
    inline double rootOfKallen (T a, T b, T c) const {
      double sres=a*a + b*b + c*c - 2.*( a*b+a*c+b*c );
      return sres>0.?sqrt( sres ):0.; }
  
  public:
 
    void persistentOutput(PersistentOStream & os) const;
 
    void persistentInput(PersistentIStream & is, int version);
 
    static void Init();
 
  protected:
 
    virtual IBPtr clone() const;
 
    virtual IBPtr fullclone() const;
 
 
    // If needed, insert declarations of virtual function defined in the
    // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs).
 
 
  private:
 
    static ClassDescription<IFMassiveDecayKinematics> initIFMassiveDecayKinematics;
 
    IFMassiveDecayKinematics & operator=(const IFMassiveDecayKinematics &) = delete;
 
  };
 
}
 
#include "ThePEG/Utilities/ClassTraits.h"
 
namespace ThePEG {
 
  template <>
  struct BaseClassTrait<Herwig::IFMassiveDecayKinematics,1> {
    typedef Herwig::DipoleSplittingKinematics NthBase;
  };
 
  template <>
  struct ClassTraits<Herwig::IFMassiveDecayKinematics>
    : public ClassTraitsBase<Herwig::IFMassiveDecayKinematics> {
    static string className() { return "Herwig::IFMassiveDecayKinematics"; }
    static string library() { return "HwDipoleShower.so"; }
  };
 
}
 
#endif /* HERWIG_IFMassiveDecayKinematics_H */