#include <Pythia6Gun.h>

Inheritance diagram for gen::Pythia6Gun:

Public Member Functions
void	beginJob () override

void	beginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) override

void	beginRun (edm::Run const &, edm::EventSetup const &) override

void	endRun (edm::Run const &, edm::EventSetup const &) override

void	produce (edm::Event &, const edm::EventSetup &) override

	Pythia6Gun (const edm::ParameterSet &)

	~Pythia6Gun () override

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

	~EDProducer () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Protected Member Functions
HepMC::GenParticle *	addAntiParticle (int &, int &, double &, double &, double &)

void	attachPy6DecaysToGenEvent ()

virtual void	generateEvent (CLHEP::HepRandomEngine *)=0

void	loadEvent (edm::Event &)

Protected Member Functions inherited from edm::ProducerBase
ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Protected Attributes
HepMC::GenEvent *	fEvt

bool	fHepMCVerbosity

int	fMaxEventsToPrint

double	fMaxPhi

double	fMinPhi

std::vector< int >	fPartIDs

Pythia6Service *	fPy6Service

int	fPylistVerbosity

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Detailed Description

Definition at line 40 of file Pythia6Gun.h.

Constructor & Destructor Documentation

Pythia6Gun::Pythia6Gun ( const edm::ParameterSet & pset )

Definition at line 24 of file Pythia6Gun.cc.

References gen::call_pygive(), edm::errors::Configuration, Exception, fHepMCVerbosity, fMaxEventsToPrint, fMaxPhi, fMinPhi, fPylistVerbosity, edm::ParameterSet::getParameter(), and edm::ParameterSet::getUntrackedParameter().

     : fPy6Service(new Pythia6Service(pset)),
       fEvt(nullptr)
 // fPDGTable( new DefaultConfig::ParticleDataTable("PDG Table") )
 {
   ParameterSet pgun_params = pset.getParameter<ParameterSet>("PGunParameters");
 
   // although there's the method ParameterSet::empty(),
   // it looks like it's NOT even necessary to check if it is,
   // before trying to extract parameters - if it is empty,
   // the default values seem to be taken
   //
   fMinPhi = pgun_params.getParameter<double>("MinPhi");  // ,-3.14159265358979323846);
   fMaxPhi = pgun_params.getParameter<double>("MaxPhi");  // , 3.14159265358979323846);
 
   fHepMCVerbosity = pset.getUntrackedParameter<bool>("pythiaHepMCVerbosity", false);
   fPylistVerbosity = pset.getUntrackedParameter<int>("pythiaPylistVerbosity", 0);
   fMaxEventsToPrint = pset.getUntrackedParameter<int>("maxEventsToPrint", 0);
 
   // Turn off banner printout
   if (!call_pygive("MSTU(12)=12345")) {
     throw edm::Exception(edm::errors::Configuration, "PythiaError") << " pythia did not accept MSTU(12)=12345";
   }
 
   produces<HepMCProduct>("unsmeared");
 }

Pythia6Gun::~Pythia6Gun ( )

override

Definition at line 51 of file Pythia6Gun.cc.

References fPy6Service.

                         {
   if (fPy6Service)
     delete fPy6Service;
   //
   // note that GenEvent or any undelaying (GenVertex, GenParticle) do NOT
   // need to be cleaned, as it'll be done automatically by HepMCProduct
   //
 }

Member Function Documentation

HepMC::GenParticle * Pythia6Gun::addAntiParticle	(	int &	ip,
		int &	particleID,
		double &	ee,
		double &	eta,
		double &	phi
	)

protected

Definition at line 198 of file Pythia6Gun.cc.

References JetChargeProducer_cfi::exp, GenParticle::GenParticle, M_PI, EgammaObjectsElectrons_cfi::particleID, multPhiCorr_741_25nsDY_cfi::px, multPhiCorr_741_25nsDY_cfi::py, gen::py1ent_(), and gen::pycomp_().

Referenced by gen::Pythia6PartonEGun::generateEvent(), gen::Pythia6PartonPtGun::generateEvent(), gen::Pythia6PtGun::generateEvent(), and gen::Pythia6EGun::generateEvent().

                                                                                                             {
   if (ip < 2)
     return nullptr;
 
   // translate PDG to Py6
   int py6PID = HepPID::translatePDTtoPythia(particleID);
   // Check if particle is its own anti-particle.
   int pythiaCode = pycomp_(py6PID);  // this is py6 internal validity check, it takes Pythia6 pid
                                      // so actually I'll need to convert
   int has_antipart = pydat2.kchg[3 - 1][pythiaCode - 1];
   int particleID2 = has_antipart ? -1 * particleID : particleID;  // this is PDG, for HepMC::GenEvent
   int py6PID2 = has_antipart ? -1 * py6PID : py6PID;              // this py6 id, for py1ent
   double the = 2. * atan(exp(eta));
   phi = phi + M_PI;
   if (phi > 2. * M_PI) {
     phi = phi - 2. * M_PI;
   }
 
   // copy over mass of the previous one, because then py6 will pick it up
   pyjets.p[4][ip - 1] = pyjets.p[4][ip - 2];
 
   py1ent_(ip, py6PID2, ee, the, phi);
 
   double px = pyjets.p[0][ip - 1];  // pt*cos(phi) ;
   double py = pyjets.p[1][ip - 1];  // pt*sin(phi) ;
   double pz = pyjets.p[2][ip - 1];  // mom*cos(the) ;
   HepMC::FourVector ap(px, py, pz, ee);
   HepMC::GenParticle* APart = new HepMC::GenParticle(ap, particleID2, 1);
   APart->suggest_barcode(ip);
 
   return APart;
 }

void Pythia6Gun::attachPy6DecaysToGenEvent ( )

protected

Definition at line 94 of file Pythia6Gun.cc.

References fEvt, fPartIDs, GenParticle::GenParticle, and class-composition::parent.

Referenced by produce().

                                            {
   for (int iprt = fPartIDs.size(); iprt < pyjets.n; iprt++)  // the pointer is shifted by -1, c++ style
   {
     int parent = pyjets.k[2][iprt];
     if (parent != 0) {
       // pull up parent particle
       //
       HepMC::GenParticle* parentPart = fEvt->barcode_to_particle(parent);
       parentPart->set_status(2);  // reset status, to mark that it's decayed
 
       HepMC::GenVertex* DecVtx = new HepMC::GenVertex(
           HepMC::FourVector(pyjets.v[0][iprt], pyjets.v[1][iprt], pyjets.v[2][iprt], pyjets.v[3][iprt]));
       DecVtx->add_particle_in(parentPart);  // this will cleanup end_vertex if exists,
                                             // and replace with the new one
                                             // I presume barcode will be given automatically
 
       HepMC::FourVector pmom(pyjets.p[0][iprt], pyjets.p[1][iprt], pyjets.p[2][iprt], pyjets.p[3][iprt]);
 
       int dstatus = 0;
       if (pyjets.k[0][iprt] >= 1 && pyjets.k[0][iprt] <= 10) {
         dstatus = 1;
       } else if (pyjets.k[0][iprt] >= 11 && pyjets.k[0][iprt] <= 20) {
         dstatus = 2;
       } else if (pyjets.k[0][iprt] >= 21 && pyjets.k[0][iprt] <= 30) {
         dstatus = 3;
       } else if (pyjets.k[0][iprt] >= 31 && pyjets.k[0][iprt] <= 100) {
         dstatus = pyjets.k[0][iprt];
       }
       HepMC::GenParticle* daughter =
           new HepMC::GenParticle(pmom, HepPID::translatePythiatoPDT(pyjets.k[1][iprt]), dstatus);
       daughter->suggest_barcode(iprt + 1);
       DecVtx->add_particle_out(daughter);
       // give particle barcode as well !
 
       int iprt1;
       for (iprt1 = iprt + 1; iprt1 < pyjets.n; iprt1++)  // the pointer is shifted by -1, c++ style
       {
         if (pyjets.k[2][iprt1] != parent)
           break;  // another parent particle, break the loop
 
         HepMC::FourVector pmomN(pyjets.p[0][iprt1], pyjets.p[1][iprt1], pyjets.p[2][iprt1], pyjets.p[3][iprt1]);
 
         dstatus = 0;
         if (pyjets.k[0][iprt1] >= 1 && pyjets.k[0][iprt1] <= 10) {
           dstatus = 1;
         } else if (pyjets.k[0][iprt1] >= 11 && pyjets.k[0][iprt1] <= 20) {
           dstatus = 2;
         } else if (pyjets.k[0][iprt1] >= 21 && pyjets.k[0][iprt1] <= 30) {
           dstatus = 3;
         } else if (pyjets.k[0][iprt1] >= 31 && pyjets.k[0][iprt1] <= 100) {
           dstatus = pyjets.k[0][iprt1];
         }
         HepMC::GenParticle* daughterN =
             new HepMC::GenParticle(pmomN, HepPID::translatePythiatoPDT(pyjets.k[1][iprt1]), dstatus);
         daughterN->suggest_barcode(iprt1 + 1);
         DecVtx->add_particle_out(daughterN);
       }
 
       iprt = iprt1 - 1;  // reset counter such that it doesn't go over the same child more than once
                          // don't forget to offset back into c++ counting, as it's already +1 forward
 
       fEvt->add_vertex(DecVtx);
     }
   }
 
   return;
 }

void Pythia6Gun::beginJob ( void )

overridevirtual

Reimplemented from edm::EDProducer.

Definition at line 60 of file Pythia6Gun.cc.

                           {
   // es.getData( fPDGTable ) ;
   return;
 }

void Pythia6Gun::beginLuminosityBlock	(	edm::LuminosityBlock const &	lumi,
		edm::EventSetup const &
	)

overridevirtual

Reimplemented from edm::EDProducer.

Definition at line 70 of file Pythia6Gun.cc.

References gen::call_pygive(), fPy6Service, edm::LuminosityBlock::index(), gen::Pythia6Service::setCSAParams(), gen::Pythia6Service::setGeneralParams(), and gen::Pythia6Service::setSLHAParams().

                                                                                     {
   assert(fPy6Service);
 
   RandomEngineSentry<Pythia6Service> sentry(fPy6Service, lumi.index());
 
   Pythia6Service::InstanceWrapper guard(fPy6Service);  // grab Py6 instance
 
   fPy6Service->setGeneralParams();
   fPy6Service->setCSAParams();
   fPy6Service->setSLHAParams();
 
   call_pygive("MSTU(10)=1");
 
   call_pyinit("NONE", "", "", 0.0);
 }

void Pythia6Gun::beginRun	(	edm::Run const &	,
		edm::EventSetup const &	es
	)

overridevirtual

Reimplemented from edm::EDProducer.

Definition at line 65 of file Pythia6Gun.cc.

References gather_cfg::cout.

                                                           {
   std::cout << " FYI: MSTU(10)=1 is ENFORCED in Py6-PGuns, for technical reasons" << std::endl;
   return;
 }

void Pythia6Gun::endRun	(	edm::Run const &	,
		edm::EventSetup const &	es
	)

overridevirtual

Reimplemented from edm::EDProducer.

Definition at line 86 of file Pythia6Gun.cc.

                                                         {
   // here put in GenRunInfoProduct
 
   call_pystat(1);
 
   return;
 }

virtual void gen::Pythia6Gun::generateEvent ( CLHEP::HepRandomEngine * )

protectedpure virtual

Implemented in gen::Pythia6PtYDistGun, gen::Pythia6EGun, gen::Pythia6JetGun, gen::Pythia6PtGun, gen::Pythia6PartonEGun, and gen::Pythia6PartonPtGun.

Referenced by produce().

void Pythia6Gun::loadEvent ( edm::Event & evt )

protected

Definition at line 187 of file Pythia6Gun.cc.

References fEvt, GenLeadTrackFilter_cfi::HepMCProduct, eostools::move(), and edm::Event::put().

Referenced by produce().

                                         {
   std::unique_ptr<HepMCProduct> bare_product(new HepMCProduct());
 
   if (fEvt)
     bare_product->addHepMCData(fEvt);
 
   evt.put(std::move(bare_product), "unsmeared");
 
   return;
 }

void Pythia6Gun::produce	(	edm::Event &	evt,
		const edm::EventSetup &
	)

override

Definition at line 162 of file Pythia6Gun.cc.

References attachPy6DecaysToGenEvent(), gen::call_pylist(), edm::EventID::event(), fEvt, fHepMCVerbosity, fMaxEventsToPrint, fPy6Service, fPylistVerbosity, generateEvent(), edm::EventBase::id(), loadEvent(), pypars, gen::Pythia6Service::randomEngine(), and edm::Event::streamID().

                                                             {
   RandomEngineSentry<Pythia6Service> sentry(fPy6Service, evt.streamID());
 
   generateEvent(fPy6Service->randomEngine());
 
   fEvt->set_beam_particles(nullptr, nullptr);
   fEvt->set_event_number(evt.id().event());
   fEvt->set_signal_process_id(pypars.msti[0]);
 
   attachPy6DecaysToGenEvent();
 
   int evtN = evt.id().event();
   if (evtN <= fMaxEventsToPrint) {
     if (fPylistVerbosity) {
       call_pylist(fPylistVerbosity);
     }
     if (fHepMCVerbosity) {
       if (fEvt)
         fEvt->print();
     }
   }
 
   loadEvent(evt);
 }