Inheritance diagram for MixEvtVtxGenerator:

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

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

	MixEvtVtxGenerator (const edm::ParameterSet &)

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

virtual	~MixEvtVtxGenerator ()

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector < edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector < ProductResolverIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

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

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 35 of file MixEvtVtxGenerator.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 65 of file MixEvtVtxGenerator.cc.

References cfLabel, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), signalLabel, useCF_, useRecVertex, and vtxOffset.

     : fVertex(0), boost_(0),
       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_ = 0;
    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 ( )

virtual

Definition at line 83 of file MixEvtVtxGenerator.cc.

References boost_, and fVertex.

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

Member Function Documentation

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

virtual

Definition at line 146 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;
 
 }

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

virtual

Definition at line 91 of file MixEvtVtxGenerator.cc.

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

Referenced by produce().

                                                          {
 
   HepMC::GenVertex* genvtx = 0;
   const HepMC::GenEvent* inev = 0;
 
   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;
 
 }

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

overridevirtual

Implements edm::stream::EDProducerBase.

Definition at line 164 of file MixEvtVtxGenerator.cc.

References edm::Event::getByToken(), getRecVertex(), getVertex(), eostools::move(), edm::Event::put(), reco::return(), 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 ;
 
 }