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.

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