Inheritance diagram for BeamDivergenceVtxGenerator:

Classes
struct	SmearingParameters

Public Member Functions
	BeamDivergenceVtxGenerator (const edm::ParameterSet &)

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

	~BeamDivergenceVtxGenerator () override=default

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &)

Private Member Functions
void	addSmearedGenParticle (const reco::GenParticle &gp, const SmearingParameters &sp, HepMC::GenEvent *genEvt)

void	applySmearingHepMC (const SmearingParameters &sp, HepMC::GenEvent *genEvt)

Static Private Member Functions
template<typename T >
static HepMC::FourVector	smearMomentum (const T &mom, const SmearingParameters &sp)

Private Attributes
edm::ESGetToken< CTPPSBeamParameters, CTPPSBeamParametersRcd >	beamParametersToken_

std::vector< edm::EDGetTokenT< reco::GenParticleCollection > >	genParticleTokens_

bool	simulateBeamDivergence_

bool	simulateVertex_

edm::EDGetTokenT< edm::HepMCProduct >	sourceToken_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 29 of file BeamDivergenceVtxGenerator.cc.

Constructor & Destructor Documentation

◆ BeamDivergenceVtxGenerator()

BeamDivergenceVtxGenerator::BeamDivergenceVtxGenerator ( const edm::ParameterSet & iConfig )

explicit

Definition at line 61 of file BeamDivergenceVtxGenerator.cc.

References genParticleTokens_, edm::ParameterSet::getParameter(), edm::Service< T >::isAvailable(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, edm::InputTag::label(), and sourceToken_.

     : beamParametersToken_(esConsumes<CTPPSBeamParameters, CTPPSBeamParametersRcd>()),
       simulateVertex_(iConfig.getParameter<bool>("simulateVertex")),
       simulateBeamDivergence_(iConfig.getParameter<bool>("simulateBeamDivergence")) {
   const edm::InputTag tagSrcHepMC = iConfig.getParameter<edm::InputTag>("src");
   if (!tagSrcHepMC.label().empty())
     sourceToken_ = consumes<edm::HepMCProduct>(tagSrcHepMC);
 
   for (const auto &it : iConfig.getParameter<std::vector<edm::InputTag>>("srcGenParticle"))
     genParticleTokens_.push_back(consumes<reco::GenParticleCollection>(it));
 
   edm::Service<edm::RandomNumberGenerator> rng;
   if (!rng.isAvailable())
     throw cms::Exception("Configuration")
         << "The BeamDivergenceVtxGenerator requires the RandomNumberGeneratorService\n"
            "which is not present in the configuration file. \n"
            "You must add the service\n"
            "in the configuration file or remove the modules that require it.";
 
   produces<edm::HepMCProduct>();
 }

◆ ~BeamDivergenceVtxGenerator()

BeamDivergenceVtxGenerator::~BeamDivergenceVtxGenerator ( )

overridedefault

Member Function Documentation

◆ addSmearedGenParticle()

void BeamDivergenceVtxGenerator::addSmearedGenParticle	(	const reco::GenParticle &	gp,
		const SmearingParameters &	sp,
		HepMC::GenEvent *	genEvt
	)

private

Definition at line 204 of file BeamDivergenceVtxGenerator.cc.

References TtGenEvtProducer_cfi::genEvt, GenParticle::GenParticle, runTauDisplay::gp, smearMomentum(), L1BJetProducer_cff::vtx, BeamDivergenceVtxGenerator::SmearingParameters::vtx_t, BeamDivergenceVtxGenerator::SmearingParameters::vtx_x, BeamDivergenceVtxGenerator::SmearingParameters::vtx_y, and BeamDivergenceVtxGenerator::SmearingParameters::vtx_z.

Referenced by produce().

                                                                               {
   // add vertex of the particle
   HepMC::GenVertex *vtx = new HepMC::GenVertex(HepMC::FourVector(
       (gp.vx() + sp.vtx_x) * 1E1,  // conversion: cm to mm
       (gp.vy() + sp.vtx_y) * 1E1,
       (gp.vz() + sp.vtx_z) * 1E1,
       (/*gp.vt()*/ +sp.vtx_t) * 1E1));  // TODO: GenParticle doesn't seem to have time component of the vertex
   genEvt->add_vertex(vtx);
 
   // add the particle itself
   HepMC::GenParticle *particle = new HepMC::GenParticle(smearMomentum(gp.p4(), sp), gp.pdgId(), gp.status());
   vtx->add_particle_out(particle);
 }

◆ applySmearingHepMC()

void BeamDivergenceVtxGenerator::applySmearingHepMC	(	const SmearingParameters &	sp,
		HepMC::GenEvent *	genEvt
	)

private

Definition at line 185 of file BeamDivergenceVtxGenerator.cc.

References TtGenEvtProducer_cfi::genEvt, simulateBeamDivergence_, simulateVertex_, smearMomentum(), BeamDivergenceVtxGenerator::SmearingParameters::vtx_t, BeamDivergenceVtxGenerator::SmearingParameters::vtx_x, BeamDivergenceVtxGenerator::SmearingParameters::vtx_y, and BeamDivergenceVtxGenerator::SmearingParameters::vtx_z.

Referenced by produce().

                                                                                                        {
   if (simulateVertex_) {
     for (HepMC::GenEvent::vertex_iterator vit = genEvt->vertices_begin(); vit != genEvt->vertices_end(); ++vit) {
       const auto &pos = (*vit)->position();
       (*vit)->set_position(HepMC::FourVector(pos.x() + sp.vtx_x * 1E1,  // conversion: cm to mm
                                              pos.y() + sp.vtx_y * 1E1,
                                              pos.z() + sp.vtx_z * 1E1,
                                              pos.t() + sp.vtx_t * 1E1));
     }
   }
 
   if (simulateBeamDivergence_) {
     for (HepMC::GenEvent::particle_iterator part = genEvt->particles_begin(); part != genEvt->particles_end(); ++part)
       (*part)->set_momentum(smearMomentum((*part)->momentum(), sp));
   }
 }

◆ fillDescriptions()

void BeamDivergenceVtxGenerator::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 85 of file BeamDivergenceVtxGenerator.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and ProducerED_cfi::InputTag.

                                                                                             {
   edm::ParameterSetDescription desc;
 
   desc.add<edm::InputTag>("src", edm::InputTag("generator", "unsmeared"))
       ->setComment("input collection in HepMC format");
 
   desc.add<std::vector<edm::InputTag>>("srcGenParticle", std::vector<edm::InputTag>())
       ->setComment("input collections in GenParticle format");
 
   desc.add<bool>("simulateBeamDivergence", true)->setComment("account for the beam angular divergence?");
   desc.add<bool>("simulateVertex", true)->setComment("account for the vertex transverse smearing?");
 
   descriptions.add("beamDivergenceVtxGenerator", desc);
 }

◆ produce()

void BeamDivergenceVtxGenerator::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

override

Definition at line 102 of file BeamDivergenceVtxGenerator.cc.

                                                                                       {
   // get random engine
   edm::Service<edm::RandomNumberGenerator> rng;
   CLHEP::HepRandomEngine *rnd = &(rng->getEngine(iEvent.streamID()));
 
   // get conditions
   edm::ESHandle<CTPPSBeamParameters> hBeamParameters = iSetup.getHandle(beamParametersToken_);
 
   // get HepMC input (if given)
   HepMC::GenEvent *genEvt;
   if (sourceToken_.isUninitialized()) {
     genEvt = new HepMC::GenEvent();
   } else {
     edm::Handle<edm::HepMCProduct> hepUnsmearedMCEvt;
     iEvent.getByToken(sourceToken_, hepUnsmearedMCEvt);
 
     genEvt = new HepMC::GenEvent(*hepUnsmearedMCEvt->GetEvent());
   }
 
   // prepare output
   std::unique_ptr<edm::HepMCProduct> output(new edm::HepMCProduct(genEvt));
 
   // generate smearing parameters
   SmearingParameters sp;
 
   if (simulateVertex_) {
     // NB: the separtion between effective offsets in LHC sectors 45 and 56 cannot be applied, thus the values for 45 are used
     sp.vtx_x = hBeamParameters->getVtxOffsetX45() + CLHEP::RandGauss::shoot(rnd) * hBeamParameters->getVtxStddevX();
     sp.vtx_y = hBeamParameters->getVtxOffsetY45() + CLHEP::RandGauss::shoot(rnd) * hBeamParameters->getVtxStddevY();
     sp.vtx_z = hBeamParameters->getVtxOffsetZ45() + CLHEP::RandGauss::shoot(rnd) * hBeamParameters->getVtxStddevZ();
     sp.vtx_t = hBeamParameters->getVtxOffsetT45() + CLHEP::RandGauss::shoot(rnd) * hBeamParameters->getVtxStddevT();
   }
 
   if (simulateBeamDivergence_) {
     sp.bd_x_45 = CLHEP::RandGauss::shoot(rnd) * hBeamParameters->getBeamDivergenceX45();
     sp.bd_x_56 = CLHEP::RandGauss::shoot(rnd) * hBeamParameters->getBeamDivergenceX56();
     sp.bd_y_45 = CLHEP::RandGauss::shoot(rnd) * hBeamParameters->getBeamDivergenceY45();
     sp.bd_y_56 = CLHEP::RandGauss::shoot(rnd) * hBeamParameters->getBeamDivergenceY56();
   }
 
   // apply smearing
   applySmearingHepMC(sp, genEvt);
 
   for (const auto &token : genParticleTokens_) {
     edm::Handle<reco::GenParticleCollection> hGPCollection;
     iEvent.getByToken(token, hGPCollection);
 
     for (const auto &gp : *hGPCollection)
       addSmearedGenParticle(gp, sp, genEvt);
   }
 
   // save output
   iEvent.put(std::move(output));
 }

◆ smearMomentum()

template<typename T >

HepMC::FourVector BeamDivergenceVtxGenerator::smearMomentum	(	const T &	mom,
		const SmearingParameters &	sp
	)

staticprivate

Definition at line 160 of file BeamDivergenceVtxGenerator.cc.

References BeamDivergenceVtxGenerator::SmearingParameters::bd_x_45, BeamDivergenceVtxGenerator::SmearingParameters::bd_x_56, BeamDivergenceVtxGenerator::SmearingParameters::bd_y_45, BeamDivergenceVtxGenerator::SmearingParameters::bd_y_56, AlCaHLTBitMon_ParallelJobs::p, Validation_hcalonly_cfi::sign, and mathSSE::sqrt().

Referenced by addSmearedGenParticle(), and applySmearingHepMC().

                                                                                                     {
   // TODO: this is an oversimplified implemetation
   // the TOTEM smearing module should be taken as reference
 
   double th_x = mom.x() / mom.z();
   double th_y = mom.y() / mom.z();
 
   if (mom.z() > 0.) {
     th_x += sp.bd_x_45;
     th_y += sp.bd_y_45;
   } else {
     th_x += sp.bd_x_56;
     th_y += sp.bd_y_56;
   }
 
   // calculate consistent p_z component
   const double sign = (mom.z() > 0.) ? 1. : -1.;
   const double p = sqrt(mom.x() * mom.x() + mom.y() * mom.y() + mom.z() * mom.z());
   const double p_z = sign * p / sqrt(1. + th_x * th_x + th_y * th_y);
 
   return HepMC::FourVector(p_z * th_x, p_z * th_y, p_z, mom.e());
 }