DipoleShowerHandler.h

// -*- C++ -*-
//
// DipoleShowerHandler.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_DipoleShowerHandler_H
#define HERWIG_DipoleShowerHandler_H
//
// This is the declaration of the DipoleShowerHandler class.
//
 
#include "Herwig/Shower/ShowerHandler.h"
 
#include "Herwig/Shower/Dipole/DipoleShowerHandler.fh"
#include "Herwig/Shower/Dipole/Base/DipoleSplittingInfo.h"
#include "Herwig/Shower/Dipole/Base/DipoleSplittingReweight.h"
#include "Herwig/Shower/Dipole/Kernels/DipoleSplittingKernel.h"
#include "Herwig/Shower/Dipole/Base/DipoleSplittingGenerator.h"
#include "Herwig/Shower/Dipole/Base/DipoleEventRecord.h"
#include "Herwig/Shower/Dipole/Base/DipoleEvolutionOrdering.h"
#include "Herwig/Shower/Dipole/Base/DipoleEventReweight.h"
#include "Herwig/Shower/Dipole/Utility/ConstituentReshuffler.h"
#include "Herwig/Shower/Dipole/Utility/IntrinsicPtGenerator.h"
#include "Herwig/MatrixElement/Matchbox/Base/MergerBase.h"
#include "Herwig/MatrixElement/Matchbox/Matching/ShowerApproximation.h"
 
#include "Herwig/Shower/Dipole/SpinCorrelations/DipoleVertexRecord.h"
#include "Herwig/MatrixElement/Matchbox/Utility/DensityOperator.h"
 
#include <tuple>
 
namespace Herwig {
 
using namespace ThePEG;
 
class DipoleShowerHandler: public ShowerHandler {
 
 
 friend class Merger;
 
public:
 
  DipoleShowerHandler();
 
public:
 
 
  inline void colourPrint();
 
  struct RedoShower {};
 
  void addSplitting(Ptr<DipoleSplittingKernel>::ptr sp) {
    kernels.push_back(sp);
  }
 
  void resetAlphaS(Ptr<AlphaSBase>::tptr);
  
  
  virtual void cascade(tPVector); 
 
  void resetReweight(Ptr<DipoleSplittingReweight>::tptr);
 
  virtual bool canHandleMatchboxTrunc() const { return false; }
 
  virtual bool isReshuffling() const { return false; }
 
  virtual Energy hardScale() const {
    return muPt;
  }
  
  double as(Energy Q)const{return theGlobalAlphaS->value(sqr(Q));}
  
  double Nf(Energy Q)const{return theGlobalAlphaS->Nf(sqr(Q));}
 
  /*
   * Access the vertex record
   */
  DipoleVertexRecord& vertexRecord() { return theVertexRecord; }
 
  const DipoleVertexRecord& vertexRecord() const { return theVertexRecord; }
 
 
  void setMerger(Ptr<MergerBase>::ptr mh){theMergingHelper=mh;}
 
 
 
public:
 
  const map<PPtr,size_t>& particleIndices() const { return eventRecord().particleIndices(); }
 
  const cPDVector& particlesAfter() const { return eventRecord().particlesAfter(); }
 
  DensityOperator& densityOperator() { return eventRecord().densityOperator(); }
 
  const map<pair<vector<PDT::Colour>,pair<size_t,size_t> >,double>& correlatorMap() const {
    return eventRecord().densityOperator().correlatorMap();
  }
 
  Ptr<ColourBasis>::tptr colourBasis() {
    return eventRecord().densityOperator().colourBasis();
  }
 
  bool continueSubleadingNc() const { return eventRecord().getContinueSubleadingNc(); }
 
protected:
 
  void addCandidates(PPair particles, list<DipoleSplittingInfo>& clist) const;
 
  void getCandidates(list<DipoleSplittingInfo>& clist) const;
 
  void performSplitting(DipoleSplittingInfo&) const;
 
  Energy nextSubleadingSplitting(Energy hardPt,
                                 Energy optHardPt, Energy optCutoff,
                                 const bool decay);
 
protected:
 
  typedef multimap<DipoleIndex,Ptr<DipoleSplittingGenerator>::ptr> GeneratorMap;
 
  virtual tPPair cascade(tSubProPtr sub, XCombPtr xcomb) {
    return cascade(sub,xcomb,ZERO,ZERO);
  }
 
  tPPair cascade(tSubProPtr sub, XCombPtr xcomb, 
                 Energy optHardPt, Energy optCutoff);
 
  void getGenerators(const DipoleIndex&,
                     Ptr<DipoleSplittingReweight>::tptr rw =
                     Ptr<DipoleSplittingReweight>::tptr());
 
  void hardScales(Energy2 scale);
 
  void hardScalesSubleading(list<DipoleSplittingInfo> candidates,Energy hardPt);
 
  Ptr<DipoleEvolutionOrdering>::tptr evolutionOrdering() const { return theEvolutionOrdering; }
 
  void constituentReshuffle();
 
  void decayConstituentReshuffle( PerturbativeProcessPtr decayProc);
 
  GeneratorMap& generators() { return theGenerators; }
 
  DipoleEventRecord& eventRecord() { return theEventRecord; }
 
  const DipoleEventRecord& eventRecord() const { return theEventRecord; }
 
  const vector<Ptr<DipoleSplittingKernel>::ptr>& splittingKernels() const {
    return kernels;
  }
  
  const set<long>& offShellPartons() { return theColouredOffShellInShower; }
  
  bool isMERegion(const Energy winnerScale,
                  const DipoleSplittingInfo & winner,
                  const list<Dipole>::iterator winnerDip);
  
  bool realign();
 
  virtual int showerPhaseSpaceOption() const {
    return theZBoundaries;
  }
 
protected:
 
  void doCascade(unsigned int& emDone,
                 Energy optHardPt = ZERO,
                 Energy optCutoff = ZERO,
                 const bool decay = false);
  void setNEmissions(unsigned int n){nEmissions=n;}
  
 
  Energy getWinner(DipoleSplittingInfo& winner,
                   const Dipole& dip,
                   pair<bool,bool> conf,
                   Energy optHardPt = ZERO,
                   Energy optCutoff = ZERO);
 
  Energy getWinner(DipoleSplittingInfo& winner,
                   Energy optHardPt = ZERO,
                   Energy optCutoff = ZERO);
 
  Energy getWinner(SubleadingSplittingInfo& winner,
                   Energy optHardPt = ZERO,
                   Energy optCutoff = ZERO);
 
  Energy getWinner(DipoleSplittingInfo& winner,
                   const DipoleIndex& index,
                   double emitterX, double spectatorX,
                   pair<bool,bool> conf,
                   tPPtr emitter, tPPtr spectator,
                   Energy startScale,
                   Energy optHardPt = ZERO,
                   Energy optCutoff = ZERO);
  
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).
 
 
protected:
 
  virtual void doinit();
 
  virtual void doinitrun();
 
  virtual void dofinish();
 
 
private:
 
  vector<Ptr<DipoleSplittingKernel>::ptr> kernels;
 
  Ptr<DipoleEvolutionOrdering>::ptr theEvolutionOrdering;
 
  Ptr<ConstituentReshuffler>::ptr constituentReshuffler;
 
  Ptr<IntrinsicPtGenerator>::ptr intrinsicPtGenerator;
 
  Ptr<AlphaSBase>::ptr theGlobalAlphaS;
 
  bool chainOrderVetoScales;
 
  unsigned int nEmissions;
 
  bool discardNoEmissions;
 
  bool firstMCatNLOEmission;
 
  bool thePowhegDecayEmission;
 
  //bool theAnalyseSpinCorrelations;
 
  int realignmentScheme;
 
  bool doSubleadingNc;
  
  size_t subleadingNcEmissionsLimit;
 
  int currentReferenceWeight;
 
  int densityOperatorEvolution;
 
  Energy2 densityOperatorCutoff;
 
  bool doPartialUnweightingAtEmission;
 
  bool doPartialUnweighting;
 
  double referenceWeight;
 
  double cmecReweightFactor;
 
  double negCMECScaling;
 
private:
 
  int verbosity;
 
  int printEvent;
 
private:
 
  GeneratorMap theGenerators;
 
  DipoleEventRecord theEventRecord;
 
  DipoleVertexRecord theVertexRecord;
 
  unsigned int nTries;
 
  bool didRadiate;
 
  bool didRealign;
 
  vector<vector<std::tuple<Energy,double,bool> > > theWeightsVector;
 
  size_t winnerIndex;//debug
  size_t kernelIndex;//debug
  size_t winningKernelIndex;//debug
  vector<Energy> scales;//debug
 
private:
 
  Energy theRenormalizationScaleFreeze;
 
  Energy theFactorizationScaleFreeze;
 
  Ptr<ShowerApproximation>::tptr theShowerApproximation;
 
  bool theDoCompensate;
 
  unsigned long theFreezeGrid;
 
  double theDetuning;
 
  Ptr<DipoleEventReweight>::ptr theEventReweight;
 
  Ptr<DipoleSplittingReweight>::ptr theSplittingReweight;
 
  static bool firstWarn;
 
  Energy maxPt;
 
  Energy muPt;
  
  
  Ptr<MergerBase>::ptr theMergingHelper;
 
 
  set<long> theColouredOffShellInShower;
 
  vector<long> theInputColouredOffShellInShower;
  
  int theZBoundaries;
  
private:
 
  static ClassDescription<DipoleShowerHandler> initDipoleShowerHandler;
 
  DipoleShowerHandler & operator=(const DipoleShowerHandler &) = delete;
 
};
 
}
 
#include "ThePEG/Utilities/ClassTraits.h"
 
namespace ThePEG {
 
template <>
struct BaseClassTrait<Herwig::DipoleShowerHandler,1> {
  typedef Herwig::ShowerHandler NthBase;
};
 
template <>
struct ClassTraits<Herwig::DipoleShowerHandler>
  : public ClassTraitsBase<Herwig::DipoleShowerHandler> {
  static string className() { return "Herwig::DipoleShowerHandler"; }
  static string library() { return "HwDipoleShower.so"; }
};
 
}
 
#endif /* HERWIG_DipoleShowerHandler_H */