ShowerTree.h

// -*- C++ -*-
//
// ShowerTree.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_ShowerTree_H
#define HERWIG_ShowerTree_H
 
#include "ThePEG/Config/ThePEG.h"
#include "Herwig/Shower/ShowerHandler.fh"
#include "Herwig/Shower/PerturbativeProcess.h"
#include "Herwig/Shower/RealEmissionProcess.h"
#include "Herwig/Shower/ShowerEventRecord.h"
#include "Herwig/Shower/QTilde/ShowerConfig.h"
#include "Herwig/Shower/QTilde/Base/ShowerParticle.h"
#include "Herwig/Shower/QTilde/Base/ShowerProgenitor.h"
#include "ThePEG/EventRecord/Step.h"
#include <cassert>
#include "ShowerTree.fh"
 
namespace Herwig {
 
typedef multimap<Energy,ShowerTreePtr,std::greater<Energy> > ShowerDecayMap;
  
using namespace ThePEG;
 
class ShowerTree : public ShowerEventRecord {
 
  friend class QTildeShowerHandler;
 
public:
 
  ShowerTree(PerturbativeProcessPtr process);
 
  static Lorentz5Distance spaceTimeDistance(tPPtr particle);
 
  static void constructTrees(ShowerTreePtr & hardTree,
                             ShowerDecayMap & decayTrees,
                             PerturbativeProcessPtr hard,
                             DecayProcessMap decay);
 
public:
 
  void fillEventRecord(StepPtr pstep,bool ISR,bool FSR) {
    if(_wasHard) 
      insertHard (pstep,ISR,FSR);
    else         
      insertDecay(pstep,ISR,FSR);
  }
  
 
  void setParents();
 
  bool isHard() const { return _wasHard; } 
 
 
  bool isDecay() const { return !_wasHard; }
 
  map<ShowerProgenitorPtr,ShowerParticlePtr> & incomingLines() {
    return _incomingLines; 
  }
 
  map<ShowerProgenitorPtr,tShowerParticlePtr> & outgoingLines() {
    return _outgoingLines; 
  }
 
  void updateFinalStateShowerProduct(ShowerProgenitorPtr progenitor,
                                     ShowerParticlePtr parent,
                                     const ShowerParticleVector & children);
 
  void updateInitialStateShowerProduct(ShowerProgenitorPtr progenitor,
                                       ShowerParticlePtr newParent);
 
  tShowerParticlePtr getFinalStateShowerProduct(ShowerProgenitorPtr progenitor) {
    return _outgoingLines.find(progenitor)==_outgoingLines.end()
      ? tShowerParticlePtr() : _outgoingLines[progenitor];
  }
 
  void addFinalStateBranching(ShowerParticlePtr parent,
                              const ShowerParticleVector & children);
 
  void addInitialStateBranching(ShowerParticlePtr oldParent,
                                ShowerParticlePtr newParent,
                                ShowerParticlePtr otherChild);
 
  // /**
  //  *  Member called at the end of the shower of a tree to perform a number of
  //  *  updates.
  //  *  @param decay The map of widths and ShowerTrees for the decays so that
  //  *  any unstable decay products can be added.
  //  */
  void updateAfterShower(ShowerDecayMap & decay);
 
  bool hasShowered() const { return _hasShowered; }
 
  void hasShowered(bool in) { _hasShowered=in; }
 
  ShowerTreePtr parent() const { return _parent; }
 
  void clear();
 
  void resetShowerProducts();
 
  void setVetoes(const map<ShowerInteraction,Energy> & pTs,
                 unsigned int type);
 
  vector<ShowerProgenitorPtr> extractProgenitors();
 
  const set<tShowerParticlePtr> & forwardParticles() const { return _forward; }
 
  const map<tShowerTreePtr,pair<tShowerProgenitorPtr,tShowerParticlePtr> > &
  treelinks()  const {return _treelinks;}
 
  void updateLink(tShowerTreePtr tree,
                  pair<tShowerProgenitorPtr,tShowerParticlePtr> in) {
    _treelinks[tree] = in;
  }
 
  void transform(const LorentzRotation & rot, bool applyNow);
 
  void applyTransforms();
 
  void clearTransforms();
 
  const LorentzRotation & transform() {return _transforms;}
 
  vector<ShowerParticlePtr> extractProgenitorParticles();
 
  void checkMomenta();
 
  void update(PerturbativeProcessPtr newProcess);
 
  RealEmissionProcessPtr perturbativeProcess();
 
protected:
 
  void insertHard(StepPtr pstep,bool ISR,bool FSR);
 
  void insertDecay(StepPtr pstep,bool ISR,bool FSR);
 
  void addFinalStateShower(PPtr particle, StepPtr step);
 
  void addInitialStateShower(PPtr particle, PPtr hadron,
                             StepPtr step, bool addchildren=true);
 
  void fixColour(tShowerParticlePtr part);
 
private:
  PPair _incoming;
  
  map<ShowerProgenitorPtr,ShowerParticlePtr> _incomingLines;
 
  map<ShowerProgenitorPtr,tShowerParticlePtr> _outgoingLines;
 
  set<tShowerParticlePtr> _forward;
 
  bool _wasHard;
 
  map<tShowerTreePtr,pair<tShowerProgenitorPtr,tShowerParticlePtr> > _treelinks;
 
  tShowerTreePtr _parent;
 
  bool _hasShowered;
 
  LorentzRotation _transforms;
 
private:
 
  static bool _spaceTime;
 
  static Energy2 _vmin2;
 
};
}
 
#endif