RemnantDecayer.h

// -*- C++ -*-
//
// RemnantDecayer.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_RemnantDecayer_H
#define THEPEG_RemnantDecayer_H
//
// This is the declaration of the RemnantDecayer class.
//
 
#include "ThePEG/PDT/Decayer.h"
#include "RemnantDecayer.fh"
#include "ThePEG/PDT/RemnantData.h"
#include "ThePEG/EventRecord/RemnantParticle.h"
#include "ThePEG/Handlers/PtGenerator.h"
 
namespace ThePEG {
 
class RemnantDecayer: public Decayer {
 
public:
 
  typedef Ptr<PtGenerator>::pointer PtGPtr;
 
public:
 
  enum RecoilOption {
    boostAll,   
    boostFinal, 
    copyFinal   
  };
 
public:
 
  RemnantDecayer() : respectDIS(2), theRecoilOption(copyFinal) {}
 
  virtual ~RemnantDecayer();
 
public:
 
  virtual bool accept(const DecayMode & dm) const;
 
  virtual bool needsFullStep() const;
 
  virtual ParticleVector decay(const DecayMode & dm, const Particle & p,
                               Step & step) const = 0;
 
  virtual ParticleVector decay(const DecayMode & dm, const Particle & p) const;
 
  virtual bool canHandle(tcPDPtr parent, tcPDPtr extracted) const;
 
  virtual bool checkExtract(tcPPtr parent, tcPPtr extracted,
                            const LorentzMomentum & pnew) const;
 
  virtual bool multiCapable() const;
 
  RecoilOption recoilOption() const { return theRecoilOption; }
 
  int respectDISKinematics() const { return respectDIS; }
 
  PtGPtr pTGenerator() const { return thePTGenerator; }
 
  static tPVector decayRemnants(const tPVector & particles, Step & step);
 
protected:
 
  tRemPDPtr data(tcRemPPtr remnant) const { return remnant->remData; }
 
  tcPPtr parent(tcRemPPtr remnant) const { return remnant->parent; }
 
  const PVector & extracted(tcRemPPtr remnant) const {
    return remnant->extracted();
  }
 
  virtual void fillSubSystem(tPPtr p, set<tPPtr> & sub) const;
 
  virtual tPVector getSubSystem(tcPPtr parent, tPPtr parton) const;
 
  static LorentzRotation getZBoost(const LorentzMomentum & p0,
                                   const LorentzMomentum & p);
 
public:
 
  struct SubSystemFail: public Exception {};
 
protected:
 
  virtual void doinit();
 
  virtual bool preInitialize() const;
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
  mutable int respectDIS;
 
private:
 
  RecoilOption theRecoilOption;
 
  PtGPtr thePTGenerator;
 
private:
 
  static AbstractClassDescription<RemnantDecayer> initRemnantDecayer;
 
  RemnantDecayer & operator=(const RemnantDecayer &) = delete;
 
};
 
}
 
#include "ThePEG/Utilities/ClassTraits.h"
 
namespace ThePEG {
 
template <>
struct BaseClassTrait<RemnantDecayer,1> {
  typedef Decayer NthBase;
};
 
template <>
struct ClassTraits<RemnantDecayer>
  : public ClassTraitsBase<RemnantDecayer> {
  static string className() { return "ThePEG::RemnantDecayer"; }
};
 
}
 
#endif /* THEPEG_RemnantDecayer_H */