Inheritance diagram for Pythia8Hadronizer:

Public Member Functions
const char *	classname () const

void	finalizeEvent ()

bool	generatePartonsAndHadronize ()

bool	hadronize ()

bool	initializeForExternalPartons ()

bool	initializeForInternalPartons ()

	Pythia8Hadronizer (const edm::ParameterSet &params)

virtual bool	residualDecay ()

void	statistics ()

	~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)

	~BaseHadronizer ()

Public Member Functions inherited from gen::Py8InterfaceBase
bool	decay ()

bool	declareSpecialSettings (const std::vector< std::string > &)

bool	declareStableParticles (const std::vector< int > &)

	Py8InterfaceBase (edm::ParameterSet const &ps)

bool	readSettings (int)

	~Py8InterfaceBase ()

Private Types
enum	{ PP, PPbar, ElectronPositron }

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

UserHooks *	fReweightPtHatRapUserHook

UserHooks *	fReweightRapUserHook

UserHooks *	fReweightUserHook

std::auto_ptr< LHAupLesHouches >	lhaUP

string	LHEInputFileName

int	nFSRveto

int	NHooks

int	nISRveto

int	nME

int	nMEFiltered

std::string	slhafile_

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
std::auto_ptr< Pythia8::Pythia >	fDecayer

std::auto_ptr< Pythia8::Pythia >	fMasterGen

ParameterCollector	fParameters

unsigned int	maxEventsToPrint

bool	pythiaHepMCVerbosity

unsigned int	pythiaPylistVerbosity

HepMC::Pythia8ToHepMC	toHepMC

Detailed Description

Definition at line 49 of file Pythia8Hadronizer.cc.

Member Enumeration Documentation

anonymous enum

private

Enumerator
PP
PPbar
ElectronPositron

Definition at line 78 of file Pythia8Hadronizer.cc.

78 { PP, PPbar, ElectronPositron };

Pythia8Hadronizer::ElectronPositron

Definition: Pythia8Hadronizer.cc:78

Pythia8Hadronizer::PP

Definition: Pythia8Hadronizer.cc:78

Pythia8Hadronizer::PPbar

Definition: Pythia8Hadronizer.cc:78

Constructor & Destructor Documentation

Pythia8Hadronizer::Pythia8Hadronizer ( const edm::ParameterSet & params )

Definition at line 123 of file Pythia8Hadronizer.cc.

References 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, edm::hlt::Exception, edm::ParameterSet::exists(), python.connectstrParser::f1, fEmissionVetoHook1, fInitialState, fJetMatchingHook, gen::Py8InterfaceBase::fMasterGen, gen::Py8InterfaceBase::fParameters, fReweightPtHatRapUserHook, fReweightRapUserHook, fReweightUserHook, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), geometryCSVtoXML::line, NHooks, PP, PPbar, and slhafile_.

                                                                   :
   BaseHadronizer(params), Py8InterfaceBase(params),
   comEnergy(params.getParameter<double>("comEnergy")),
   LHEInputFileName(params.getUntrackedParameter<string>("LHEInputFileName","")),
   fInitialState(PP),
   fReweightUserHook(0),fReweightRapUserHook(0),fReweightPtHatRapUserHook(0),
   fJetMatchingHook(0),fJetMatchingPy8InternalHook(0), fMergingHook(0),
   fEmissionVetoHook(0), fEmissionVetoHook1(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<string>("SLHAFileForPythia8");
     edm::FileInPath f1( slhafilenameshort );
     slhafile_ = f1.fullPath();
     
     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 SLHAFileForPythia8"
         << std::endl;
      }  
   }
 
   // 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) fMasterGen->setUserHooksPtr(fReweightUserHook);
   if(fReweightRapUserHook) fMasterGen->setUserHooksPtr(fReweightRapUserHook);
   if(fReweightPtHatRapUserHook) fMasterGen->setUserHooksPtr(fReweightPtHatRapUserHook);
   if(fJetMatchingHook) fMasterGen->setUserHooksPtr(fJetMatchingHook);
   if(fEmissionVetoHook1) { 
     edm::LogInfo("Pythia8Interface") << "Turning on Emission Veto Hook 1 from CMSSW Pythia8Interface";
     fMasterGen->setUserHooksPtr(fEmissionVetoHook1);
   }
 
 }

Pythia8Hadronizer::~Pythia8Hadronizer ( )

Definition at line 286 of file Pythia8Hadronizer.cc.

References fEmissionVetoHook, and fEmissionVetoHook1.

 {
 // do we need to delete UserHooks/JetMatchingHook here ???
   if(fEmissionVetoHook) {delete fEmissionVetoHook; fEmissionVetoHook=0;}
   if(fEmissionVetoHook1) {delete fEmissionVetoHook1; fEmissionVetoHook1=0;}
 }

Member Function Documentation

const char* Pythia8Hadronizer::classname ( ) const

inlinevirtual

Implements gen::Py8InterfaceBase.

Definition at line 68 of file Pythia8Hadronizer.cc.

68 { return "Pythia8Hadronizer"; }

void Pythia8Hadronizer::finalizeEvent ( )

virtual

Implements gen::Py8InterfaceBase.

Definition at line 614 of file Pythia8Hadronizer.cc.

References gather_cfg::cout, DJR, gen::BaseHadronizer::event(), gen::BaseHadronizer::eventInfo(), gen::Py8InterfaceBase::fMasterGen, gen::BaseHadronizer::lheEvent(), gen::Py8InterfaceBase::maxEventsToPrint, nME, nMEFiltered, gen::Py8InterfaceBase::pythiaHepMCVerbosity, 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)) {
     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();
     }
   }
 }

bool Pythia8Hadronizer::generatePartonsAndHadronize ( )

virtual

Implements gen::Py8InterfaceBase.

Definition at line 462 of file Pythia8Hadronizer.cc.

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

 {
 
   if (!fMasterGen->next()) return false;
 
   event().reset(new HepMC::GenEvent);
   return toHepMC.fill_next_event( *(fMasterGen.get()), event().get());
 
 }

bool Pythia8Hadronizer::hadronize ( )

Definition at line 473 of file Pythia8Hadronizer.cc.

References abs, JetMatchingHook::beforeHadronization(), lhef::LHEEvent::count(), DJR, gen::BaseHadronizer::event(), 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(), and gen::Py8InterfaceBase::toHepMC.

 {
   DJR.resize(0);
   nME = -1;
   nMEFiltered = -1;
   if(LHEInputFileName == 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 );
 
   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 350 of file Pythia8Hadronizer.cc.

References edm::errors::Configuration, edm::hlt::Exception, gen::Py8InterfaceBase::fDecayer, fEmissionVetoHook, fEmissionVetoHook1, fJetMatchingHook, fJetMatchingPy8InternalHook, gen::Py8InterfaceBase::fMasterGen, fMergingHook, JetMatchingHook::init(), lhaUP, LHEInputFileName, gen::BaseHadronizer::lheRunInfo(), gen::Py8InterfaceBase::pythiaPylistVerbosity, and ntuplemaker::status.

 {
 
   edm::LogInfo("Pythia8Interface") << "Initializing for external partons";
 
   bool status = true;
   
   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";
     fMasterGen->setUserHooksPtr(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;
     fMasterGen->setUserHooksPtr(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);
     fMasterGen->setUserHooksPtr(fMergingHook);
   }
   
   
   if(LHEInputFileName != string()) {
 
     edm::LogInfo("Pythia8Interface") << "Initialize direct pythia8 reading from LHE file "
                                      << LHEInputFileName;
     edm::LogInfo("Pythia8Interface") << "Some LHE information can be not stored";
     //fMasterGen->init(LHEInputFileName);
     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->init(lhaUP.get());
     fMasterGen->settings.mode("Beams:frameType", 5);
     fMasterGen->setLHAupPtr(lhaUP.get());
     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->readString("ProcessLevel:all = off"); // trick
   //fDecayer->readString("ProcessLevel::resonanceDecays=on");
   fDecayer->settings.flag("ProcessLevel:all", false ); // trick
   fDecayer->settings.flag("ProcessLevel:resonanceDecays", true );
   status &= fDecayer->init();
 
   return status;
 }

bool Pythia8Hadronizer::initializeForInternalPartons ( )

virtual

Implements gen::Py8InterfaceBase.

Definition at line 293 of file Pythia8Hadronizer.cc.

References comEnergy, edm::errors::Configuration, ElectronPositron, edm::hlt::Exception, gen::Py8InterfaceBase::fDecayer, fInitialState, gen::Py8InterfaceBase::fMasterGen, PP, PPbar, gen::Py8InterfaceBase::pythiaPylistVerbosity, and ntuplemaker::status.

 {
   
   bool status = true;
   
   if ( fInitialState == PP ) // default
   {
     //fMasterGen->init(2212, 2212, comEnergy);
     fMasterGen->settings.mode("Beams:idA", 2212);
     fMasterGen->settings.mode("Beams:idB", 2212);
     fMasterGen->settings.parm("Beams:eCM", comEnergy);
     status &= fMasterGen->init();
   }
   else if ( fInitialState == PPbar )
   {
     //fMasterGen->init(2212, -2212, comEnergy);
     fMasterGen->settings.mode("Beams:idA", 2212);
     fMasterGen->settings.mode("Beams:idB", -2212);
     fMasterGen->settings.parm("Beams:eCM", comEnergy);
     status &= fMasterGen->init();
   }
   else if ( fInitialState == ElectronPositron )
   {
     //fMasterGen->init(11, -11, comEnergy);
     fMasterGen->settings.mode("Beams:idA", 11);
     fMasterGen->settings.mode("Beams:idB", -11);
     fMasterGen->settings.parm("Beams:eCM", comEnergy);
     status &= fMasterGen->init();
   }    
   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";
   }
 
   fMasterGen->settings.listChanged();
 
   if ( pythiaPylistVerbosity > 10 )
   {
     if ( pythiaPylistVerbosity == 11 || pythiaPylistVerbosity == 13 )
            fMasterGen->settings.listAll();
     if ( pythiaPylistVerbosity == 12 || pythiaPylistVerbosity == 13 )
            fMasterGen->particleData.listAll();
   }
 
   // init decayer
   //fDecayer->readString("ProcessLevel:all = off"); // trick
   //fDecayer->readString("ProcessLevel::resonanceDecays=on");
   fDecayer->settings.flag("ProcessLevel:all", false ); // trick
   fDecayer->settings.flag("ProcessLevel:resonanceDecays", true );
   status &= fDecayer->init();
 
   return status;
 }

bool Pythia8Hadronizer::residualDecay ( )

virtual

Definition at line 540 of file Pythia8Hadronizer.cc.

References gen::BaseHadronizer::event(), gen::Py8InterfaceBase::fDecayer, gen::Py8InterfaceBase::fMasterGen, and configurableAnalysis::GenParticle.

 {
 
   Event* pythiaEvent = &(fMasterGen->event);
 
   int NPartsBeforeDecays = pythiaEvent->size();
   int NPartsAfterDecays = event().get()->particles_size();
   int NewBarcode = NPartsAfterDecays;
 
   for ( int ipart=NPartsAfterDecays; ipart>NPartsBeforeDecays; ipart-- )
   {
 
     HepMC::GenParticle* part = event().get()->barcode_to_particle( ipart );
 
     if ( part->status() == 1 )
     {
       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);
 
       Particle& py8daughter = fDecayer->event[nentries]; // the 1st daughter
       HepMC::GenVertex* DecVtx = new HepMC::GenVertex( HepMC::FourVector(py8daughter.xProd(),
                                                        py8daughter.yProd(),
                                                        py8daughter.zProd(),
                                                        py8daughter.tProd()) );
 
       DecVtx->add_particle_in( part ); // this will cleanup end_vertex if exists, replace with the new one
                                        // I presume (vtx) barcode will be given automatically
 
       HepMC::FourVector pmom( py8daughter.px(), py8daughter.py(), py8daughter.pz(), py8daughter.e() );
 
       HepMC::GenParticle* daughter =
                         new HepMC::GenParticle( pmom, py8daughter.id(), 1 );
 
       NewBarcode++;
       daughter->suggest_barcode( NewBarcode );
       DecVtx->add_particle_out( daughter );
 
       for ( int ipart1=nentries+1; ipart1<nentries1; ipart1++ )
       {
         py8daughter = fDecayer->event[ipart1];
         HepMC::FourVector pmomN( py8daughter.px(), py8daughter.py(), py8daughter.pz(), py8daughter.e() );
         HepMC::GenParticle* daughterN =
                         new HepMC::GenParticle( pmomN, py8daughter.id(), 1 );
         NewBarcode++;
         daughterN->suggest_barcode( NewBarcode );
         DecVtx->add_particle_out( daughterN );
       }
 
       event().get()->add_vertex( DecVtx );
 
     }
  }
  return true;
 
 }

void Pythia8Hadronizer::statistics ( )

virtual

Reimplemented from gen::Py8InterfaceBase.

Definition at line 445 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)
   runInfo().setInternalXSec(xsec);
 }