SplittingGenerator.h

// -*- C++ -*-
//
// SplittingGenerator.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_SplittingGenerator_H
#define HERWIG_SplittingGenerator_H
//
// This is the declaration of the SplittingGenerator class.
//
 
#include "ThePEG/Interface/Interfaced.h"
#include "Herwig/Shower/QTilde/Base/Branching.h"
#include "Herwig/Shower/QTilde/SplittingFunctions/SudakovFormFactor.h"
#include "SplittingGenerator.fh"
#include "Herwig/Shower/QTilde/Base/ShowerParticle.h"
#include "Herwig/Shower/QTilde/Kinematics/ShowerKinematics.h"
 
namespace Herwig {
 
using namespace ThePEG;
 
class SplittingGenerator: public Interfaced {
 
public:
 
  SplittingGenerator() : _deTuning(1.) {}
 
public:
 
  Branching chooseForwardBranching(ShowerParticle & particle,
                                   double enhance,
                                   ShowerInteraction type) const; 
 
  Branching chooseDecayBranching(ShowerParticle & particle, 
                                 const ShowerParticle::EvolutionScales & maxScales,
                                 Energy minmass,double enhance,
                                 ShowerInteraction type) const; 
 
  Branching 
  chooseBackwardBranching(ShowerParticle & particle,
                          PPtr beamparticle,
                          double enhance,
                          Ptr<BeamParticleData>::transient_const_pointer beam,
                          ShowerInteraction type,
                          tcPDFPtr , Energy ) const;
 
public:
 
  string addFinalSplitting(string arg) { return addSplitting(arg,true); }
 
  string addInitialSplitting(string arg) { return addSplitting(arg,false); }
 
  string deleteFinalSplitting(string arg) { return deleteSplitting(arg,true); }
 
  string deleteInitialSplitting(string arg) { return deleteSplitting(arg,false); }
 
  const BranchingList & finalStateBranchings() const { return _fbranchings; }
 
  const BranchingList & initialStateBranchings() const { return _bbranchings; }
 
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
protected:
 
  virtual void rebind(const TranslationMap & trans)
   ;
 
  virtual IVector getReferences();
 
private:
 
  void addToMap(const IdList & ids, const SudakovPtr & sudakov, bool final);
 
  void deleteFromMap(const IdList & ids, const SudakovPtr & sudakov, bool final);
 
  void finalStateBasisVectors(ShowerParticle particle, Lorentz5Momentum & p,
                              Lorentz5Momentum & n) const;
 
  string addSplitting(string in ,bool final);
 
  string deleteSplitting(string in ,bool final);
 
private:
 
  SplittingGenerator & operator=(const SplittingGenerator &) = delete;
 
private:
 
  BranchingList _fbranchings;
 
  BranchingList _bbranchings;
 
  double _deTuning;
};
 
}
 
#endif /* HERWIG_SplittingGenerator_H */