PowhegShowerHandler.h

// -*- C++ -*-
//
// PowhegShowerHandler.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_PowhegShowerHandler_H
#define HERWIG_PowhegShowerHandler_H
//
// This is the declaration of the PowhegShowerHandler class.
//
 
#include "Herwig/Shower/QTilde/QTildeShowerHandler.h"
#include "Herwig/MatrixElement/Matchbox/MatchboxFactory.h"
#include "Herwig/MatrixElement/HwMEBase.h"
#include "Herwig/Shower/QTilde/Base/HardBranching.h"
 
#include "Herwig/Shower/QTilde/Matching/CKKWTree.h"
#include "Herwig/Shower/QTilde/Matching/ProtoTree.h"
#include "Herwig/Shower/QTilde/Matching/ProtoBranching.h"
#include "Herwig/Shower/QTilde/Matching/PotentialTree.h"
 
#include "ThePEG/MatrixElement/DiagramBase.fh"
#include "ThePEG/MatrixElement/MEBase.h"
#include "ThePEG/PDF/PartonExtractor.h"
#include "Herwig/Shower/QTilde/Base/HardTree.h"
 
// #include "Herwig/Shower/QTilde/SplittingFunctions/SplittingGenerator.h"
// #include "Herwig/Shower/QTilde/Base/ShowerModel.h"
// #include "ThePEG/PDF/BeamParticleData.h"
// #include "Herwig/Shower/QTilde/Base/ShowerTree.h"
// #include "Herwig/Shower/QTilde/Base/ShowerProgenitor.fh"
// #include "Herwig/Shower/QTilde/QTildeShowerHandler.fh"
// #include "Herwig/Shower/QTilde/Base/Branching.h"
// #include "Herwig/Shower/QTilde/Base/ShowerVeto.h"
// #include "ThePEG/Handlers/XComb.h"
// #include "Herwig/Decay/HwDecayerBase.h"
 
 
namespace Herwig {
 
using namespace ThePEG;
 
class PowhegShowerHandler: public QTildeShowerHandler {
 
public:
 
  PowhegShowerHandler() : subtractionIntegral_(false),
                          enforceColourConsistency_(false),
                          forcePartners_(false),
                          decayRadiation_(0)
  {}
 
public:
 
  Ptr<MatchboxFactory>::tptr Factory() const{return MatchboxFactory::currentFactory();}
 
  virtual bool canHandleMatchboxTrunc() const { return true; }
 
protected:
 
  virtual HardTreePtr generateCKKW(ShowerTreePtr tree) const;
 
protected:
 
  MEPtr matrixElement() const {return matrixElement_;}
 
  PotentialTree doClustering(tSubProPtr sub,ShowerTreePtr showerTree) const;
 
  PotentialTree & hardTree() {return hardTree_;}
  const PotentialTree & hardTree() const {return hardTree_;}
 
  void hardTree(PotentialTree in) const {hardTree_ = in;}
 
  bool fuzzyEqual(Lorentz5Momentum a, Lorentz5Momentum  b) const;
 
  set<ProtoBranchingPtr> & protoBranchings() const {return protoBranchings_;}
 
  set< ProtoTreePtr > & protoTrees() const {return protoTrees_;}
 
  void fillProtoTrees( ProtoTreePtr , long id ) const;
 
  tProtoBranchingPtr getCluster( tProtoBranchingPtr, tProtoBranchingPtr ) const;
 
  bool repeatProtoTree( ProtoTreePtr currentProtoTree ) const;
 
  BranchingElement allowedFinalStateBranching( tProtoBranchingPtr &,
                                               tProtoBranchingPtr &) const;
  
  BranchingElement allowedInitialStateBranching( tProtoBranchingPtr & ,
                                                 tProtoBranchingPtr &) const;
 
  bool checkDiagram(PotentialTree &,tcDiagPtr) const;
 
  bool subtractionIntegral() const {return subtractionIntegral_;}
 
  void setSubtractionIntegral(bool subInt) const { subtractionIntegral_=subInt;}
 
 
private:
 
  mutable MEPtr matrixElement_;
 
  mutable PotentialTree hardTree_;
 
  mutable set<ProtoBranchingPtr> protoBranchings_;
 
  mutable set< ProtoTreePtr > protoTrees_;
 
  mutable vector< pair< PotentialTree, double > > hardTrees_;
 
  mutable map<pair<long,long>,BranchingElement > allowedFinal_;
 
  mutable multimap<long, BranchingElement > allowedInitial_;
 
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 doinit();
 
private:
 
  PowhegShowerHandler & operator=(const PowhegShowerHandler &) = delete;
 
private:
 
  mutable int emitter_;
 
  mutable int spectator_;
 
  mutable bool subtractionIntegral_;
 
  bool enforceColourConsistency_;
 
  bool forcePartners_;
 
  unsigned int decayRadiation_;
 
};
 
}
 
#endif /* HERWIG_PowhegShowerHandler_H */