Inheritance diagram for MixEvtVtxGenerator:

Public Member Functions
virtual HepMC::FourVector *	getRecVertex (edm::Event &)

virtual HepMC::FourVector *	getVertex (edm::Event &)

	MixEvtVtxGenerator (const edm::ParameterSet &)

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

	~MixEvtVtxGenerator () override

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

Protected Attributes
TMatrixD *	boost_

HepMC::FourVector *	fVertex

Private Attributes
edm::EDGetTokenT< CrossingFrame< HepMCProduct > >	cfLabel

edm::EDGetTokenT< reco::VertexCollection >	hiLabel

edm::EDGetTokenT< HepMCProduct >	signalLabel

bool	useCF_

bool	useRecVertex

std::vector< double >	vtxOffset

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 33 of file MixEvtVtxGenerator.cc.

Constructor & Destructor Documentation

◆ MixEvtVtxGenerator()

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

explicit

Definition at line 58 of file MixEvtVtxGenerator.cc.

References cfLabel, muonDTDigis_cfi::pset, signalLabel, useCF_, useRecVertex, and vtxOffset.

     : fVertex(nullptr),
       boost_(nullptr),
       useRecVertex(pset.exists("useRecVertex") ? pset.getParameter<bool>("useRecVertex") : false)
 
 {
   produces<edm::HepMCProduct>();
   vtxOffset.resize(3);
   if (pset.exists("vtxOffset"))
     vtxOffset = pset.getParameter<std::vector<double> >("vtxOffset");
 
   if (useRecVertex)
     useCF_ = false;
   else {
     useCF_ = pset.getUntrackedParameter<bool>("useCF", false);
     cfLabel = consumes<CrossingFrame<HepMCProduct> >(pset.getParameter<edm::InputTag>("mixLabel"));
   }
   signalLabel = consumes<HepMCProduct>(pset.getParameter<edm::InputTag>("signalLabel"));
 }

◆ ~MixEvtVtxGenerator()

MixEvtVtxGenerator::~MixEvtVtxGenerator ( )

override

Definition at line 78 of file MixEvtVtxGenerator.cc.

References boost_, and fVertex.

                                         {
   delete fVertex;
   if (boost_ != nullptr)
     delete boost_;
   // no need since now it's done in HepMCProduct
   // delete fEvt ;
 }

Member Function Documentation

◆ getRecVertex()

HepMC::FourVector * MixEvtVtxGenerator::getRecVertex ( edm::Event & evt )

virtual

Definition at line 138 of file MixEvtVtxGenerator.cc.

References fVertex, edm::Event::getByToken(), hiLabel, input, and vtxOffset.

Referenced by produce().

                                                             {
   Handle<reco::VertexCollection> input;
   evt.getByToken(hiLabel, input);
 
   double aX, aY, aZ;
 
   aX = input->begin()->position().x() + vtxOffset[0];
   aY = input->begin()->position().y() + vtxOffset[1];
   aZ = input->begin()->position().z() + vtxOffset[2];
 
   if (!fVertex)
     fVertex = new HepMC::FourVector();
   fVertex->set(10.0 * aX, 10.0 * aY, 10.0 * aZ, 0.0);  // HepMC positions in mm (RECO in cm)
 
   return fVertex;
 }

◆ getVertex()

HepMC::FourVector * MixEvtVtxGenerator::getVertex ( edm::Event & evt )

virtual

Definition at line 86 of file MixEvtVtxGenerator.cc.

References cfLabel, gather_cfg::cout, Exception, fVertex, edm::Event::getByToken(), edm::HepMCProduct::GetEvent(), input, edm::HepMCProduct::isVtxGenApplied(), GeneratorMix_cff::mix, edm::Handle< T >::product(), DiDispStaMuonMonitor_cfi::pt, signalLabel, and useCF_.

Referenced by produce().

                                                          {
   HepMC::GenVertex* genvtx = nullptr;
   const HepMC::GenEvent* inev = nullptr;
 
   if (useCF_) {
     Handle<CrossingFrame<HepMCProduct> > cf;
     evt.getByToken(cfLabel, cf);
     MixCollection<HepMCProduct> mix(cf.product());
     if (mix.size() < 2) {
       throw cms::Exception("MatchVtx") << "Mixing has " << mix.size() << " sub-events, should have been at least 2"
                                        << endl;
     }
     const HepMCProduct& bkg = mix.getObject(1);
     if (!(bkg.isVtxGenApplied())) {
       throw cms::Exception("MatchVtx") << "Input background does not have smeared vertex!" << endl;
     } else {
       inev = bkg.GetEvent();
     }
   } else {
     Handle<HepMCProduct> input;
     evt.getByToken(signalLabel, input);
     inev = input->GetEvent();
   }
 
   genvtx = inev->signal_process_vertex();
   if (!genvtx) {
     HepMC::GenEvent::particle_const_iterator pt = inev->particles_begin();
     HepMC::GenEvent::particle_const_iterator ptend = inev->particles_end();
     while (!genvtx || (genvtx->particles_in_size() == 1 && pt != ptend)) {
       if (pt == ptend)
         cout << "End reached, No Gen Vertex!" << endl;
       genvtx = (*pt)->production_vertex();
       ++pt;
     }
   }
   double aX, aY, aZ, aT;
 
   aX = genvtx->position().x();
   aY = genvtx->position().y();
   aZ = genvtx->position().z();
   aT = genvtx->position().t();
 
   if (!fVertex) {
     fVertex = new HepMC::FourVector();
   }
   LogInfo("MatchVtx") << " setting vertex "
                       << " aX " << aX << " aY " << aY << " aZ " << aZ << " aT " << aT << endl;
   fVertex->set(aX, aY, aZ, aT);
 
   return fVertex;
 }

◆ produce()

void MixEvtVtxGenerator::produce	(	edm::Event &	evt,
		const edm::EventSetup &
	)

override

Definition at line 155 of file MixEvtVtxGenerator.cc.

References edm::Event::getByToken(), edm::HepMCProduct::GetEvent(), getRecVertex(), getVertex(), edm::HepMCProduct::isVtxGenApplied(), eostools::move(), edm::Event::put(), signalLabel, and useRecVertex.

                                                               {
   Handle<HepMCProduct> HepUnsmearedMCEvt;
 
   evt.getByToken(signalLabel, HepUnsmearedMCEvt);
 
   // generate new vertex & apply the shift
   //
   if (HepUnsmearedMCEvt->isVtxGenApplied())
     throw cms::Exception("MatchVtx")
         << "Signal HepMCProduct is not compatible for embedding - it's vertex is already smeared." << std::endl;
   // Copy the HepMC::GenEvent
   HepMC::GenEvent* genevt = new HepMC::GenEvent(*HepUnsmearedMCEvt->GetEvent());
   std::unique_ptr<edm::HepMCProduct> HepMCEvt(new edm::HepMCProduct(genevt));
   // generate new vertex & apply the shift
   //
   HepMCEvt->applyVtxGen(useRecVertex ? getRecVertex(evt) : getVertex(evt));
 
   //   HepMCEvt->boostToLab( GetInvLorentzBoost(), "vertex" );
   //   HepMCEvt->boostToLab( GetInvLorentzBoost(), "momentum" );
 
   evt.put(std::move(HepMCEvt));
 
   return;
 }