QTildeShowerHandler.h

// -*- C++ -*-
#ifndef Herwig_QTildeShowerHandler_H
#define Herwig_QTildeShowerHandler_H
//
// This is the declaration of the QTildeShowerHandler class.
//
 
#include "QTildeShowerHandler.fh"
#include "Herwig/Shower/ShowerHandler.h"
#include "Herwig/Shower/QTilde/SplittingFunctions/SplittingGenerator.h"
#include "Herwig/Shower/QTilde/Base/ShowerTree.h"
#include "Herwig/Shower/QTilde/Base/ShowerProgenitor.fh"
#include "Herwig/Shower/QTilde/Base/HardTree.h"
#include "Herwig/Shower/QTilde/Base/Branching.h"
#include "Herwig/Shower/QTilde/Base/ShowerVeto.h"
#include "Herwig/Shower/QTilde/Base/FullShowerVeto.h"
#include "Herwig/Shower/QTilde/Kinematics/KinematicsReconstructor.fh"
#include "Herwig/Shower/QTilde/Base/PartnerFinder.fh"
#include "Herwig/Shower/QTilde/SplittingFunctions/SudakovFormFactor.fh"
#include "Herwig/MatrixElement/HwMEBase.h"
#include "Herwig/Decay/HwDecayerBase.h"
#include "Herwig/MatrixElement/Matchbox/Matching/ShowerApproximation.h"
#include "Herwig/Shower/RealEmissionProcess.h"
#include "Herwig/Utilities/Statistic.h"
 
namespace Herwig {
 
using namespace ThePEG;
 
class QTildeShowerHandler: public ShowerHandler {
 
public:
  
  typedef Ptr<XComb>::pointer XCPtr;
 
public:
 
  QTildeShowerHandler();
 
public:
 
  void fillEventRecord();
  
  virtual Energy hardScale() const {
    return muPt;
  }
 
  virtual bool showerHardProcessVeto() const { return false; }
  
  virtual HardTreePtr generateCKKW(ShowerTreePtr tree) const;
 
  virtual void showerHardProcess(ShowerTreePtr,XCPtr);
 
  virtual void showerDecay(ShowerTreePtr);
 
 
  tSplittingGeneratorPtr splittingGenerator() const { return _splittingGenerator; }
 
  int hardEmission() const {return _hardEmission;}
 
  virtual void connectTrees(ShowerTreePtr showerTree, HardTreePtr hardTree, bool hard );
 
  unsigned int softCorrelations() const {
    return _softOpt;
  }
 
  virtual bool correlations() const {
    return spinCorrelations()!=0||_softOpt!=0;
  }
 
public:
  tKinematicsReconstructorPtr kinematicsReconstructor() const { return _reconstructor; }
 
  tPartnerFinderPtr partnerFinder() const { return _partnerfinder; }
 
 
protected:
 
  void doShowering(bool hard,XCPtr);
 
  virtual RealEmissionProcessPtr hardMatrixElementCorrection(bool);
 
  virtual void hardestEmission(bool hard);
 
  void setupMECorrection(RealEmissionProcessPtr real);
 
  virtual vector<ShowerProgenitorPtr> setupShower(bool hard);
 
  virtual void setEvolutionPartners(bool hard,ShowerInteraction,
                                    bool clear);
 
  virtual bool timeLikeShower(tShowerParticlePtr particle, ShowerInteraction,
                              Branching fb, bool first);
 
  virtual bool spaceLikeShower(tShowerParticlePtr particle,PPtr beam,
                               ShowerInteraction); 
 
  virtual bool 
  spaceLikeDecayShower(tShowerParticlePtr particle,
                       const ShowerParticle::EvolutionScales & maxScales,
                       Energy minimumMass,ShowerInteraction,
                       Branching fb);
 
  virtual bool truncatedTimeLikeShower(tShowerParticlePtr particle,
                                       HardBranchingPtr branch,
                                       ShowerInteraction type,
                                       Branching fb, bool first);
 
  virtual bool truncatedSpaceLikeShower(tShowerParticlePtr particle,PPtr beam,
                                        HardBranchingPtr branch,
                                        ShowerInteraction type);
 
  virtual bool truncatedSpaceLikeDecayShower(tShowerParticlePtr particle,
                                             const ShowerParticle::EvolutionScales & maxScales,
                                             Energy minimumMass, HardBranchingPtr branch,
                                             ShowerInteraction type, Branching fb);
 
  bool MECOn() const { 
    return _hardEmission == 1;
  }
 
  bool hardMEC() const {
    return _hardEmission == 1 && (_meCorrMode == 1 || _meCorrMode == 2);
  }
 
  bool softMEC() const {
    return _hardEmission == 1 && (_meCorrMode == 1 || _meCorrMode > 2);
  }
 
  bool isTruncatedShowerON() const {return _trunc_Mode;}
 
  bool ipTon() const {
    return _iptrms != ZERO || ( _beta == 1.0 && _gamma != ZERO && _iptmax !=ZERO );
  }
 
  void addVeto (ShowerVetoPtr v) { _vetoes.push_back(v); }
 
  void removeVeto (ShowerVetoPtr v) { 
    vector<ShowerVetoPtr>::iterator vit = find(_vetoes.begin(),_vetoes.end(),v);
    if (vit != _vetoes.end())
      _vetoes.erase(vit);
  }
 
 
  bool hardVetoReadOption() const {return _hardVetoReadOption;}
 
  double initialStateRadiationEnhancementFactor() const { return _initialenhance; }
 
  double finalStateRadiationEnhancementFactor() const { return _finalenhance; }
 
  void initialStateRadiationEnhancementFactor(double in) { _initialenhance=in; }
 
  void finalStateRadiationEnhancementFactor(double in) { _finalenhance=in; }
 
  tHardTreePtr hardTree() {return _hardtree;}
 
  void hardTree(tHardTreePtr in) {_hardtree = in;}
 
  Ptr<BeamParticleData>::const_pointer beamParticle() const { return _beam; }
 
  void setBeamParticle(Ptr<BeamParticleData>::const_pointer in) { _beam=in; }
 
  tShowerTreePtr currentTree() { return _currenttree; }
 
  void currentTree(tShowerTreePtr tree) { _currenttree=tree; }
 
 
  unsigned int maximumTries() const { return _maxtry; }
 
  ShowerProgenitorPtr progenitor() { return _progenitor; }
 
  void progenitor(ShowerProgenitorPtr in) { _progenitor=in; }
 
  virtual void generateIntrinsicpT(vector<ShowerProgenitorPtr>);
 
  map<tShowerProgenitorPtr,pair<Energy,double> > & intrinsicpT() { return _intrinsic; }
 
  void setupMaximumScales(const vector<ShowerProgenitorPtr> &,XCPtr);
 
  void setupHardScales(const vector<ShowerProgenitorPtr> &,XCPtr);
 
  void convertHardTree(bool hard,ShowerInteraction type);
 
protected:
 
  PPtr findFirstParton(tPPtr seed) const;
 
  tPPair remakeRemnant(tPPair oldp); 
 
protected:
 
  virtual bool startTimeLikeShower(ShowerInteraction);
 
  void updateHistory(tShowerParticlePtr particle);
 
  virtual bool startSpaceLikeShower(PPtr,ShowerInteraction);
 
  virtual bool 
  startSpaceLikeDecayShower(const ShowerParticle::EvolutionScales & maxScales,
                            Energy minimumMass,ShowerInteraction);
 
  Branching selectTimeLikeBranching(tShowerParticlePtr particle,
                                    ShowerInteraction type,
                                    HardBranchingPtr branch);
 
  Branching selectSpaceLikeDecayBranching(tShowerParticlePtr particle,
                                          const ShowerParticle::EvolutionScales & maxScales,
                                          Energy minmass,ShowerInteraction type,
                                          HardBranchingPtr branch);
  ShowerParticleVector createTimeLikeChildren(tShowerParticlePtr particle,
                                              IdList ids);
 
  virtual bool timeLikeVetoed(const Branching &,ShowerParticlePtr);
 
  virtual bool spaceLikeVetoed(const Branching &,ShowerParticlePtr);
 
  virtual bool spaceLikeDecayVetoed(const Branching &,ShowerParticlePtr);
 
  bool hardOnly() const {return _limitEmissions==3;}
 
  void checkFlags();
 
  void addFSRUsingDecayPOWHEG(HardTreePtr ISRTree);
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual tPPair cascade(tSubProPtr sub, XCPtr xcomb);
 
  void decay(ShowerTreePtr tree, ShowerDecayMap & decay);
 
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
protected:
 
  virtual void doinit();
 
  virtual void doinitrun();
 
private:
 
  QTildeShowerHandler & operator=(const QTildeShowerHandler &) = delete;
 
private:
 
 
 
  ShowerTreePtr hard_;
 
  ShowerDecayMap decay_;
 
  vector<ShowerTreePtr> done_;
 
private :
 
  SplittingGeneratorPtr _splittingGenerator;
 
  unsigned int _maxtry;
 
  unsigned int _meCorrMode;
 
  unsigned int _evolutionScheme;
 
  bool _hardVetoReadOption; 
 
  Energy _iptrms;
 
  double _beta;
 
  Energy _gamma;
 
  Energy _iptmax;
 
  unsigned int _limitEmissions;
  
  ShowerProgenitorPtr _progenitor;
 
  HwMEBasePtr _hardme;
 
  HwDecayerBasePtr _decayme;
 
  ShowerTreePtr _currenttree;
 
  HardTreePtr _hardtree;
 
  double _initialenhance;
 
  double _finalenhance;
 
  Ptr<BeamParticleData>::const_pointer _beam;
 
  map<tShowerProgenitorPtr,pair<Energy,double> > _intrinsic;
 
  vector<ShowerVetoPtr> _vetoes;
 
  vector<FullShowerVetoPtr> _fullShowerVetoes;
 
  unsigned int _nReWeight;
 
  bool _reWeight;
 
  unsigned int _nis;
 
  unsigned int _nfs;
 
  ShowerInteraction interaction_;
 
  bool _trunc_Mode;
 
  int _hardEmission;
 
  unsigned int _softOpt;
 
  bool _hardPOWHEG;
 
  static bool _hardEmissionWarn;
 
  static bool _missingTruncWarn;
 
  Energy muPt;
 
private:
  KinematicsReconstructorPtr _reconstructor;
 
  PartnerFinderPtr _partnerfinder;
 
 
};
 
}
 
#endif /* HERWIG_QTildeShowerHandler_H */