ShowerHandler.h

// -*- C++ -*-
//
// ShowerHandler.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_ShowerHandler_H
#define HERWIG_ShowerHandler_H
//
// This is the declaration of the ShowerHandler class.
//
 
#include "ThePEG/Handlers/EventHandler.h"
#include "ThePEG/Handlers/CascadeHandler.h"
#include "ShowerVariation.h"
#include "Herwig/PDF/HwRemDecayer.fh"
#include "ThePEG/EventRecord/RemnantParticle.fh"
#include "UEBase.h"
#include "PerturbativeProcess.h"
#include "Herwig/MatrixElement/Matchbox/Matching/HardScaleProfile.h"
#include "ShowerHandler.fh"
 
namespace Herwig {
using namespace ThePEG;
 
class ShowerHandler: public CascadeHandler {
 
public:
 
  typedef pair<tRemPPtr, tRemPPtr> RemPair;
 
public:
 
  ShowerHandler();
 
  virtual ~ShowerHandler();
 
public:
 
  virtual void cascade();
 
  static const tShowerHandlerPtr currentHandler() {
    if(currentHandler_)
      return currentHandler_;
    else
      return tShowerHandlerPtr();
  }
 
  static bool currentHandlerIsSet() {
    return currentHandler_;
  }
 
public:
 
  virtual bool showerHardProcessVeto() const { return false; }
 
  virtual bool isReshuffling() const { return true; }
 
  virtual bool retConstituentMasses() const { return useConstituentMasses_; }
 
 
 
  virtual bool canHandleMatchboxTrunc() const { return false; }
 
  Energy pdfFreezingScale() const { return pdfFreezingScale_; }
 
  PDFPtr getPDFA() const {return PDFA_;}
 
  PDFPtr getPDFB() const {return PDFB_;}
 
  bool firstInteraction() const {
    if (!eventHandler()->currentCollision())return true;
    return ( subProcess_ ==
             eventHandler()->currentCollision()->primarySubProcess() );
  }
 
  tHwRemDecPtr remnantDecayer() const { return remDec_; }
 
  void splitHardProcess(tPVector tagged, PerturbativeProcessPtr & hard,
                        DecayProcessMap & decay) const;
 
  bool doesSplitHardProcess()const {return splitHardProcess_;}
 
  tDMPtr decay(PerturbativeProcessPtr,
               DecayProcessMap & decay,
               bool radPhotons = false) const;
 
 
  tDMPtr findDecayMode(const string & tag) const;
 
 
  struct ParticleOrdering {
 
    bool operator() (tcPDPtr p1, tcPDPtr p2) const;
 
  };
 
 
  typedef multiset<tcPDPtr,ParticleOrdering> OrderedParticles;
 
 
public:
 
  bool doRadiation() const {return doFSR_ || doISR_;}
 
  bool doFSR() const { return doFSR_;}
 
  bool doISR() const { return doISR_;}
 
public:
 
  bool hardScaleIsMuF() const { return maxPtIsMuF_; }
 
  double factorizationScaleFactor() const {
    return factorizationScaleFactor_;
  }
 
  double renFac() const {
    return renormalizationScaleFactor_;
  }
 
  double facFac() const {
    return factorizationScaleFactor_;
  }
 
  double renormalizationScaleFactor() const {
    return renormalizationScaleFactor_;
  }
 
  double hardScaleFactor() const {
    return hardScaleFactor_;
  }
  bool restrictPhasespace() const { return restrictPhasespace_; }
 
  Ptr<HardScaleProfile>::tptr profileScales() const { return hardScaleProfile_; }
 
  virtual Energy hardScale() const;
 
  virtual int showerPhaseSpaceOption() const {
    assert(false && "not implemented in general");
    return -1;
  }
 
public:
 
  map<string,ShowerVariation>& showerVariations() {
    return showerVariations_;
  }
 
  const map<string,ShowerVariation>& showerVariations() const {
    return showerVariations_;
  }
 
  map<string,double>& currentWeights() {
    return currentWeights_;
  }
 
  const map<string,double>& currentWeights() const {
    return currentWeights_;
  }
 
  void reweight(double w) {
    reweight_ = w;
  }
 
  double reweight() const {
    return reweight_;
  }
 
public :
 
  unsigned int spinCorrelations() const {
    return spinOpt_;
  }
 
  virtual bool correlations() const {
    return spinOpt_!=0;
  }
 
public:
 
  struct ExtraScatterVeto {};
 
  struct ShowerTriesVeto {
    const int tries;
 
    ShowerTriesVeto(int t) : tries(t) {}
  };
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual tPPair cascade(tSubProPtr sub, XCPtr xcomb);
 
  void prepareCascade(tSubProPtr sub) {
    current_ = currentStep();
    subProcess_ = sub;
  }
 
  void boostCollision(bool boost);
 
protected:
 
  void setCurrentHandler() {
    currentHandler_ = tShowerHandlerPtr(this);
  }
 
  void unSetCurrentHandler() {
    currentHandler_ = tShowerHandlerPtr();
  }
 
protected:
 
  bool isMPIOn() const {
    return MPIHandler_ && MPIHandler_->beamOK();
  }
 
  tUEBasePtr getMPIHandler() const {
    assert(MPIHandler_);
    return MPIHandler_;
  }
 
  bool isResolvedHadron(tPPtr);
 
  RemPair getRemnants(PBIPair incbins);
 
  void setMPIPDFs();
 
public:
 
  bool decaysInShower(long id) const {
    return ( particlesDecayInShower_.find( abs(id) ) !=
             particlesDecayInShower_.end() );
  }
 
protected:
 
  void findDecayProducts(PPtr parent, PerturbativeProcessPtr hard, DecayProcessMap & decay) const;
 
  void createDecayProcess(PPtr parent,PerturbativeProcessPtr hard, DecayProcessMap & decay) const;
 
  tSubProPtr currentSubProcess() const {
    assert(subProcess_);
    return subProcess_;
  }
 
  tPPair incomingBeams() const {
    return incoming_;
  }
 
protected:
 
  //@
  void combineWeights();
 
  void initializeWeights();
 
  void resetWeights();
 
protected:
 
  unsigned int maxtry() const { return maxtry_; }
 
protected:
 
  bool includeSpaceTime() const {return includeSpaceTime_;}
 
  Energy2 vMin() const {return vMin_;}
 
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
protected:
 
  virtual void doinit();
 
  virtual void doinitrun();
 
  virtual void dofinish();
 
private:
 
  ShowerHandler & operator=(const ShowerHandler &) = delete;
 
private:
 
  static tShowerHandlerPtr  currentHandler_;
 
  UEBasePtr MPIHandler_;
 
  HwRemDecPtr remDec_;
 
private:
 
  unsigned int maxtry_;
 
  unsigned int maxtryMPI_;
 
  unsigned int maxtryDP_;
 
  unsigned int maxtryDecay_;
 
private:
 
  double factorizationScaleFactor_;
 
  double renormalizationScaleFactor_;
 
  double hardScaleFactor_;
 
  bool restrictPhasespace_;
 
  bool maxPtIsMuF_;
 
  Ptr<HardScaleProfile>::ptr hardScaleProfile_;
 
  unsigned int spinOpt_;
 
private:
 
  tPPair incoming_;
 
  LorentzRotation boost_;
 
  tSubProPtr subProcess_;
 
  tcStepPtr current_;
 
private:
 
  Energy pdfFreezingScale_;
 
  PDFPtr PDFA_;
 
  PDFPtr PDFB_;
 
  PDFPtr PDFARemnant_;
 
  PDFPtr PDFBRemnant_;
 
  pair <PDFPtr, PDFPtr> mpipdfs_;
 
  pair <PDFPtr, PDFPtr> rempdfs_;
 
  pair <PDFPtr, PDFPtr> remmpipdfs_;
 
private:
 
  bool doFSR_;
 
  bool doISR_;
 
private:
 
  bool splitHardProcess_;
 
  set<long> particlesDecayInShower_;
 
  vector<long> inputparticlesDecayInShower_;
 
private:
 
  bool includeSpaceTime_;
 
  Energy2 vMin_;
 
 
private:
 
 
  bool useConstituentMasses_ = true;
 
  int tagIntermediates_ = 0;
 
 
private:
 
  map<string,ShowerVariation> showerVariations_;
 
  string doAddVariation(string);
 
  double reweight_;
 
  map<string,double> currentWeights_;
};
 
}
 
#endif /* HERWIG_ShowerHandler_H */