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

bool	hasAbilityToProduceInEndLumis () 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;
 }