Evolver.h

// -*- C++ -*-
//
// Evolver.h is a part of Herwig++ - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2011 The Herwig Collaboration
//
// Herwig++ is licenced under version 2 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef HERWIG_Evolver_H
#define HERWIG_Evolver_H
//
// This is the declaration of the Evolver class.
//

#include "ThePEG/Interface/Interfaced.h"
#include "Herwig++/Shower/SplittingFunctions/SplittingGenerator.h"
#include "ShowerModel.h"
#include "ThePEG/PDF/BeamParticleData.h"
#include "ShowerTree.h"
#include "ShowerProgenitor.fh"
#include "Herwig++/Shower/ShowerHandler.fh"
#include "Branching.h"
#include "ShowerVeto.h"
#include "HardTree.h"
#include "ThePEG/Handlers/XComb.h"
#include "Evolver.fh"
#include "Herwig++/MatrixElement/HwMEBase.h"
#include "Herwig++/Decay/HwDecayerBase.h"

namespace Herwig {

using namespace ThePEG;

class Evolver: public Interfaced {

friend class ShowerHandler;

public:
  
  typedef Ptr<XComb>::pointer XCPtr;

public:

  Evolver() : _maxtry(100), _meCorrMode(1), _hardVetoMode(1),
              _hardVetoRead(0), _reconOpt(0), _hardVetoReadOption(false),
              _iptrms(ZERO), _beta(0.), _gamma(ZERO), _iptmax(),
              _limitEmissions(0), _initialenhance(1.), _finalenhance(1.),
              _hardonly(false), _trunc_Mode(true), _hardEmissionMode(0),
              _colourEvolutionMethod(0), _hardScaleFactor(1.0)
  {}

  virtual void showerHardProcess(ShowerTreePtr,XCPtr);

  virtual void showerDecay(ShowerTreePtr);

  bool showeringON() const { return isISRadiationON() || isFSRadiationON(); }

  bool isISRadiationON() const { return _splittingGenerator->isISRadiationON(); }

  bool isFSRadiationON() const { return _splittingGenerator->isFSRadiationON(); }

  ShowerModelPtr showerModel() const {return _model;}

  tSplittingGeneratorPtr splittingGenerator() const { return _splittingGenerator; }

  virtual void connectTrees(ShowerTreePtr showerTree, HardTreePtr hardTree, bool hard )const;

public:

  void persistentOutput(PersistentOStream & os) const;

  void persistentInput(PersistentIStream & is, int version);

  static void Init();

protected:

  virtual void hardMatrixElementCorrection(bool);

  virtual void hardestEmission(bool hard);

  virtual vector<ShowerProgenitorPtr> setupShower(bool hard);

  virtual void setEvolutionPartners(bool hard,ShowerInteraction::Type);

  virtual bool timeLikeShower(tShowerParticlePtr particle, ShowerInteraction::Type,
                              bool first); 

  virtual bool spaceLikeShower(tShowerParticlePtr particle,PPtr beam,
                               ShowerInteraction::Type); 

  virtual bool spaceLikeDecayShower(tShowerParticlePtr particle,
                                    Energy maxscale,
                                    Energy minimumMass,
                                    ShowerInteraction::Type);

  virtual bool truncatedTimeLikeShower(tShowerParticlePtr particle,
                                       HardBranchingPtr branch,
                                       ShowerInteraction::Type type);
 
  virtual bool truncatedSpaceLikeShower(tShowerParticlePtr particle,PPtr beam,
                                        HardBranchingPtr branch,
                                        ShowerInteraction::Type type);

  virtual bool truncatedSpaceLikeDecayShower(tShowerParticlePtr particle,
                                             Energy maxscale, Energy minimumMass,
                                             HardBranchingPtr branch,
                                             ShowerInteraction::Type type);

  bool MECOn() const {
    return _meCorrMode > 0 && _hardEmissionMode==0;
  }

  bool hardMEC() const {
    return (_meCorrMode == 1 || _meCorrMode == 2) && _hardEmissionMode==0;
  }

  bool softMEC() const {
    return (_meCorrMode == 1 || _meCorrMode > 2) && _hardEmissionMode==0;
  }

  bool isTruncatedShowerON() const {return _trunc_Mode;}

  bool ipTon() const {
    return _iptrms != ZERO || ( _beta == 1.0 && _gamma != ZERO && _iptmax !=ZERO );
  }

  void addVeto (ShowerVetoPtr v) { _vetoes.push_back(v); }

  void removeVeto (ShowerVetoPtr v) { 
    vector<ShowerVetoPtr>::iterator vit = find(_vetoes.begin(),_vetoes.end(),v);
    if (vit != _vetoes.end())
      _vetoes.erase(vit);
  }


  bool hardVetoOn() const { return _hardVetoMode > 0; }

  bool hardVetoIS() const { return _hardVetoMode == 1 || _hardVetoMode == 2; }

  bool hardVetoFS() const { return _hardVetoMode == 1 || _hardVetoMode > 2; }

  bool hardVetoXComb() const {return (_hardVetoRead == 1);}

  bool hardVetoReadOption() const {return _hardVetoReadOption;}

  double initialStateRadiationEnhancementFactor() const { return _initialenhance; }

  double finalStateRadiationEnhancementFactor() const { return _finalenhance; }

  void initialStateRadiationEnhancementFactor(double in) { _initialenhance=in; }

  void finalStateRadiationEnhancementFactor(double in) { _finalenhance=in; }

  tHardTreePtr hardTree() {return _hardtree;}

  void hardTree(tHardTreePtr in) {_hardtree = in;}

  Ptr<BeamParticleData>::const_pointer beamParticle() const { return _beam; }

  void setBeamParticle(Ptr<BeamParticleData>::const_pointer in) { _beam=in; }

  tShowerTreePtr currentTree() { return _currenttree; }

  void currentTree(tShowerTreePtr tree) { _currenttree=tree; }


  unsigned int maximumTries() const { return _maxtry; }

  ShowerProgenitorPtr progenitor() { return _progenitor; }

  void progenitor(ShowerProgenitorPtr in) { _progenitor=in; }

  virtual void generateIntrinsicpT(vector<ShowerProgenitorPtr>);

  map<tShowerProgenitorPtr,pair<Energy,double> > & intrinsicpT() { return _intrinsic; }

  void setupMaximumScales(ShowerTreePtr, const vector<ShowerProgenitorPtr> &,XCPtr);

  double hardScaleFactor() const { return _hardScaleFactor; }

  void hardScaleFactor(double f) { _hardScaleFactor = f; };

protected:

  virtual bool startTimeLikeShower(ShowerInteraction::Type);

  void updateHistory(tShowerParticlePtr particle);

  virtual bool startSpaceLikeShower(PPtr,ShowerInteraction::Type);

  virtual bool startSpaceLikeDecayShower(Energy maxscale,Energy minimumMass,
                                         ShowerInteraction::Type);

  virtual bool timeLikeVetoed(const Branching &,ShowerParticlePtr);

  virtual bool spaceLikeVetoed(const Branching &,ShowerParticlePtr);

  virtual bool spaceLikeDecayVetoed(const Branching &,ShowerParticlePtr);

  bool hardOnly() const {return _hardonly;}

protected:

  virtual IBPtr clone() const;

  virtual IBPtr fullclone() const;

private:

  double getReductionFactor(tShowerParticlePtr particle);

  Evolver & operator=(const Evolver &);

private:

  ShowerModelPtr _model;

  SplittingGeneratorPtr _splittingGenerator;

  unsigned int _maxtry;

  unsigned int _meCorrMode; 

  unsigned int _hardVetoMode; 

  unsigned int _hardVetoRead; 

  unsigned int _reconOpt;

  bool _hardVetoReadOption; 

  Energy _iptrms;

  double _beta;

  Energy _gamma;

  Energy _iptmax;

  unsigned int _limitEmissions;
  
  ShowerProgenitorPtr _progenitor;

  HwMEBasePtr _hardme;

  HwDecayerBasePtr _decayme;

  ShowerTreePtr _currenttree;

  HardTreePtr _hardtree;

  double _initialenhance;

  double _finalenhance;

  Ptr<BeamParticleData>::const_pointer _beam;

  map<tShowerProgenitorPtr,pair<Energy,double> > _intrinsic;

  vector<ShowerVetoPtr> _vetoes;

  unsigned int _nis;

  unsigned int _nfs;

  bool _hardonly;

  bool _trunc_Mode;
  
  unsigned int _truncEmissions;

  unsigned int _hardEmissionMode;

  int _colourEvolutionMethod;

  double _hardScaleFactor;

};

}

#endif /* HERWIG_Evolver_H */