ShowerProgenitor.h

// -*- C++ -*-
//
// ShowerProgenitor.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_ShowerProgenitor_H
#define HERWIG_ShowerProgenitor_H
//
// This is the declaration of the ShowerProgenitor struct.
//
 
#include "ThePEG/Config/ThePEG.h"
#include "Herwig/Shower/QTilde/ShowerConfig.h"
#include "Herwig/Shower/QTilde/Base/ShowerParticle.h"
#include "ShowerProgenitor.fh"
#include "ThePEG/PDF/BeamParticleData.h"
 
namespace Herwig {
 
using namespace ThePEG;
 
class ShowerProgenitor : public Base {
 
public:
 
  enum Reconstructed { notReconstructed=0, done, dontReconstruct};
 
 
typedef Ptr<BeamParticleData>::transient_const_pointer tcBeamPtr;
 
public:
 
  ShowerProgenitor(PPtr original,PPtr copy, ShowerParticlePtr particle,
                   Energy pT=ZERO,bool emitted=false)
    : _original(original), _copy(copy), _perturbative(true),
      _particle(particle), _highestpT(pT), 
      _maxHardPt(ZERO), _hardScale(ZERO), _hasEmitted(emitted),
      _reconstructed(notReconstructed) {
    // get the BeamParticleData object
    if ( original->parents().empty() ) {
      _beam=dynamic_ptr_cast<tcBeamPtr>(original->dataPtr());
    } 
    else {
      _beam=dynamic_ptr_cast<tcBeamPtr>(original->parents()[0]->dataPtr());
    }
  }
  
  ShowerParticlePtr progenitor() const { return _particle; }
 
  void progenitor(ShowerParticlePtr in) { _particle=in; }
 
  PPtr original() const { return _original; }
 
  PPtr copy() const { return _copy; }
 
  void copy(PPtr in) { _copy=in; }
 
  bool perturbative() const { return _perturbative; }
 
  void perturbative(bool in) { _perturbative=in; }
 
  Energy highestpT() const { return _highestpT; }
 
  void highestpT(Energy in) { _highestpT=in; }
 
  Energy maximumpT(ShowerInteraction type) const {
    assert(type!=ShowerInteraction::QEDQCD && type!=ShowerInteraction::ALL && type!=ShowerInteraction::UNDEFINED);
    map<ShowerInteraction,Energy>::const_iterator it = _maxpT.find(type);
    return it !=_maxpT.end() ? it->second : Constants::MaxEnergy; 
  }
 
  void maximumpT(Energy in,ShowerInteraction type) {
    _maxpT[type]=in; }
 
  Energy maxHardPt() const { return _maxHardPt; }
 
  void maxHardPt(Energy in) { _maxHardPt = in; }
 
  Energy hardScale() const { return _hardScale; }
 
  void hardScale(Energy in) { _hardScale = in; }
 
  bool hasEmitted() const { return _hasEmitted; }
 
  void hasEmitted(bool in) { _hasEmitted=in; }
 
  long id() const { return _particle->id(); }
 
  tcBeamPtr beam() { return _beam; }
 
  Reconstructed reconstructed() const {return _reconstructed;}
 
  void reconstructed(Reconstructed recon) {_reconstructed = recon;}
 
private:
 
  PPtr _original;
 
  PPtr _copy;
 
  bool _perturbative;
 
  ShowerParticlePtr _particle;
 
  Energy _highestpT;
 
  map<ShowerInteraction,Energy> _maxpT;
 
  Energy _maxHardPt;
 
  Energy _hardScale;
 
  bool _hasEmitted;
 
  tcBeamPtr _beam;
 
  Reconstructed _reconstructed;
 
};
}
 
#endif /* HERWIG_ShowerProgenitor_H */