#include <FlatRandomPtAndDxyGunProducer.h>

Inheritance diagram for edm::FlatRandomPtAndDxyGunProducer:

Public Member Functions
	FlatRandomPtAndDxyGunProducer (const ParameterSet &pset)

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

	~FlatRandomPtAndDxyGunProducer () override

Public Member Functions inherited from edm::BaseFlatGunProducer
	BaseFlatGunProducer (const ParameterSet &)

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

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

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

	~BaseFlatGunProducer () override

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

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

ModuleDescription const &	moduleDescription () 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)

virtual	~ProducerBase () noexcept(false)

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

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

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

virtual	~EDConsumerBase () noexcept(false)

Private Attributes
double	ConeH_

double	ConeRadius_

double	DistanceToAPEX_

double	dxyMax_

double	dxyMin_

double	fMaxPt

double	fMinPt

double	lxyMax_

double	lzMax_

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 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 inherited from edm::BaseFlatGunProducer
bool	fAddAntiParticle

HepMC::GenEvent *	fEvt

double	fMaxEta

double	fMaxPhi

double	fMinEta

double	fMinPhi

std::vector< int >	fPartIDs

ESHandle< HepPDT::ParticleDataTable >	fPDGTable

int	fVerbosity

Detailed Description

Definition at line 25 of file FlatRandomPtAndDxyGunProducer.h.

Constructor & Destructor Documentation

FlatRandomPtAndDxyGunProducer::FlatRandomPtAndDxyGunProducer ( const ParameterSet & pset )

Definition at line 18 of file FlatRandomPtAndDxyGunProducer.cc.

References ConeH_, ConeRadius_, DistanceToAPEX_, dxyMax_, dxyMin_, fMaxPt, fMinPt, edm::ParameterSet::getParameter(), lxyMax_, and lzMax_.

                                                                                      :
 BaseFlatGunProducer(pset)
 {
   ParameterSet defpset ;
   ParameterSet pgun_params =
     pset.getParameter<ParameterSet>("PGunParameters") ;
 
   fMinPt = pgun_params.getParameter<double>("MinPt");
   fMaxPt = pgun_params.getParameter<double>("MaxPt");
   dxyMin_ = pgun_params.getParameter<double>("dxyMin");
   dxyMax_ = pgun_params.getParameter<double>("dxyMax");
   lxyMax_ = pgun_params.getParameter<double>("LxyMax");
   lzMax_ = pgun_params.getParameter<double>("LzMax");
   ConeRadius_ = pgun_params.getParameter<double>("ConeRadius");
   ConeH_ = pgun_params.getParameter<double>("ConeH");
   DistanceToAPEX_ = pgun_params.getParameter<double>("DistanceToAPEX");
 
   produces<HepMCProduct>("unsmeared");
   produces<GenEventInfoProduct>();
 }

FlatRandomPtAndDxyGunProducer::~FlatRandomPtAndDxyGunProducer ( )

override

Definition at line 39 of file FlatRandomPtAndDxyGunProducer.cc.

 {
     // no need to cleanup GenEvent memory - done in HepMCProduct
 }

Member Function Documentation

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

override

Definition at line 44 of file FlatRandomPtAndDxyGunProducer.cc.

 {
    edm::Service<edm::RandomNumberGenerator> rng;
    CLHEP::HepRandomEngine* engine = &rng->getEngine(e.streamID());
 
   if ( fVerbosity > 0 ){
     cout << " FlatRandomPtAndDxyGunProducer : Begin New Event Generation" << endl ;
   }
   // event loop (well, another step in it...)
 
   // no need to clean up GenEvent memory - done in HepMCProduct
   //
 
   // here re-create fEvt (memory)
   //
   fEvt = new HepMC::GenEvent() ;
 
   // now actualy, cook up the event from PDGTable and gun parameters
   int barcode = 1 ;
   for (unsigned int ip=0; ip<fPartIDs.size(); ++ip){
 
     double phi_vtx = 0;
     double dxy = 0;
     double pt = 0;
     double eta = 0;
     double px = 0;
     double py = 0;
     double pz = 0;
     double vx = 0;
     double vy = 0;
     double vz = 0;
     double lxy = 0;
 
     bool passLoop = false;
     while (not passLoop) {
 
       bool passLxy = false;
       bool passLz = false;
       phi_vtx = CLHEP::RandFlat::shoot(engine, fMinPhi, fMaxPhi);
       dxy = CLHEP::RandFlat::shoot(engine, dxyMin_, dxyMax_);
       float dxysign = CLHEP::RandFlat::shoot(engine, -1, 1);
       if (dxysign < 0)
       dxy = -dxy;
       pt = CLHEP::RandFlat::shoot(engine, fMinPt, fMaxPt);
       px = pt*cos(phi_vtx);
       py = pt*sin(phi_vtx);
       for (int i=0; i<10000; i++){
         vx = CLHEP::RandFlat::shoot(engine, -lxyMax_, lxyMax_);
         vy = (pt*dxy + vx * py)/px;
         lxy = sqrt(vx*vx + vy*vy);
         if (lxy<abs(lxyMax_) and (vx*px + vy*py)>0){
           passLxy = true;
           break;
         }
       }
       eta = CLHEP::RandFlat::shoot(engine, fMinEta, fMaxEta);
       pz = pt * sinh(eta);
       //vz = fabs(fRandomGaussGenerator->fire(0.0, LzWidth_/2.0));
       float ConeTheta = ConeRadius_/ConeH_;
       for (int j=0; j<100; j++){
       vz = CLHEP::RandFlat::shoot(engine, 0.0, lzMax_);// this is abs(vz)
       float v0 = vz - DistanceToAPEX_;
       if ( v0<=0 or lxy*lxy/(ConeTheta*ConeTheta) > v0*v0 ) {
           passLz=true;
           break;
       }
       }
       if (pz<0)
       vz = -vz;
       passLoop = (passLxy and passLz);
 
       if (passLoop)
         break;
     }
 
     HepMC::GenVertex* Vtx1  = new HepMC::GenVertex(HepMC::FourVector(vx,vy,vz));
 
     int PartID = fPartIDs[ip] ;
     const HepPDT::ParticleData* PData = fPDGTable->particle(HepPDT::ParticleID(abs(PartID))) ;
     double mass   = PData->mass().value() ;
     double energy2= px*px + py*py + pz*pz + mass*mass ;
     double energy = sqrt(energy2) ;
     HepMC::FourVector p(px,py,pz,energy) ;
     HepMC::GenParticle* Part = new HepMC::GenParticle(p,PartID,1);
     Part->suggest_barcode( barcode ) ;
     barcode++;
     Vtx1->add_particle_out(Part);
     fEvt->add_vertex(Vtx1) ;
 
     if ( fAddAntiParticle ) {
       HepMC::GenVertex* Vtx2  = new HepMC::GenVertex(HepMC::FourVector(-vx,-vy,-vz));
       HepMC::FourVector ap(-px,-py,-pz,energy) ;
       int APartID = -PartID ;
       if ( PartID == 22 || PartID == 23 )
         {
           APartID = PartID ;
         }
       HepMC::GenParticle* APart = new HepMC::GenParticle(ap,APartID,1);
       APart->suggest_barcode( barcode ) ;
       barcode++ ;
       Vtx2->add_particle_out(APart) ;
       fEvt->add_vertex(Vtx2) ;
     }
   }
   fEvt->set_event_number(e.id().event()) ;
   fEvt->set_signal_process_id(20) ;
 
   if ( fVerbosity > 0 ){
     fEvt->print() ;
   }
   
   unique_ptr<HepMCProduct> BProduct(new HepMCProduct()) ;
   BProduct->addHepMCData( fEvt );
   e.put(std::move(BProduct), "unsmeared");
   
   unique_ptr<GenEventInfoProduct> genEventInfo(new GenEventInfoProduct(fEvt));
   e.put(std::move(genEventInfo));
   
   if ( fVerbosity > 0 ){
     cout << " FlatRandomPtAndDxyGunProducer : End New Event Generation" << endl ;
     fEvt->print();
   }
 }