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	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () 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
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<>
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 28 of file BeamDivergenceVtxGenerator.cc.

Constructor & Destructor Documentation

◆ BeamDivergenceVtxGenerator()

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

explicit

Definition at line 60 of file BeamDivergenceVtxGenerator.cc.

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

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 203 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,
       (/*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);

References TtGenEvtProducer_cfi::genEvt, GenParticle::GenParticle, runTauDisplay::gp, smearMomentum(), extraflags_cff::vtx, BeamDivergenceVtxGenerator::SmearingParameters::vtx_t, 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 184 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() + 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));
   }

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().

◆ fillDescriptions()

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

static

Definition at line 84 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(), submitPVResolutionJobs::desc, and HLT_FULL_cff::InputTag.

◆ produce()

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

override

Definition at line 101 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 159 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());