Pythia8Hadronizer Class Reference

Inheritance diagram for Pythia8Hadronizer:

Public Member Functions
const char *	classname () const override
void	finalizeEvent () override
bool	generatePartonsAndHadronize () override
bool	hadronize ()
bool	initializeForExternalPartons ()
bool	initializeForInternalPartons () override
	Pythia8Hadronizer (const edm::ParameterSet &params)
virtual bool	residualDecay ()
void	statistics () override
	~Pythia8Hadronizer ()
Public Member Functions inherited from gen::BaseHadronizer
	BaseHadronizer (edm::ParameterSet const &ps)
edm::Event &	getEDMEvent () const
HepMC::GenEvent *	getGenEvent ()
GenEventInfoProduct *	getGenEventInfo ()
GenRunInfoProduct &	getGenRunInfo ()
const boost::shared_ptr < lhef::LHERunInfo > &	getLHERunInfo () const
void	resetEvent (HepMC::GenEvent *event)
void	resetEventInfo (GenEventInfoProduct *eventInfo)
virtual bool	select (HepMC::GenEvent *) const
void	setEDMEvent (edm::Event &event)
void	setLHEEvent (lhef::LHEEvent *event)
void	setLHERunInfo (lhef::LHERunInfo *runInfo)
void	setRandomEngine (CLHEP::HepRandomEngine *v)
std::vector< std::string > const &	sharedResources () const
	~BaseHadronizer ()
Public Member Functions inherited from gen::Py8InterfaceBase
bool	decay ()
bool	declareSpecialSettings (const std::vector< std::string > &)
bool	declareStableParticles (const std::vector< int > &)
void	p8SetRandomEngine (CLHEP::HepRandomEngine *v)
	Py8InterfaceBase (edm::ParameterSet const &ps)
P8RndmEngine &	randomEngine ()
bool	readSettings (int)
	~Py8InterfaceBase ()

Private Types
enum	{ PP, PPbar, ElectronPositron }

Private Member Functions
virtual void	doSetRandomEngine (CLHEP::HepRandomEngine *v) override
virtual std::vector < std::string > const &	doSharedResources () const override

Private Attributes
double	comEnergy
	Center-of-Mass energy. More...
vector< float >	DJR
int	EV1_emittedMode
int	EV1_maxVetoCount
bool	EV1_MPIvetoOn
int	EV1_nFinal
int	EV1_pTdefMode
int	EV1_pTempMode
int	EV1_pThardMode
bool	EV1_vetoOn
double	fBeam1PZ
double	fBeam2PZ
PowhegHooks *	fEmissionVetoHook
EmissionVetoHook1 *	fEmissionVetoHook1
int	fInitialState
JetMatchingHook *	fJetMatchingHook
Pythia8::JetMatchingMadgraph *	fJetMatchingPy8InternalHook
Pythia8::amcnlo_unitarised_interface *	fMergingHook
MultiUserHook *	fMultiUserHook
ResonanceDecayFilterHook *	fResonanceDecayFilterHook
UserHooks *	fReweightPtHatRapUserHook
UserHooks *	fReweightRapUserHook
UserHooks *	fReweightUserHook
std::auto_ptr< LHAupLesHouches >	lhaUP
std::string	LHEInputFileName
int	nFSRveto
int	NHooks
int	nISRveto
int	nME
int	nMEFiltered
std::string	slhafile_

Static Private Attributes
static const std::vector < std::string >	p8SharedResources = { edm::SharedResourceNames::kPythia8 }

Additional Inherited Members
Protected Member Functions inherited from gen::BaseHadronizer
std::auto_ptr< HepMC::GenEvent > &	event ()
std::auto_ptr < GenEventInfoProduct > &	eventInfo ()
lhef::LHEEvent *	lheEvent ()
lhef::LHERunInfo *	lheRunInfo ()
GenRunInfoProduct &	runInfo ()
Protected Attributes inherited from gen::Py8InterfaceBase
HepMC::IO_AsciiParticles *	ascii_io
EvtGenDecays *	evtgenDecays
std::string	evtgenDecFile
std::string	evtgenPdlFile
std::vector< std::string >	evtgenUserFiles
std::auto_ptr< Pythia8::Pythia >	fDecayer
std::auto_ptr< Pythia8::Pythia >	fMasterGen
ParameterCollector	fParameters
unsigned int	maxEventsToPrint
bool	pythiaHepMCVerbosity
bool	pythiaHepMCVerbosityParticles
unsigned int	pythiaPylistVerbosity
HepMC::Pythia8ToHepMC	toHepMC
bool	useEvtGen

Detailed Description

Definition at line 66 of file Pythia8Hadronizer.cc.

Member Enumeration Documentation

anonymous enum

private

Enumerator
PP
PPbar
ElectronPositron

Definition at line 98 of file Pythia8Hadronizer.cc.

{ PP, PPbar, ElectronPositron };

Constructor & Destructor Documentation

Pythia8Hadronizer::Pythia8Hadronizer

(

const edm::ParameterSet &

params

)

Definition at line 153 of file Pythia8Hadronizer.cc.

References MultiUserHook::addHook(), gen::ParameterCollector::begin(), edm::errors::Configuration, ElectronPositron, gen::ParameterCollector::end(), EV1_emittedMode, EV1_maxVetoCount, EV1_MPIvetoOn, EV1_nFinal, EV1_pTdefMode, EV1_pTempMode, EV1_pThardMode, EV1_vetoOn, Exception, edm::ParameterSet::exists(), validate-o2o-wbm::f1, ztee::fd, fEmissionVetoHook1, fInitialState, fJetMatchingHook, gen::Py8InterfaceBase::fMasterGen, fMultiUserHook, gen::Py8InterfaceBase::fParameters, fReweightPtHatRapUserHook, fReweightRapUserHook, fReweightUserHook, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), geometryCSVtoXML::line, NHooks, PP, PPbar, slhafile_, AlCaHLTBitMon_QueryRunRegistry::string, and TablePrint::write.

                                                                  :
  BaseHadronizer(params), Py8InterfaceBase(params),
  comEnergy(params.getParameter<double>("comEnergy")),
  LHEInputFileName(params.getUntrackedParameter<std::string>("LHEInputFileName","")),
  fInitialState(PP),
  fMultiUserHook(new MultiUserHook), fReweightUserHook(0),fReweightRapUserHook(0),fReweightPtHatRapUserHook(0),
  fJetMatchingHook(0),fJetMatchingPy8InternalHook(0), fMergingHook(0),
  fEmissionVetoHook(0), fEmissionVetoHook1(0), fResonanceDecayFilterHook(0), nME(-1), nMEFiltered(-1), nISRveto(0), nFSRveto(0),
  NHooks(0)
{

  // J.Y.: the following 3 parameters are hacked "for a reason"
  //
  if ( params.exists( "PPbarInitialState" ) )
  {
    if ( fInitialState == PP )
    {
      fInitialState = PPbar;
      edm::LogImportant("GeneratorInterface|Pythia8Interface")
      << "Pythia8 will be initialized for PROTON-ANTIPROTON INITIAL STATE. "
      << "This is a user-request change from the DEFAULT PROTON-PROTON initial state.";
    }
    else
    {   
      // probably need to throw on attempt to override ?
    }
  }   
  else if ( params.exists( "ElectronPositronInitialState" ) )
  {
    if ( fInitialState == PP )
    {
      fInitialState = ElectronPositron;
      edm::LogInfo("GeneratorInterface|Pythia8Interface")
      << "Pythia8 will be initialized for ELECTRON-POSITRON INITIAL STATE. "
      << "This is a user-request change from the DEFAULT PROTON-PROTON initial state.";
    }
    else
    {   
       // probably need to throw on attempt to override ?
    }
  }
  else if ( params.exists( "ElectronProtonInitialState" ) || params.exists( "PositronProtonInitialState" ) )
  {
    // throw on unknown initial state !
    throw edm::Exception(edm::errors::Configuration,"Pythia8Interface")
      <<" UNKNOWN INITIAL STATE. \n The allowed initial states are: PP, PPbar, ElectronPositron \n";
  }
    
  if( params.exists( "SLHAFileForPythia8" ) ) {
    std::string slhafilenameshort = params.getParameter<std::string>("SLHAFileForPythia8");
    edm::FileInPath f1( slhafilenameshort );
    
    fMasterGen->settings.mode("SLHA:readFrom", 2);
    fMasterGen->settings.word("SLHA:file", f1.fullPath());    
    
    for ( ParameterCollector::const_iterator line = fParameters.begin();
          line != fParameters.end(); ++line ) {
      if (line->find("SLHA:file") != std::string::npos)
        throw cms::Exception("PythiaError") << "Attempted to set SLHA file name twice, "
        << "using Pythia8 card SLHA:file and Pythia8Interface card SLHAFileForPythia8"
        << std::endl;
     }  
  }
  else if( params.exists( "SLHATableForPythia8" ) ) {
    std::string slhatable = params.getParameter<std::string>("SLHATableForPythia8");
        
    char tempslhaname[] = "pythia8SLHAtableXXXXXX";
    int fd = mkstemp(tempslhaname);
    write(fd,slhatable.c_str(),slhatable.size());
    close(fd);
    
    slhafile_ = tempslhaname;
    
    fMasterGen->settings.mode("SLHA:readFrom", 2);
    fMasterGen->settings.word("SLHA:file", slhafile_);    
    
    for ( ParameterCollector::const_iterator line = fParameters.begin();
          line != fParameters.end(); ++line ) {
      if (line->find("SLHA:file") != std::string::npos)
        throw cms::Exception("PythiaError") << "Attempted to set SLHA file name twice, "
        << "using Pythia8 card SLHA:file and Pythia8Interface card SLHATableForPythia8"
        << std::endl;
     }  
  }
  
  //add settings for resonance decay filter
  fMasterGen->settings.addFlag("ResonanceDecayFilter:filter",false);
  fMasterGen->settings.addFlag("ResonanceDecayFilter:exclusive",false);
  fMasterGen->settings.addFlag("ResonanceDecayFilter:eMuAsEquivalent",false);
  fMasterGen->settings.addFlag("ResonanceDecayFilter:eMuTauAsEquivalent",false);
  fMasterGen->settings.addFlag("ResonanceDecayFilter:allNuAsEquivalent",false);
  fMasterGen->settings.addMVec("ResonanceDecayFilter:mothers",std::vector<int>(),false,false,0,0);
  fMasterGen->settings.addMVec("ResonanceDecayFilter:daughters",std::vector<int>(),false,false,0,0);

  // Reweight user hook
  //
  if( params.exists( "reweightGen" ) )
    fReweightUserHook = new PtHatReweightUserHook();
  if( params.exists( "reweightGenRap" ) )
  {
    edm::LogInfo("Pythia8Interface") << "Start setup for reweightGenRap";
    edm::ParameterSet rgrParams =
      params.getParameter<edm::ParameterSet>("reweightGenRap");
    fReweightRapUserHook =
      new RapReweightUserHook(rgrParams.getParameter<std::string>("yLabSigmaFunc"),
                              rgrParams.getParameter<double>("yLabPower"),
                              rgrParams.getParameter<std::string>("yCMSigmaFunc"),
                              rgrParams.getParameter<double>("yCMPower"),
                              rgrParams.getParameter<double>("pTHatMin"),
                              rgrParams.getParameter<double>("pTHatMax"));
    edm::LogInfo("Pythia8Interface") << "End setup for reweightGenRap";
  }
  if( params.exists( "reweightGenPtHatRap" ) )
  {
    edm::LogInfo("Pythia8Interface") << "Start setup for reweightGenPtHatRap";
    edm::ParameterSet rgrParams =
      params.getParameter<edm::ParameterSet>("reweightGenPtHatRap");
    fReweightPtHatRapUserHook =
      new PtHatRapReweightUserHook(rgrParams.getParameter<std::string>("yLabSigmaFunc"),
                                   rgrParams.getParameter<double>("yLabPower"),
                                   rgrParams.getParameter<std::string>("yCMSigmaFunc"),
                                   rgrParams.getParameter<double>("yCMPower"),
                                   rgrParams.getParameter<double>("pTHatMin"),
                                   rgrParams.getParameter<double>("pTHatMax"));
    edm::LogInfo("Pythia8Interface") << "End setup for reweightGenPtHatRap";
  }

  if( params.exists( "useUserHook" ) )
    throw edm::Exception(edm::errors::Configuration,"Pythia8Interface")
      <<" Obsolete parameter: useUserHook \n Please use the actual one instead \n";

  // PS matching prototype
  //
  if ( params.exists("jetMatching") )
  {
    edm::ParameterSet jmParams =
      params.getUntrackedParameter<edm::ParameterSet>("jetMatching");
      std::string scheme = jmParams.getParameter<std::string>("scheme");
      if ( scheme == "Madgraph" || scheme == "MadgraphFastJet" )
      {
         fJetMatchingHook = new JetMatchingHook( jmParams, &fMasterGen->info );
      }
  }

  // Pythia8Interface emission veto
  //
  if ( params.exists("emissionVeto1") )
  {
    EV1_nFinal = -1;
    if(params.exists("EV1_nFinal")) EV1_nFinal = params.getParameter<int>("EV1_nFinal");
    EV1_vetoOn = true;
    if(params.exists("EV1_vetoOn")) EV1_vetoOn = params.getParameter<bool>("EV1_vetoOn");
    EV1_maxVetoCount = 10;
    if(params.exists("EV1_maxVetoCount")) EV1_maxVetoCount = params.getParameter<int>("EV1_maxVetoCount");
    EV1_pThardMode = 1;
    if(params.exists("EV1_pThardMode")) EV1_pThardMode = params.getParameter<int>("EV1_pThardMode");
    EV1_pTempMode = 0;
    if(params.exists("EV1_pTempMode")) EV1_pTempMode = params.getParameter<int>("EV1_pTempMode");
    if(EV1_pTempMode > 2 || EV1_pTempMode < 0)
      throw edm::Exception(edm::errors::Configuration,"Pythia8Interface")
        <<" Wrong value for EV1_pTempMode code\n";
    EV1_emittedMode = 0;
    if(params.exists("EV1_emittedMode")) EV1_emittedMode = params.getParameter<int>("EV1_emittedMode");
    EV1_pTdefMode = 1;
    if(params.exists("EV1_pTdefMode")) EV1_pTdefMode = params.getParameter<int>("EV1_pTdefMode");
    EV1_MPIvetoOn = false;
    if(params.exists("EV1_MPIvetoOn")) EV1_MPIvetoOn = params.getParameter<bool>("EV1_MPIvetoOn");
    fEmissionVetoHook1 = new EmissionVetoHook1(EV1_nFinal, EV1_vetoOn,
                               EV1_maxVetoCount, EV1_pThardMode, EV1_pTempMode,
                               EV1_emittedMode, EV1_pTdefMode, EV1_MPIvetoOn, 0);
  }

  if(fReweightUserHook) NHooks++;
  if(fReweightRapUserHook) NHooks++;
  if(fReweightPtHatRapUserHook) NHooks++;
  if(fJetMatchingHook) NHooks++;
  if(fEmissionVetoHook1) NHooks++;
  if(NHooks > 1)
    throw edm::Exception(edm::errors::Configuration,"Pythia8Interface")
      <<" Too many User Hooks. \n Please choose one from: reweightGen, reweightGenRap, reweightGenPtHatRap, jetMatching, emissionVeto1 \n";
  if(fReweightUserHook) fMultiUserHook->addHook(fReweightUserHook);
  if(fReweightRapUserHook) fMultiUserHook->addHook(fReweightRapUserHook);
  if(fReweightPtHatRapUserHook) fMultiUserHook->addHook(fReweightPtHatRapUserHook);
  if(fJetMatchingHook) fMultiUserHook->addHook(fJetMatchingHook);
  if(fEmissionVetoHook1) { 
    edm::LogInfo("Pythia8Interface") << "Turning on Emission Veto Hook 1 from CMSSW Pythia8Interface";
    fMultiUserHook->addHook(fEmissionVetoHook1);
  }

}

Pythia8Hadronizer::~Pythia8Hadronizer

(

)

Definition at line 345 of file Pythia8Hadronizer.cc.

References fEmissionVetoHook, fEmissionVetoHook1, fMultiUserHook, MatrixUtil::remove(), and slhafile_.

{
// do we need to delete UserHooks/JetMatchingHook here ???
  if(fEmissionVetoHook) {delete fEmissionVetoHook; fEmissionVetoHook=0;}
  if(fEmissionVetoHook1) {delete fEmissionVetoHook1; fEmissionVetoHook1=0;}
  if (fMultiUserHook) { 
    delete fMultiUserHook;
    fMultiUserHook = 0;
  }
  
  //clean up temp file
  if (!slhafile_.empty()) {
    std::remove(slhafile_.c_str());
  }
  
}

Member Function Documentation

const char* Pythia8Hadronizer::classname ( ) const

inlineoverridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 85 of file Pythia8Hadronizer.cc.

{ return "Pythia8Hadronizer"; }

virtual void Pythia8Hadronizer::doSetRandomEngine ( CLHEP::HepRandomEngine *  v )

inlineoverrideprivatevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 89 of file Pythia8Hadronizer.cc.

{ p8SetRandomEngine(v); }

virtual std::vector<std::string> const& Pythia8Hadronizer::doSharedResources ( ) const

inlineoverrideprivatevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 90 of file Pythia8Hadronizer.cc.

{ return p8SharedResources; }

void Pythia8Hadronizer::finalizeEvent ( )

overridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 697 of file Pythia8Hadronizer.cc.

References gen::Py8InterfaceBase::ascii_io, gather_cfg::cout, DJR, gen::BaseHadronizer::event(), gen::BaseHadronizer::eventInfo(), gen::Py8InterfaceBase::fMasterGen, gen::BaseHadronizer::lheEvent(), gen::Py8InterfaceBase::maxEventsToPrint, nME, nMEFiltered, gen::Py8InterfaceBase::pythiaHepMCVerbosity, gen::Py8InterfaceBase::pythiaHepMCVerbosityParticles, and gen::Py8InterfaceBase::pythiaPylistVerbosity.

{
  bool lhe = lheEvent() != 0;

  // now create the GenEventInfo product from the GenEvent and fill
  // the missing pieces
  eventInfo().reset( new GenEventInfoProduct( event().get() ) );

  // in pythia pthat is used to subdivide samples into different bins
  // in LHE mode the binning is done by the external ME generator
  // which is likely not pthat, so only filling it for Py6 internal mode
  if (!lhe) {
    eventInfo()->setBinningValues(std::vector<double>(1, fMasterGen->info.pTHat()));
  }
  
  eventInfo()->setDJR(DJR);
  eventInfo()->setNMEPartons(nME);
  eventInfo()->setNMEPartonsFiltered(nMEFiltered);

  //******** Verbosity ********

  if (maxEventsToPrint > 0 &&
      (pythiaPylistVerbosity || pythiaHepMCVerbosity ||
                                pythiaHepMCVerbosityParticles) ) {
    maxEventsToPrint--;
    if (pythiaPylistVerbosity) {
      fMasterGen->info.list(std::cout); 
      fMasterGen->event.list(std::cout);
    } 

    if (pythiaHepMCVerbosity) {
      std::cout << "Event process = "
                << fMasterGen->info.code() << "\n"
                << "----------------------" << std::endl;
      event()->print();
    }
    if (pythiaHepMCVerbosityParticles) {
      std::cout << "Event process = "
                << fMasterGen->info.code() << "\n"
                << "----------------------" << std::endl;
      ascii_io->write_event(event().get());
    }
  }
}

bool Pythia8Hadronizer::generatePartonsAndHadronize ( )

overridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 567 of file Pythia8Hadronizer.cc.

References gen::BaseHadronizer::event(), gen::Py8InterfaceBase::evtgenDecays, gen::Py8InterfaceBase::fMasterGen, and gen::Py8InterfaceBase::toHepMC.

{

  if (!fMasterGen->next()) return false;

  if (evtgenDecays) evtgenDecays->decay();

  event().reset(new HepMC::GenEvent);
  return toHepMC.fill_next_event( *(fMasterGen.get()), event().get());

}

bool Pythia8Hadronizer::hadronize

(

)

Definition at line 580 of file Pythia8Hadronizer.cc.

References funct::abs(), JetMatchingHook::beforeHadronization(), lhef::LHEEvent::count(), DJR, gen::BaseHadronizer::event(), gen::Py8InterfaceBase::evtgenDecays, fEmissionVetoHook, fJetMatchingHook, fJetMatchingPy8InternalHook, gen::Py8InterfaceBase::fMasterGen, fMergingHook, lhef::LHERunInfo::kAccepted, lhef::LHERunInfo::kSelected, lhaUP, gen::BaseHadronizer::lheEvent(), LHEInputFileName, min(), nFSRveto, nISRveto, nME, nMEFiltered, JetMatchingHook::resetMatchingStatus(), AlCaHLTBitMon_QueryRunRegistry::string, and gen::Py8InterfaceBase::toHepMC.

{
  DJR.resize(0);
  nME = -1;
  nMEFiltered = -1;
  if(LHEInputFileName == std::string()) lhaUP->loadEvent(lheEvent());

  if ( fJetMatchingHook ) 
  {
    fJetMatchingHook->resetMatchingStatus(); 
    fJetMatchingHook->beforeHadronization( lheEvent() );
  }

  bool py8next = fMasterGen->next();

  double mergeweight = fMasterGen.get()->info.mergingWeightNLO();
  if (fMergingHook) {
    mergeweight *= fMergingHook->getNormFactor();
  }
  
  
  //protect against 0-weight from ckkw or similar
  if (!py8next || std::abs(mergeweight)==0.)
  {
    lheEvent()->count( lhef::LHERunInfo::kSelected, 1.0, mergeweight );
    event().reset();
    return false;
  }
  
  if (fJetMatchingPy8InternalHook) {
    const std::vector<double> djrmatch = fJetMatchingPy8InternalHook->GetDJR();
    //cap size of djr vector to save storage space (keep only up to first 6 elements)
    unsigned int ndjr = std::min(djrmatch.size(), std::vector<double>::size_type(6));
    for (unsigned int idjr=0; idjr<ndjr; ++idjr) {
      DJR.push_back(djrmatch[idjr]);
    }
    
    nME=fJetMatchingPy8InternalHook->nMEpartons().first;
    nMEFiltered=fJetMatchingPy8InternalHook->nMEpartons().second;
  }
  
  // update LHE matching statistics
  //
  lheEvent()->count( lhef::LHERunInfo::kAccepted, 1.0, mergeweight );

  if (evtgenDecays) evtgenDecays->decay();

  event().reset(new HepMC::GenEvent);
  bool py8hepmc =  toHepMC.fill_next_event( *(fMasterGen.get()), event().get());
  if (!py8hepmc) {
    return false;
  }
  
  //add ckkw/umeps/unlops merging weight
  if (mergeweight!=1.) {
    event()->weights()[0] *= mergeweight;
  }
  
  if (fEmissionVetoHook) {
    nISRveto += fEmissionVetoHook->getNISRveto();
    nFSRveto += fEmissionVetoHook->getNFSRveto();  
  }

  return true;

}

bool Pythia8Hadronizer::initializeForExternalPartons

(

)

Definition at line 433 of file Pythia8Hadronizer.cc.

References MultiUserHook::addHook(), edm::errors::Configuration, gen::Py8InterfaceBase::evtgenDecays, gen::Py8InterfaceBase::evtgenDecFile, gen::Py8InterfaceBase::evtgenPdlFile, gen::Py8InterfaceBase::evtgenUserFiles, Exception, gen::Py8InterfaceBase::fDecayer, fEmissionVetoHook, fEmissionVetoHook1, fJetMatchingHook, fJetMatchingPy8InternalHook, gen::Py8InterfaceBase::fMasterGen, fMergingHook, fMultiUserHook, fResonanceDecayFilterHook, i, JetMatchingHook::init(), lhaUP, LHEInputFileName, gen::BaseHadronizer::lheRunInfo(), MultiUserHook::nHooks(), gen::Py8InterfaceBase::pythiaPylistVerbosity, ntuplemaker::status, AlCaHLTBitMon_QueryRunRegistry::string, and gen::Py8InterfaceBase::useEvtGen.

{

  edm::LogInfo("Pythia8Interface") << "Initializing for external partons";

  bool status = false, status1 = false;
  
  if((fMasterGen->settings.mode("POWHEG:veto") > 0 || fMasterGen->settings.mode("POWHEG:MPIveto") > 0) && !fEmissionVetoHook) {

    if(fJetMatchingHook || fEmissionVetoHook1)
      throw edm::Exception(edm::errors::Configuration,"Pythia8Interface")
      <<" Attempt to turn on PowhegHooks by pythia8 settings but there are incompatible hooks on \n Incompatible are : jetMatching, emissionVeto1 \n";

    fEmissionVetoHook = new PowhegHooks();

    edm::LogInfo("Pythia8Interface") << "Turning on Emission Veto Hook from pythia8 code";
    fMultiUserHook->addHook(fEmissionVetoHook);

  }

  //adapted from main89.cc in pythia8 examples
  bool internalMatching = fMasterGen->settings.flag("JetMatching:merge");
  bool internalMerging = !(fMasterGen->settings.word("Merging:Process").compare("void")==0);
  
  if (internalMatching && internalMerging) {
    throw edm::Exception(edm::errors::Configuration,"Pythia8Interface")
      <<" Only one jet matching/merging scheme can be used at a time. \n";
  }
  
  if (internalMatching && !fJetMatchingPy8InternalHook) {
    fJetMatchingPy8InternalHook = new Pythia8::JetMatchingMadgraph;
    fMultiUserHook->addHook(fJetMatchingPy8InternalHook);
  }
  
  if (internalMerging && !fMergingHook) {
    int scheme = ( fMasterGen->settings.flag("Merging:doUMEPSTree")
                || fMasterGen->settings.flag("Merging:doUMEPSSubt")) ?
                1 :
                 ( ( fMasterGen->settings.flag("Merging:doUNLOPSTree")
                || fMasterGen->settings.flag("Merging:doUNLOPSSubt")
                || fMasterGen->settings.flag("Merging:doUNLOPSLoop")
                || fMasterGen->settings.flag("Merging:doUNLOPSSubtNLO")) ?
                2 :
                0 );
    fMergingHook = new Pythia8::amcnlo_unitarised_interface(scheme);
    fMultiUserHook->addHook(fMergingHook);
  }
  
  bool resonanceDecayFilter = fMasterGen->settings.flag("ResonanceDecayFilter:filter");
  if (resonanceDecayFilter && !fResonanceDecayFilterHook) {
    fResonanceDecayFilterHook = new ResonanceDecayFilterHook;
    fMultiUserHook->addHook(fResonanceDecayFilterHook);
  }
  
  if (fMultiUserHook->nHooks()>0) {
    fMasterGen->setUserHooksPtr(fMultiUserHook);
  }  
  
  if(LHEInputFileName != std::string()) {

    edm::LogInfo("Pythia8Interface") << "Initialize direct pythia8 reading from LHE file "
                                     << LHEInputFileName;
    edm::LogInfo("Pythia8Interface") << "Some LHE information can be not stored";
    fMasterGen->settings.mode("Beams:frameType", 4);
    fMasterGen->settings.word("Beams:LHEF", LHEInputFileName);
    status = fMasterGen->init();

  } else {

    lhaUP.reset(new LHAupLesHouches());
    lhaUP->setScalesFromLHEF(fMasterGen->settings.flag("Beams:setProductionScalesFromLHEF"));
    lhaUP->loadRunInfo(lheRunInfo());
    
    if ( fJetMatchingHook )
    {
       fJetMatchingHook->init ( lheRunInfo() );
    }
    
    fMasterGen->settings.mode("Beams:frameType", 5);
    fMasterGen->setLHAupPtr(lhaUP.get());
    edm::LogInfo("Pythia8Interface") << "Initializing MasterGen";
    status = fMasterGen->init();
  }
  
  if ( pythiaPylistVerbosity > 10 )
  {
    if ( pythiaPylistVerbosity == 11 || pythiaPylistVerbosity == 13 )
           fMasterGen->settings.listAll();
    if ( pythiaPylistVerbosity == 12 || pythiaPylistVerbosity == 13 )
           fMasterGen->particleData.listAll();
  }

  // init decayer
  fDecayer->settings.flag("ProcessLevel:all", false ); // trick
  fDecayer->settings.flag("ProcessLevel:resonanceDecays", true );
  edm::LogInfo("Pythia8Interface") << "Initializing Decayer";
  status1 = fDecayer->init();

  if (useEvtGen) {
    edm::LogInfo("Pythia8Interface") << "Creating and initializing pythia8 EvtGen plugin";

    std::string evtgenpath(getenv("EVTGENDATA"));
    evtgenDecays = new EvtGenDecays(fMasterGen.get(), evtgenDecFile.c_str(), evtgenPdlFile.c_str());

    for (unsigned int i=0; i<evtgenUserFiles.size(); i++) {
      edm::FileInPath evtgenUserFile(evtgenUserFiles.at(i));
      evtgenDecays->readDecayFile(evtgenUserFile.fullPath().c_str());
    }

  }

  return (status&&status1);
}

bool Pythia8Hadronizer::initializeForInternalPartons ( )

overridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 362 of file Pythia8Hadronizer.cc.

References MultiUserHook::addHook(), comEnergy, edm::errors::Configuration, ElectronPositron, gen::Py8InterfaceBase::evtgenDecays, gen::Py8InterfaceBase::evtgenDecFile, gen::Py8InterfaceBase::evtgenPdlFile, gen::Py8InterfaceBase::evtgenUserFiles, Exception, gen::Py8InterfaceBase::fDecayer, fInitialState, gen::Py8InterfaceBase::fMasterGen, fMultiUserHook, fResonanceDecayFilterHook, i, MultiUserHook::nHooks(), PP, PPbar, gen::Py8InterfaceBase::pythiaPylistVerbosity, ntuplemaker::status, and gen::Py8InterfaceBase::useEvtGen.

{
  
  bool status = false, status1 = false;
  
  if ( fInitialState == PP ) // default
  {
    fMasterGen->settings.mode("Beams:idA", 2212);
    fMasterGen->settings.mode("Beams:idB", 2212);
  }
  else if ( fInitialState == PPbar )
  {
    fMasterGen->settings.mode("Beams:idA", 2212);
    fMasterGen->settings.mode("Beams:idB", -2212);
  }
  else if ( fInitialState == ElectronPositron )
  {
    fMasterGen->settings.mode("Beams:idA", 11);
    fMasterGen->settings.mode("Beams:idB", -11);
  }    
  else 
  {
    // throw on unknown initial state !
    throw edm::Exception(edm::errors::Configuration,"Pythia8Interface")
      <<" UNKNOWN INITIAL STATE. \n The allowed initial states are: PP, PPbar, ElectronPositron \n";
  }
  
  bool resonanceDecayFilter = fMasterGen->settings.flag("ResonanceDecayFilter:filter");
  if (resonanceDecayFilter && !fResonanceDecayFilterHook) {
    fResonanceDecayFilterHook = new ResonanceDecayFilterHook;
    fMultiUserHook->addHook(fResonanceDecayFilterHook);
  }
  
  if (fMultiUserHook->nHooks()>0) {
    fMasterGen->setUserHooksPtr(fMultiUserHook);
  }

  fMasterGen->settings.parm("Beams:eCM", comEnergy);
  edm::LogInfo("Pythia8Interface") << "Initializing MasterGen";
  status = fMasterGen->init();

  if ( pythiaPylistVerbosity > 10 )
  {
    if ( pythiaPylistVerbosity == 11 || pythiaPylistVerbosity == 13 )
           fMasterGen->settings.listAll();
    if ( pythiaPylistVerbosity == 12 || pythiaPylistVerbosity == 13 )
           fMasterGen->particleData.listAll();
  }

  // init decayer
  fDecayer->settings.flag("ProcessLevel:all", false ); // trick
  fDecayer->settings.flag("ProcessLevel:resonanceDecays", true );
  edm::LogInfo("Pythia8Interface") << "Initializing Decayer";
  status1 = fDecayer->init();

  if (useEvtGen) {
    edm::LogInfo("Pythia8Interface") << "Creating and initializing pythia8 EvtGen plugin";

    evtgenDecays = new EvtGenDecays(fMasterGen.get(), evtgenDecFile.c_str(), evtgenPdlFile.c_str());

    for (unsigned int i=0; i<evtgenUserFiles.size(); i++) {
      edm::FileInPath evtgenUserFile(evtgenUserFiles.at(i)); 
      evtgenDecays->readDecayFile(evtgenUserFile.fullPath().c_str());
    }

  }

  return (status&&status1);
}

bool Pythia8Hadronizer::residualDecay ( )

virtual

Definition at line 648 of file Pythia8Hadronizer.cc.

References gen::BaseHadronizer::event(), gen::Py8InterfaceBase::fDecayer, gen::Py8InterfaceBase::fMasterGen, GenParticle::GenParticle, query::result, and gen::Py8InterfaceBase::toHepMC.

{

  Event* pythiaEvent = &(fMasterGen->event);

  int NPartsBeforeDecays = pythiaEvent->size();
  int NPartsAfterDecays = event().get()->particles_size();

  if(NPartsAfterDecays == NPartsBeforeDecays) return true;

  bool result = true;

  for ( int ipart=NPartsAfterDecays; ipart>NPartsBeforeDecays; ipart-- )
  {

    HepMC::GenParticle* part = event().get()->barcode_to_particle( ipart );

    if ( part->status() == 1 && (fDecayer->particleData).canDecay(part->pdg_id()) )
    {
      fDecayer->event.reset();
      Particle py8part(  part->pdg_id(), 93, 0, 0, 0, 0, 0, 0,
                         part->momentum().x(),
                         part->momentum().y(),
                         part->momentum().z(),
                         part->momentum().t(),
                         part->generated_mass() );
      HepMC::GenVertex* ProdVtx = part->production_vertex();
      py8part.vProd( ProdVtx->position().x(), ProdVtx->position().y(),
                     ProdVtx->position().z(), ProdVtx->position().t() );
      py8part.tau( (fDecayer->particleData).tau0( part->pdg_id() ) );
      fDecayer->event.append( py8part );
      int nentries = fDecayer->event.size();
      if ( !fDecayer->event[nentries-1].mayDecay() ) continue;
      fDecayer->next();
      int nentries1 = fDecayer->event.size();
      if ( nentries1 <= nentries ) continue; //same number of particles, no decays...

      part->set_status(2);

      result = toHepMC.fill_next_event( *(fDecayer.get()), event().get(), -1, true, part);

    }
  }

  return result;

}

void Pythia8Hadronizer::statistics ( )

overridevirtual

Reimplemented from gen::Py8InterfaceBase.

Definition at line 548 of file Pythia8Hadronizer.cc.

References fEmissionVetoHook, gen::Py8InterfaceBase::fMasterGen, nFSRveto, nISRveto, gen::BaseHadronizer::runInfo(), and GenRunInfoProduct::setInternalXSec().

{
  fMasterGen->stat();

  if(fEmissionVetoHook) {
    edm::LogPrint("Pythia8Interface") << "\n"
      << "Number of ISR vetoed = " << nISRveto;
    edm::LogPrint("Pythia8Interface")
      << "Number of FSR vetoed = " << nFSRveto;
  }

  double xsec = fMasterGen->info.sigmaGen(); // cross section in mb
  xsec *= 1.0e9; // translate to pb (CMS/Gen "convention" as of May 2009)
  double err  = fMasterGen->info.sigmaErr(); // cross section err in mb
  err  *= 1.0e9; // translate to pb (CMS/Gen "convention" as of May 2009)
  runInfo().setInternalXSec(GenRunInfoProduct::XSec(xsec,err));
}

Member Data Documentation

double Pythia8Hadronizer::comEnergy

private

Center-of-Mass energy.

Definition at line 93 of file Pythia8Hadronizer.cc.

Referenced by initializeForInternalPartons().

vector<float> Pythia8Hadronizer::DJR

private

Definition at line 140 of file Pythia8Hadronizer.cc.

Referenced by finalizeEvent(), and hadronize().

int Pythia8Hadronizer::EV1_emittedMode

private

Definition at line 132 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

int Pythia8Hadronizer::EV1_maxVetoCount

private

Definition at line 129 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

bool Pythia8Hadronizer::EV1_MPIvetoOn

private

Definition at line 134 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

int Pythia8Hadronizer::EV1_nFinal

private

Definition at line 127 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

int Pythia8Hadronizer::EV1_pTdefMode

private

Definition at line 133 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

int Pythia8Hadronizer::EV1_pTempMode

private

Definition at line 131 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

int Pythia8Hadronizer::EV1_pThardMode

private

Definition at line 130 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

bool Pythia8Hadronizer::EV1_vetoOn

private

Definition at line 128 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

double Pythia8Hadronizer::fBeam1PZ

private

Definition at line 101 of file Pythia8Hadronizer.cc.

double Pythia8Hadronizer::fBeam2PZ

private

Definition at line 102 of file Pythia8Hadronizer.cc.

PowhegHooks* Pythia8Hadronizer::fEmissionVetoHook

private

Definition at line 121 of file Pythia8Hadronizer.cc.

Referenced by hadronize(), initializeForExternalPartons(), statistics(), and ~Pythia8Hadronizer().

EmissionVetoHook1* Pythia8Hadronizer::fEmissionVetoHook1

private

Definition at line 122 of file Pythia8Hadronizer.cc.

Referenced by initializeForExternalPartons(), Pythia8Hadronizer(), and ~Pythia8Hadronizer().

int Pythia8Hadronizer::fInitialState

private

Definition at line 99 of file Pythia8Hadronizer.cc.

Referenced by initializeForInternalPartons(), and Pythia8Hadronizer().

JetMatchingHook* Pythia8Hadronizer::fJetMatchingHook

private

Definition at line 115 of file Pythia8Hadronizer.cc.

Referenced by hadronize(), initializeForExternalPartons(), and Pythia8Hadronizer().

Pythia8::JetMatchingMadgraph* Pythia8Hadronizer::fJetMatchingPy8InternalHook

private

Definition at line 116 of file Pythia8Hadronizer.cc.

Referenced by hadronize(), and initializeForExternalPartons().

Pythia8::amcnlo_unitarised_interface* Pythia8Hadronizer::fMergingHook

private

Definition at line 117 of file Pythia8Hadronizer.cc.

Referenced by hadronize(), and initializeForExternalPartons().

MultiUserHook* Pythia8Hadronizer::fMultiUserHook

private

Definition at line 105 of file Pythia8Hadronizer.cc.

Referenced by initializeForExternalPartons(), initializeForInternalPartons(), Pythia8Hadronizer(), and ~Pythia8Hadronizer().

ResonanceDecayFilterHook* Pythia8Hadronizer::fResonanceDecayFilterHook

private

Definition at line 125 of file Pythia8Hadronizer.cc.

Referenced by initializeForExternalPartons(), and initializeForInternalPartons().

UserHooks* Pythia8Hadronizer::fReweightPtHatRapUserHook

private

Definition at line 111 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

UserHooks* Pythia8Hadronizer::fReweightRapUserHook

private

Definition at line 110 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

UserHooks* Pythia8Hadronizer::fReweightUserHook

private

Definition at line 109 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

std::auto_ptr<LHAupLesHouches> Pythia8Hadronizer::lhaUP

private

Definition at line 96 of file Pythia8Hadronizer.cc.

Referenced by hadronize(), and initializeForExternalPartons().

std::string Pythia8Hadronizer::LHEInputFileName

private

Definition at line 95 of file Pythia8Hadronizer.cc.

Referenced by hadronize(), and initializeForExternalPartons().

int Pythia8Hadronizer::nFSRveto

private

Definition at line 145 of file Pythia8Hadronizer.cc.

Referenced by hadronize(), and statistics().

int Pythia8Hadronizer::NHooks

private

Definition at line 147 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

int Pythia8Hadronizer::nISRveto

private

Definition at line 144 of file Pythia8Hadronizer.cc.

Referenced by hadronize(), and statistics().

int Pythia8Hadronizer::nME

private

Definition at line 141 of file Pythia8Hadronizer.cc.

Referenced by finalizeEvent(), and hadronize().

int Pythia8Hadronizer::nMEFiltered

private

Definition at line 142 of file Pythia8Hadronizer.cc.

Referenced by finalizeEvent(), and hadronize().

const std::vector< std::string > Pythia8Hadronizer::p8SharedResources = { edm::SharedResourceNames::kPythia8 }

staticprivate

Definition at line 136 of file Pythia8Hadronizer.cc.

std::string Pythia8Hadronizer::slhafile_

private

Definition at line 138 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer(), and ~Pythia8Hadronizer().