#include <CosMuoGenProducer.h>

Inheritance diagram for edm::CosMuoGenProducer:

Public Member Functions
	CosMuoGenProducer (const ParameterSet &)

	~CosMuoGenProducer () override

Public Member Functions inherited from edm::one::EDProducer< EndRunProducer, one::WatchLuminosityBlocks >
	EDProducer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

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

Private Member Functions
void	beginLuminosityBlock (LuminosityBlock const &, EventSetup const &) override

void	clear ()

void	endLuminosityBlock (LuminosityBlock const &, EventSetup const &) override

void	endRunProduce (Run &r, const EventSetup &es) override

void	produce (Event &e, const EventSetup &es) override

Private Attributes
bool	AllMu

double	ClayLayerWidth

bool	cmVerbosity_

std::unique_ptr< CosmicMuonGenerator >	CosMuoGen

double	ELSF

double	extCrossSect

double	extFilterEff

bool	isInitialized_

double	MaxEn

double	MaxP

double	MaxPh

double	MaxS

double	MaxT

double	MinEn

double	MinP

double	MinP_CMS

double	MinPh

double	MinS

double	MinT

bool	MTCCHalf

bool	MultiMuon

int32_t	MultiMuonFileFirstEvent

std::string	MultiMuonFileName

int32_t	MultiMuonNmin

double	NuPrdAlt

double	PlugVtx

double	PlugVtz

int32_t	RanS

double	RTarget

bool	TIFOnly_constant

bool	TIFOnly_linear

bool	TrackerOnly

double	VarRhoAir

double	VarRhoClay

double	VarRhoPlug

double	VarRhoRock

double	VarRhoWall

double	ZCTarget

double	ZTarget

Additional Inherited Members
Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	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::one::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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)

Detailed Description

Definition at line 22 of file CosMuoGenProducer.h.

Constructor & Destructor Documentation

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

Definition at line 11 of file CosMuoGenProducer.cc.

References AllMu, ClayLayerWidth, CosMuoGen, ELSF, MaxEn, MaxP, MaxPh, MaxS, MaxT, MinEn, MinP, MinP_CMS, MinPh, MinS, MinT, MTCCHalf, MultiMuon, MultiMuonFileFirstEvent, MultiMuonFileName, MultiMuonNmin, NuPrdAlt, PlugVtx, PlugVtz, RanS, RTarget, TIFOnly_constant, TIFOnly_linear, TrackerOnly, VarRhoAir, VarRhoClay, VarRhoPlug, VarRhoRock, VarRhoWall, ZCTarget, and ZTarget.

                                                                    :
   //RanS(pset.getParameter<int>("RanSeed", 123456)), //get seed now from Framework
   MinP(pset.getParameter<double>("MinP")),
   MinP_CMS(pset.getParameter<double>("MinP_CMS")),
   MaxP(pset.getParameter<double>("MaxP")),
   MinT(pset.getParameter<double>("MinTheta")),
   MaxT(pset.getParameter<double>("MaxTheta")),
   MinPh(pset.getParameter<double>("MinPhi")),
   MaxPh(pset.getParameter<double>("MaxPhi")),
   MinS(pset.getParameter<double>("MinT0")),
   MaxS(pset.getParameter<double>("MaxT0")),
   ELSF(pset.getParameter<double>("ElossScaleFactor")),
   RTarget(pset.getParameter<double>("RadiusOfTarget")),
   ZTarget(pset.getParameter<double>("ZDistOfTarget")),
   ZCTarget(pset.getParameter<double>("ZCentrOfTarget")),
   TrackerOnly(pset.getParameter<bool>("TrackerOnly")),
   MultiMuon(pset.getParameter<bool>("MultiMuon")),
   MultiMuonFileName(pset.getParameter<std::string>("MultiMuonFileName")),
   MultiMuonFileFirstEvent(pset.getParameter<int>("MultiMuonFileFirstEvent")),
   MultiMuonNmin(pset.getParameter<int>("MultiMuonNmin")),
   TIFOnly_constant(pset.getParameter<bool>("TIFOnly_constant")),
   TIFOnly_linear(pset.getParameter<bool>("TIFOnly_linear")),
   MTCCHalf(pset.getParameter<bool>("MTCCHalf")),
   PlugVtx(pset.getParameter<double>("PlugVx")),
   PlugVtz(pset.getParameter<double>("PlugVz")),
   VarRhoAir(pset.getParameter<double>("RhoAir")),
   VarRhoWall(pset.getParameter<double>("RhoWall")),
   VarRhoRock(pset.getParameter<double>("RhoRock")),
   VarRhoClay(pset.getParameter<double>("RhoClay")),
   VarRhoPlug(pset.getParameter<double>("RhoPlug")),
   ClayLayerWidth(pset.getParameter<double>("ClayWidth")),
   MinEn(pset.getParameter<double>("MinEnu")),
   MaxEn(pset.getParameter<double>("MaxEnu")),
   NuPrdAlt(pset.getParameter<double>("NuProdAlt")),
   AllMu(pset.getParameter<bool>("AcptAllMu")),
   extCrossSect(pset.getUntrackedParameter<double>("crossSection", -1.)),
   extFilterEff(pset.getUntrackedParameter<double>("filterEfficiency", -1.)),
   cmVerbosity_(pset.getParameter<bool>("Verbosity")),
   isInitialized_(false)
   {
     //if not specified (i.e. negative) then use MinP also for MinP_CMS
     if(MinP_CMS < 0) MinP_CMS = MinP;
 
     // set up the generator
     CosMuoGen = std::make_unique<CosmicMuonGenerator>();
 // Begin JMM change
 //  CosMuoGen->setNumberOfEvents(numberEventsInRun());
     CosMuoGen->setNumberOfEvents(999999999);
 // End of JMM change
     CosMuoGen->setRanSeed(RanS);
     CosMuoGen->setMinP(MinP);
     CosMuoGen->setMinP_CMS(MinP_CMS);
     CosMuoGen->setMaxP(MaxP);
     CosMuoGen->setMinTheta(MinT);
     CosMuoGen->setMaxTheta(MaxT);
     CosMuoGen->setMinPhi(MinPh);
     CosMuoGen->setMaxPhi(MaxPh);
     CosMuoGen->setMinT0(MinS);
     CosMuoGen->setMaxT0(MaxS);
     CosMuoGen->setElossScaleFactor(ELSF);
     CosMuoGen->setRadiusOfTarget(RTarget);
     CosMuoGen->setZDistOfTarget(ZTarget);
     CosMuoGen->setZCentrOfTarget(ZCTarget);
     CosMuoGen->setTrackerOnly(TrackerOnly);
     CosMuoGen->setMultiMuon(MultiMuon);
     CosMuoGen->setMultiMuonFileName(MultiMuonFileName);
     CosMuoGen->setMultiMuonFileFirstEvent(MultiMuonFileFirstEvent);
     CosMuoGen->setMultiMuonNmin(MultiMuonNmin);
     CosMuoGen->setTIFOnly_constant(TIFOnly_constant);
     CosMuoGen->setTIFOnly_linear(TIFOnly_linear);
     CosMuoGen->setMTCCHalf(MTCCHalf);
     CosMuoGen->setPlugVx(PlugVtx);
     CosMuoGen->setPlugVz(PlugVtz);    
     CosMuoGen->setRhoAir(VarRhoAir);
     CosMuoGen->setRhoWall(VarRhoWall);
     CosMuoGen->setRhoRock(VarRhoRock);
     CosMuoGen->setRhoClay(VarRhoClay);
     CosMuoGen->setRhoPlug(VarRhoPlug);
     CosMuoGen->setClayWidth(ClayLayerWidth);
     CosMuoGen->setMinEnu(MinEn);
     CosMuoGen->setMaxEnu(MaxEn);    
     CosMuoGen->setNuProdAlt(NuPrdAlt);
     CosMuoGen->setAcptAllMu(AllMu);
     produces<HepMCProduct>("unsmeared");
     produces<GenEventInfoProduct>();
     produces<GenRunInfoProduct, edm::Transition::EndRun>();
   }

edm::CosMuoGenProducer::~CosMuoGenProducer ( )

override

Definition at line 99 of file CosMuoGenProducer.cc.

References clear().

                                         {
   clear();
 }

Member Function Documentation

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

overrideprivate

Definition at line 103 of file CosMuoGenProducer.cc.

References CosMuoGen, edm::LuminosityBlock::index(), and isInitialized_.

 {
   if(!isInitialized_) {
     isInitialized_ = true;
     RandomEngineSentry<CosmicMuonGenerator> randomEngineSentry(CosMuoGen.get(), lumi.index());
     CosMuoGen->initialize(randomEngineSentry.randomEngine());
   }
 }

void edm::CosMuoGenProducer::clear ( void )

private

Definition at line 127 of file CosMuoGenProducer.cc.

Referenced by endLuminosityBlock(), and ~CosMuoGenProducer().

127 {}

void edm::CosMuoGenProducer::endLuminosityBlock	(	LuminosityBlock const &	,
		EventSetup const &
	)

inlineoverrideprivate

Definition at line 30 of file CosMuoGenProducer.h.

References clear(), MillePedeFileConverter_cfg::e, endRunProduce(), produce(), and alignCSCRings::r.

30 { }

void edm::CosMuoGenProducer::endRunProduce	(	Run &	r,
		const EventSetup &	es
	)

overrideprivate

Definition at line 112 of file CosMuoGenProducer.cc.

References CosMuoGen, fwrapper::cs, extCrossSect, extFilterEff, eostools::move(), MultiMuon, and edm::Run::put().

Referenced by endLuminosityBlock().

 {
   std::unique_ptr<GenRunInfoProduct> genRunInfo(new GenRunInfoProduct());
 
   double cs = CosMuoGen->getRate(); // flux in Hz, not s^-1m^-2
   if (MultiMuon) genRunInfo->setInternalXSec(0.);
   else genRunInfo->setInternalXSec(cs);
   genRunInfo->setExternalXSecLO(extCrossSect);
   genRunInfo->setFilterEfficiency(extFilterEff);
 
   run.put(std::move(genRunInfo));
 
   CosMuoGen->terminate();
 }

void edm::CosMuoGenProducer::produce	(	Event &	e,
		const EventSetup &	es
	)

overrideprivate

Definition at line 129 of file CosMuoGenProducer.cc.

References cmVerbosity_, CosMuoGen, gather_cfg::cout, Debug, edm::EventID::event(), particlelevel_cff::genEventInfo, GenParticle::GenParticle, mps_fire::i, edm::EventBase::id(), eostools::move(), MultiMuon, edm::Event::put(), edm::Event::streamID(), and summarizeEdmComparisonLogfiles::success.

Referenced by endLuminosityBlock().

 {  
   RandomEngineSentry<CosmicMuonGenerator> randomEngineSentry(CosMuoGen.get(), e.streamID());
 
   // generate event
   if (!MultiMuon) {
     CosMuoGen->nextEvent();
   }
   else {
     bool success = CosMuoGen->nextMultiEvent();
     if (!success) std::cout << "CosMuoGenProducer.cc: CosMuoGen->nextMultiEvent() failed!" 
                 << std::endl;
   }
 
   if (Debug) {
     std::cout << "CosMuoGenProducer.cc: CosMuoGen->EventWeight=" << CosMuoGen->EventWeight 
           << "  CosMuoGen: Nmuons=" << CosMuoGen->Id_sf.size() << std::endl; 
     std::cout << "CosMuoGen->Id_at=" << CosMuoGen->Id_at
           << "  CosMuoGen->Vx_at=" << CosMuoGen->Vx_at 
           << "  CosMuoGen->Vy_at=" << CosMuoGen->Vy_at
           << "  CosMuoGen->Vz_at=" << CosMuoGen->Vz_at 
           << "  CosMuoGen->T0_at=" << CosMuoGen->T0_at << std::endl;
     std::cout << "  Px=" << CosMuoGen->Px_at
           << "  Py=" << CosMuoGen->Py_at
           << "  Pz=" << CosMuoGen->Pz_at << std::endl;
     for (unsigned int i=0; i<CosMuoGen->Id_sf.size(); ++i) {
       std::cout << "Id_sf[" << i << "]=" << CosMuoGen->Id_sf[i]
         << "  Vx_sf[" << i << "]=" << CosMuoGen->Vx_sf[i]
         << "  Vy_sf=" << CosMuoGen->Vy_sf[i]
         << "  Vz_sf=" << CosMuoGen->Vz_sf[i]
         << "  T0_sf=" << CosMuoGen->T0_sf[i]
         << "  Px_sf=" << CosMuoGen->Px_sf[i]
         << "  Py_sf=" << CosMuoGen->Py_sf[i]
         << "  Pz_sf=" << CosMuoGen->Pz_sf[i] << std::endl;
       std::cout << "phi_sf=" << atan2(CosMuoGen->Px_sf[i],CosMuoGen->Pz_sf[i]) << std::endl;
       std::cout << "Id_ug[" << i << "]=" << CosMuoGen->Id_ug[i] 
         << "  Vx_ug[" << i << "]=" << CosMuoGen->Vx_ug[i] 
         << "  Vy_ug=" << CosMuoGen->Vy_ug[i]
         << "  Vz_ug=" << CosMuoGen->Vz_ug[i]
         << "  T0_ug=" << CosMuoGen->T0_ug[i]
         << "  Px_ug=" << CosMuoGen->Px_ug[i]
         << "  Py_ug=" << CosMuoGen->Py_ug[i]
         << "  Pz_ug=" << CosMuoGen->Pz_ug[i] << std::endl;
       std::cout << "phi_ug=" << atan2(CosMuoGen->Px_ug[i],CosMuoGen->Pz_ug[i]) << std::endl;;
     }
   }
 
 
   auto fEvt = std::make_unique<HepMC::GenEvent>();
   
   HepMC::GenVertex* Vtx_at = new  HepMC::GenVertex(HepMC::FourVector(CosMuoGen->Vx_at, //[mm]
                                  CosMuoGen->Vy_at, //[mm]
                                  CosMuoGen->Vz_at, //[mm]
                                  CosMuoGen->T0_at)); //[mm]
   //cout << "CosMuoGenProducer.cc: Vy_at=" << CosMuoGen->Vy_at << endl;
   HepMC::FourVector p_at(CosMuoGen->Px_at,CosMuoGen->Py_at,CosMuoGen->Pz_at,CosMuoGen->E_at);
   HepMC::GenParticle* Part_at =
     new HepMC::GenParticle(p_at,CosMuoGen->Id_at, 3);//Comment mother particle in
   Vtx_at->add_particle_in(Part_at);
 
 
   //loop here in case of multi muon events (else just one iteration)
   for (unsigned int i=0; i<CosMuoGen->Id_sf.size(); ++i) {
 
     HepMC::FourVector p_sf(CosMuoGen->Px_sf[i],CosMuoGen->Py_sf[i],CosMuoGen->Pz_sf[i],CosMuoGen->E_sf[i]);
     HepMC::GenParticle* Part_sf_in =
       new HepMC::GenParticle(p_sf,CosMuoGen->Id_sf[i], 3); //Comment daughter particle
     Vtx_at->add_particle_out(Part_sf_in);
     
     HepMC::GenVertex* Vtx_sf = new HepMC::GenVertex(HepMC::FourVector(CosMuoGen->Vx_sf[i],                             CosMuoGen->Vy_sf[i], CosMuoGen->Vz_sf[i], CosMuoGen->T0_sf[i])); //[mm]
     HepMC::GenParticle* Part_sf_out =
       new HepMC::GenParticle(p_sf,CosMuoGen->Id_sf[i], 3); //Comment daughter particle
     
     Vtx_sf->add_particle_in(Part_sf_in);
     Vtx_sf->add_particle_out(Part_sf_out);
     
     fEvt->add_vertex(Vtx_sf); //one per muon
 
     HepMC::GenVertex* Vtx_ug = new HepMC::GenVertex(HepMC::FourVector(CosMuoGen->Vx_ug[i],                             CosMuoGen->Vy_ug[i], CosMuoGen->Vz_ug[i], CosMuoGen->T0_ug[i])); //[mm]
     
     HepMC::FourVector p_ug(CosMuoGen->Px_ug[i],CosMuoGen->Py_ug[i],CosMuoGen->Pz_ug[i],CosMuoGen->E_ug[i]);
     HepMC::GenParticle* Part_ug =
       new HepMC::GenParticle(p_ug,CosMuoGen->Id_ug[i], 1);//Final state daughter particle
 
     Vtx_ug->add_particle_in(Part_sf_out);
     Vtx_ug->add_particle_out(Part_ug);
 
     fEvt->add_vertex(Vtx_ug); //one per muon
 
   }
 
   fEvt->add_vertex(Vtx_at);
   fEvt->set_signal_process_vertex(Vtx_at);
 
   fEvt->set_event_number(e.id().event());
   fEvt->set_signal_process_id(13);
 
   fEvt->weights().push_back( CosMuoGen->EventWeight ); // just one event weight 
   fEvt->weights().push_back( CosMuoGen->Trials ); // int Trials number (unweighted) 
 
 
   if (cmVerbosity_) fEvt->print();
 
   std::unique_ptr<GenEventInfoProduct> genEventInfo(new GenEventInfoProduct( fEvt.get() ));
   e.put(std::move(genEventInfo));
 
   //This causes fEvt to be deleted
   std::unique_ptr<HepMCProduct> CMProduct(new HepMCProduct());
   CMProduct->addHepMCData( fEvt.release() );
   e.put(std::move(CMProduct), "unsmeared");
 }