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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

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

Constructor & Destructor Documentation

◆ MixEvtVtxGenerator()

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

explicit

Definition at line 58 of file MixEvtVtxGenerator.cc.

     : 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"));
 }

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

◆ ~MixEvtVtxGenerator()

MixEvtVtxGenerator::~MixEvtVtxGenerator ( )

override

Definition at line 78 of file MixEvtVtxGenerator.cc.

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

References boost_, and fVertex.

Member Function Documentation

◆ getRecVertex()

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

virtual

Definition at line 138 of file MixEvtVtxGenerator.cc.

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

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

Referenced by produce().

◆ getVertex()

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

virtual

Definition at line 86 of file MixEvtVtxGenerator.cc.

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

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

◆ produce()

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

override

Definition at line 155 of file MixEvtVtxGenerator.cc.

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