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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

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
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<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Definition at line 27 of file BeamDivergenceVtxGenerator.cc.

Constructor & Destructor Documentation

◆ BeamDivergenceVtxGenerator()

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

explicit

Definition at line 58 of file BeamDivergenceVtxGenerator.cc.

     : 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>();

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

◆ ~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 200 of file BeamDivergenceVtxGenerator.cc.

                                                                               {
   // 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,
                                                                  0.));
   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);

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

Referenced by produce().

◆ applySmearingHepMC()

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

private

Definition at line 181 of file BeamDivergenceVtxGenerator.cc.

                                                                                                        {
   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()));
     }
   }
  
   if (simulateBeamDivergence_) {
     for (HepMC::GenEvent::particle_iterator part = genEvt->particles_begin(); part != genEvt->particles_end(); ++part)
       (*part)->set_momentum(smearMomentum((*part)->momentum(), sp));
   }

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

Referenced by produce().

◆ fillDescriptions()

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

static

Definition at line 81 of file BeamDivergenceVtxGenerator.cc.

                                                                                             {
   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);

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and HLT_2018_cff::InputTag.

◆ produce()

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

override

Definition at line 98 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.get<CTPPSBeamParametersRcd>().get(hBeamParameters);
  
   // 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();
   }
  
   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 156 of file BeamDivergenceVtxGenerator.cc.

                                                                                                     {
   // 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());