Inheritance diagram for ConversionTrackCandidateProducer:

Public Member Functions
void	beginRun (edm::Run const &, edm::EventSetup const &es) final

	ConversionTrackCandidateProducer (const edm::ParameterSet &ps)

void	produce (edm::Event &evt, const edm::EventSetup &es) 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

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Member Functions
void	buildCollections (bool detector, const edm::Handle< edm::View< reco::CaloCluster >> &scHandle, const edm::Handle< edm::View< reco::CaloCluster >> &bcHandle, const EcalRecHitCollection &ecalRecHits, const EcalSeverityLevelAlgo *sevLev, CaloTowerCollection const &hcalTowers, TrackCandidateCollection &outInTracks, TrackCandidateCollection &inOutTracks, std::vector< edm::Ptr< reco::CaloCluster >> &vecRecOI, std::vector< edm::Ptr< reco::CaloCluster >> &vecRecIO)

void	setEventSetup (const edm::EventSetup &es)
	Initialize EventSetup objects at each event. More...

Private Attributes
edm::EDGetTokenT< EcalRecHitCollection >	barrelecalCollection_

edm::EDGetTokenT< edm::View< reco::CaloCluster > >	bcBarrelCollection_

edm::EDGetTokenT< edm::View< reco::CaloCluster > >	bcEndcapCollection_

std::vector< edm::Ptr< reco::CaloCluster > >	caloPtrVecInOut_

std::vector< edm::Ptr< reco::CaloCluster > >	caloPtrVecOutIn_

double	ecalIsoCut_offset_

double	ecalIsoCut_slope_

edm::EDGetTokenT< EcalRecHitCollection >	endcapecalCollection_

std::vector< int >	flagsexclEB_

std::vector< int >	flagsexclEE_

edm::EDGetTokenT< CaloTowerCollection >	hcalTowers_

double	hOverEConeSize_

InOutConversionSeedFinder	inOutSeedFinder_

std::string	InOutTrackCandidateCollection_

InOutConversionTrackFinder	inOutTrackFinder_

std::string	InOutTrackSCAssociationCollection_

double	isoConeR_

double	isoEMin_

double	isoEtaSlice_

double	isoEtMin_

double	isoInnerConeR_

double	maxHOverE_

edm::EDGetTokenT< MeasurementTrackerEvent >	measurementTrkEvtToken_

double	minSCEt_

OutInConversionSeedFinder	outInSeedFinder_

std::string	OutInTrackCandidateCollection_

OutInConversionTrackFinder	outInTrackFinder_

std::string	OutInTrackSCAssociationCollection_

edm::EDGetTokenT< edm::View< reco::CaloCluster > >	scHybridBarrelProducer_

edm::EDGetTokenT< edm::View< reco::CaloCluster > >	scIslandEndcapProducer_

std::vector< int >	severitiesexclEB_

std::vector< int >	severitiesexclEE_

edm::ESHandle< CaloGeometry >	theCaloGeom_

std::unique_ptr< BaseCkfTrajectoryBuilder >	theTrajectoryBuilder_

bool	useNumXtals_

std::vector< edm::Ref< reco::SuperClusterCollection > >	vecOfSCRefForInOut

std::vector< edm::Ref< reco::SuperClusterCollection > >	vecOfSCRefForOutIn

bool	vetoClusteredHits_

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

Author: Nancy Marinelli, U. of Notre Dame, US

Definition at line 49 of file ConversionTrackCandidateProducer.cc.

Constructor & Destructor Documentation

◆ ConversionTrackCandidateProducer()

ConversionTrackCandidateProducer::ConversionTrackCandidateProducer ( const edm::ParameterSet & ps )

Definition at line 132 of file ConversionTrackCandidateProducer.cc.

     : bcBarrelCollection_{consumes(config.getParameter<edm::InputTag>("bcBarrelCollection"))},
       bcEndcapCollection_{consumes(config.getParameter<edm::InputTag>("bcEndcapCollection"))},
       scHybridBarrelProducer_{consumes(config.getParameter<edm::InputTag>("scHybridBarrelProducer"))},
       scIslandEndcapProducer_{consumes(config.getParameter<edm::InputTag>("scIslandEndcapProducer"))},
  
       hcalTowers_{consumes(config.getParameter<edm::InputTag>("hcalTowers"))},
       barrelecalCollection_{consumes(config.getParameter<edm::InputTag>("barrelEcalRecHitCollection"))},
       endcapecalCollection_{consumes(config.getParameter<edm::InputTag>("endcapEcalRecHitCollection"))},
       measurementTrkEvtToken_{consumes(edm::InputTag("MeasurementTrackerEvent"))},
  
       theTrajectoryBuilder_(createBaseCkfTrajectoryBuilder(
           config.getParameter<edm::ParameterSet>("TrajectoryBuilderPSet"), consumesCollector())),
       outInSeedFinder_{config, consumesCollector()},
       outInTrackFinder_{config, theTrajectoryBuilder_.get()},
       inOutSeedFinder_{config, consumesCollector()},
       inOutTrackFinder_{config, theTrajectoryBuilder_.get()} {
   OutInTrackCandidateCollection_ = config.getParameter<std::string>("outInTrackCandidateCollection");
   InOutTrackCandidateCollection_ = config.getParameter<std::string>("inOutTrackCandidateCollection");
  
   OutInTrackSCAssociationCollection_ = config.getParameter<std::string>("outInTrackCandidateSCAssociationCollection");
   InOutTrackSCAssociationCollection_ = config.getParameter<std::string>("inOutTrackCandidateSCAssociationCollection");
  
   hOverEConeSize_ = config.getParameter<double>("hOverEConeSize");
   maxHOverE_ = config.getParameter<double>("maxHOverE");
   minSCEt_ = config.getParameter<double>("minSCEt");
   isoConeR_ = config.getParameter<double>("isoConeR");
   isoInnerConeR_ = config.getParameter<double>("isoInnerConeR");
   isoEtaSlice_ = config.getParameter<double>("isoEtaSlice");
   isoEtMin_ = config.getParameter<double>("isoEtMin");
   isoEMin_ = config.getParameter<double>("isoEMin");
   vetoClusteredHits_ = config.getParameter<bool>("vetoClusteredHits");
   useNumXtals_ = config.getParameter<bool>("useNumXstals");
   ecalIsoCut_offset_ = config.getParameter<double>("ecalIsoCut_offset");
   ecalIsoCut_slope_ = config.getParameter<double>("ecalIsoCut_slope");
  
   //Flags and Severities to be excluded from photon calculations
   auto const& flagnamesEB = config.getParameter<std::vector<std::string>>("RecHitFlagToBeExcludedEB");
   auto const& flagnamesEE = config.getParameter<std::vector<std::string>>("RecHitFlagToBeExcludedEE");
  
   flagsexclEB_ = StringToEnumValue<EcalRecHit::Flags>(flagnamesEB);
   flagsexclEE_ = StringToEnumValue<EcalRecHit::Flags>(flagnamesEE);
  
   auto const& severitynamesEB = config.getParameter<std::vector<std::string>>("RecHitSeverityToBeExcludedEB");
   auto const& severitynamesEE = config.getParameter<std::vector<std::string>>("RecHitSeverityToBeExcludedEE");
  
   severitiesexclEB_ = StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynamesEB);
   severitiesexclEE_ = StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynamesEE);
  
   // Register the product
   produces<TrackCandidateCollection>(OutInTrackCandidateCollection_);
   produces<TrackCandidateCollection>(InOutTrackCandidateCollection_);
  
   produces<reco::TrackCandidateCaloClusterPtrAssociation>(OutInTrackSCAssociationCollection_);
   produces<reco::TrackCandidateCaloClusterPtrAssociation>(InOutTrackSCAssociationCollection_);
 }

Member Function Documentation

◆ beginRun()

void ConversionTrackCandidateProducer::beginRun	(	edm::Run const &	r,
		edm::EventSetup const &	es
	)

final

Definition at line 196 of file ConversionTrackCandidateProducer.cc.

                                                                                                    {
   edm::ESHandle<NavigationSchool> nav;
   theEventSetup.get<NavigationSchoolRecord>().get("SimpleNavigationSchool", nav);
   const NavigationSchool* navigation = nav.product();
   theTrajectoryBuilder_->setNavigationSchool(navigation);
   outInSeedFinder_.setNavigationSchool(navigation);
   inOutSeedFinder_.setNavigationSchool(navigation);
 }

References edm::EventSetup::get(), get, inOutSeedFinder_, outInSeedFinder_, edm::ESHandle< T >::product(), ConversionSeedFinder::setNavigationSchool(), and theTrajectoryBuilder_.

◆ buildCollections()

void ConversionTrackCandidateProducer::buildCollections	(	bool	detector,
		const edm::Handle< edm::View< reco::CaloCluster >> &	scHandle,
		const edm::Handle< edm::View< reco::CaloCluster >> &	bcHandle,
		const EcalRecHitCollection &	ecalRecHits,
		const EcalSeverityLevelAlgo *	sevLev,
		CaloTowerCollection const &	hcalTowers,
		TrackCandidateCollection &	outInTracks,
		TrackCandidateCollection &	inOutTracks,
		std::vector< edm::Ptr< reco::CaloCluster >> &	vecRecOI,
		std::vector< edm::Ptr< reco::CaloCluster >> &	vecRecIO
	)

private

Definition at line 329 of file ConversionTrackCandidateProducer.cc.

 {
   //  Loop over SC in the barrel and reconstruct converted photons
   for (auto const& aClus : scHandle->ptrs()) {
     // preselection based in Et and H/E cut.
     if (aClus->energy() / cosh(aClus->eta()) <= minSCEt_)
       continue;
     if (aClus->eta() > 1.479 && aClus->eta() < 1.556)
       continue;
  
     const reco::CaloCluster* pClus = &(*aClus);
     const reco::SuperCluster* sc = dynamic_cast<const reco::SuperCluster*>(pClus);
     double scEt = sc->energy() / cosh(sc->eta());
     EgammaTowerIsolation towerIso(hOverEConeSize_, 0., 0., -1, &hcalTowers);
     double HoE = towerIso.getTowerESum(sc) / sc->energy();
     if (HoE >= maxHOverE_)
       continue;
  
     EgammaRecHitIsolation ecalIso(
         isoConeR_, isoInnerConeR_, isoEtaSlice_, isoEtMin_, isoEMin_, theCaloGeom_, ecalRecHits, sevLevel, DetId::Ecal);
  
     ecalIso.setVetoClustered(vetoClusteredHits_);
     ecalIso.setUseNumCrystals(useNumXtals_);
     if (isBarrel) {
       ecalIso.doFlagChecks(flagsexclEB_);
       ecalIso.doSeverityChecks(&ecalRecHits, severitiesexclEB_);
     } else {
       ecalIso.doFlagChecks(flagsexclEE_);
       ecalIso.doSeverityChecks(&ecalRecHits, severitiesexclEE_);
     }
  
     double ecalIsolation = ecalIso.getEtSum(sc);
     if (ecalIsolation > ecalIsoCut_offset_ + ecalIsoCut_slope_ * scEt)
       continue;
  
     // Now launch the seed finding
     outInSeedFinder_.setCandidate(pClus->energy(),
                                   GlobalPoint(pClus->position().x(), pClus->position().y(), pClus->position().z()));
     outInSeedFinder_.makeSeeds(bcHandle);
  
     std::vector<Trajectory> theOutInTracks = outInTrackFinder_.tracks(outInSeedFinder_.seeds(), outInTrackCandidates);
  
     inOutSeedFinder_.setCandidate(pClus->energy(),
                                   GlobalPoint(pClus->position().x(), pClus->position().y(), pClus->position().z()));
     inOutSeedFinder_.setTracks(theOutInTracks);
     inOutSeedFinder_.makeSeeds(bcHandle);
  
     std::vector<Trajectory> theInOutTracks = inOutTrackFinder_.tracks(inOutSeedFinder_.seeds(), inOutTrackCandidates);
  
     // Debug
     //   std::cout  << "ConversionTrackCandidateProducer  theOutInTracks.size() " << theOutInTracks.size() << " theInOutTracks.size() " << theInOutTracks.size() <<  " Event pointer to out in track size barrel " << outInTrackCandidates.size() << " in out track size " << inOutTrackCandidates.size() <<   "\n";
  
     for (auto it = theOutInTracks.begin(); it != theOutInTracks.end(); ++it) {
       vecRecOI.push_back(aClus);
       //     std::cout  << "ConversionTrackCandidateProducer Barrel OutIn Tracks Number of hits " << (*it).foundHits() << "\n";
     }
  
     for (auto it = theInOutTracks.begin(); it != theInOutTracks.end(); ++it) {
       vecRecIO.push_back(aClus);
       //     std::cout  << "ConversionTrackCandidateProducer Barrel InOut Tracks Number of hits " << (*it).foundHits() << "\n";
     }
   }
 }

References EgammaRecHitIsolation::doFlagChecks(), EgammaRecHitIsolation::doSeverityChecks(), DetId::Ecal, ecalIsoCut_offset_, ecalIsoCut_slope_, RecoTauCleanerPlugins::ecalIsolation, reco::CaloCluster::energy(), reco::CaloCluster::eta(), flagsexclEB_, flagsexclEE_, EgammaRecHitIsolation::getEtSum(), conversions_cfi::hcalTowers, hOverEConeSize_, inOutSeedFinder_, inOutTrackFinder_, PixelPluginsPhase0_cfi::isBarrel, isoConeR_, isoEMin_, isoEtaSlice_, isoEtMin_, isoInnerConeR_, OutInConversionSeedFinder::makeSeeds(), InOutConversionSeedFinder::makeSeeds(), maxHOverE_, minSCEt_, outInSeedFinder_, outInTrackFinder_, reco::CaloCluster::position(), ConversionSeedFinder::seeds(), ConversionSeedFinder::setCandidate(), InOutConversionSeedFinder::setTracks(), EgammaRecHitIsolation::setUseNumCrystals(), EgammaRecHitIsolation::setVetoClustered(), severitiesexclEB_, severitiesexclEE_, theCaloGeom_, InOutConversionTrackFinder::tracks(), OutInConversionTrackFinder::tracks(), useNumXtals_, and vetoClusteredHits_.

Referenced by produce().

◆ fillDescriptions()

void ConversionTrackCandidateProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 405 of file ConversionTrackCandidateProducer.cc.

                                                                                                   {
   // conversionTrackCandidates
   edm::ParameterSetDescription desc;
  
   desc.add<edm::InputTag>("bcBarrelCollection", {"particleFlowSuperClusterECAL", "particleFlowBasicClusterECALBarrel"});
   desc.add<edm::InputTag>("bcEndcapCollection", {"particleFlowSuperClusterECAL", "particleFlowBasicClusterECALEndcap"});
   desc.add<edm::InputTag>("scHybridBarrelProducer",
                           {"particleFlowSuperClusterECAL", "particleFlowSuperClusterECALBarrel"});
   desc.add<edm::InputTag>("scIslandEndcapProducer",
                           {"particleFlowSuperClusterECAL", "particleFlowSuperClusterECALEndcapWithPreshower"});
  
   desc.add<std::string>("outInTrackCandidateSCAssociationCollection", "outInTrackCandidateSCAssociationCollection");
   desc.add<std::string>("inOutTrackCandidateSCAssociationCollection", "inOutTrackCandidateSCAssociationCollection");
   desc.add<std::string>("outInTrackCandidateCollection", "outInTracksFromConversions");
   desc.add<std::string>("inOutTrackCandidateCollection", "inOutTracksFromConversions");
  
   desc.add<edm::InputTag>("barrelEcalRecHitCollection", {"ecalRecHit", "EcalRecHitsEB"});
   desc.add<edm::InputTag>("endcapEcalRecHitCollection", {"ecalRecHit", "EcalRecHitsEE"});
   desc.add<std::string>("MeasurementTrackerName", "");
   desc.add<std::string>("OutInRedundantSeedCleaner", "CachingSeedCleanerBySharedInput");
   desc.add<std::string>("InOutRedundantSeedCleaner", "CachingSeedCleanerBySharedInput");
   desc.add<bool>("useHitsSplitting", false);
   desc.add<int>("maxNumOfSeedsOutIn", 50);
   desc.add<int>("maxNumOfSeedsInOut", 50);
   desc.add<double>("bcEtCut", 1.5);
   desc.add<double>("bcECut", 1.5);
   desc.add<bool>("useEtCut", true);
   desc.add<edm::InputTag>("hcalTowers", {"towerMaker"});
   desc.add<double>("minSCEt", 20.0);
   desc.add<double>("hOverEConeSize", 0.15);
   desc.add<double>("maxHOverE", 0.15);
   desc.add<double>("isoInnerConeR", 3.5);
   desc.add<double>("isoConeR", 0.4);
   desc.add<double>("isoEtaSlice", 2.5);
   desc.add<double>("isoEtMin", 0.0);
   desc.add<double>("isoEMin", 0.08);
   desc.add<bool>("vetoClusteredHits", false);
   desc.add<bool>("useNumXstals", true);
   desc.add<double>("ecalIsoCut_offset", 999999999);  // alternative value: 4.2
   desc.add<double>("ecalIsoCut_slope", 0.0);         // alternative value: 0.003
  
   desc.add<std::vector<std::string>>("RecHitFlagToBeExcludedEB", {});
   desc.add<std::vector<std::string>>("RecHitSeverityToBeExcludedEB", {});
   desc.add<std::vector<std::string>>("RecHitFlagToBeExcludedEE", {});
   desc.add<std::vector<std::string>>("RecHitSeverityToBeExcludedEE", {});
  
   desc.add<double>("fractionShared", 0.5);
   desc.add<std::string>("TrajectoryBuilder", "TrajectoryBuilderForConversions");
   {
     edm::ParameterSetDescription psd0;
     psd0.setUnknown();
     desc.add<edm::ParameterSetDescription>("TrajectoryBuilderPSet", psd0);
   }
   {
     edm::ParameterSetDescription psd0;
     psd0.add<std::string>("propagatorAlongTISE", "alongMomElePropagator");
     psd0.add<int>("numberMeasurementsForFit", 4);
     psd0.add<std::string>("propagatorOppositeTISE", "oppositeToMomElePropagator");
     desc.add<edm::ParameterSetDescription>("TransientInitialStateEstimatorParameters", psd0);
   }
   desc.add<bool>("allowSharedFirstHit", true);
   desc.add<double>("ValidHitBonus", 5.0);
   desc.add<double>("MissingHitPenalty", 20.0);
  
   descriptions.add("conversionTrackCandidates", desc);
   // or use the following to generate the label from the module's C++ type
   //descriptions.addWithDefaultLabel(desc);
 }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, edm::ParameterSetDescription::setUnknown(), and AlCaHLTBitMon_QueryRunRegistry::string.

◆ produce()

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

override

Definition at line 205 of file ConversionTrackCandidateProducer.cc.

                                                                                                      {
   // get the trajectory builder and initialize it with the data
   theTrajectoryBuilder_->setEvent(theEvent, theEventSetup, &theEvent.get(measurementTrkEvtToken_));
  
   // this need to be done after the initialization of the TrajectoryBuilder!
   setEventSetup(theEventSetup);
  
   outInSeedFinder_.setEvent(theEvent);
   inOutSeedFinder_.setEvent(theEvent);
  
   //
   // create empty output collections
   //
   //  Out In Track Candidates
   auto outInTrackCandidate_p = std::make_unique<TrackCandidateCollection>();
   //  In Out  Track Candidates
   auto inOutTrackCandidate_p = std::make_unique<TrackCandidateCollection>();
   //   Track Candidate  calo  Cluster Association
   auto outInAssoc_p = std::make_unique<reco::TrackCandidateCaloClusterPtrAssociation>();
   auto inOutAssoc_p = std::make_unique<reco::TrackCandidateCaloClusterPtrAssociation>();
  
   // Get the basic cluster collection in the Barrel
   bool validBarrelBCHandle = true;
   auto bcBarrelHandle = theEvent.getHandle(bcBarrelCollection_);
   if (!bcBarrelHandle.isValid()) {
     edm::LogError("ConversionTrackCandidateProducer") << "Error! Can't get the Barrel Basic Clusters!";
     validBarrelBCHandle = false;
   }
  
   // Get the basic cluster collection in the Endcap
   bool validEndcapBCHandle = true;
   auto bcEndcapHandle = theEvent.getHandle(bcEndcapCollection_);
   if (!bcEndcapHandle.isValid()) {
     edm::LogError("CoonversionTrackCandidateProducer") << "Error! Can't get the Endcap Basic Clusters";
     validEndcapBCHandle = false;
   }
  
   // Get the Super Cluster collection in the Barrel
   bool validBarrelSCHandle = true;
   auto scBarrelHandle = theEvent.getHandle(scHybridBarrelProducer_);
   if (!scBarrelHandle.isValid()) {
     edm::LogError("CoonversionTrackCandidateProducer") << "Error! Can't get the barrel superclusters!";
     validBarrelSCHandle = false;
   }
  
   // Get the Super Cluster collection in the Endcap
   bool validEndcapSCHandle = true;
   auto scEndcapHandle = theEvent.getHandle(scIslandEndcapProducer_);
   if (!scEndcapHandle.isValid()) {
     edm::LogError("CoonversionTrackCandidateProducer") << "Error! Can't get the endcap superclusters!";
     validEndcapSCHandle = false;
   }
  
   // get the geometry from the event setup:
   theEventSetup.get<CaloGeometryRecord>().get(theCaloGeom_);
  
   auto const& hcalTowers = theEvent.get(hcalTowers_);
  
   auto const& ecalhitsCollEB = theEvent.get(barrelecalCollection_);
   auto const& ecalhitsCollEE = theEvent.get(endcapecalCollection_);
  
   edm::ESHandle<EcalSeverityLevelAlgo> sevlv;
   theEventSetup.get<EcalSeverityLevelAlgoRcd>().get(sevlv);
   const EcalSeverityLevelAlgo* sevLevel = sevlv.product();
  
   caloPtrVecOutIn_.clear();
   caloPtrVecInOut_.clear();
  
   bool isBarrel = true;
   if (validBarrelBCHandle && validBarrelSCHandle)
     buildCollections(isBarrel,
                      scBarrelHandle,
                      bcBarrelHandle,
                      ecalhitsCollEB,
                      sevLevel,
                      hcalTowers,
                      *outInTrackCandidate_p,
                      *inOutTrackCandidate_p,
                      caloPtrVecOutIn_,
                      caloPtrVecInOut_);
  
   if (validEndcapBCHandle && validEndcapSCHandle) {
     isBarrel = false;
     buildCollections(isBarrel,
                      scEndcapHandle,
                      bcEndcapHandle,
                      ecalhitsCollEE,
                      sevLevel,
                      hcalTowers,
                      *outInTrackCandidate_p,
                      *inOutTrackCandidate_p,
                      caloPtrVecOutIn_,
                      caloPtrVecInOut_);
   }
  
   //  std::cout  << "  ConversionTrackCandidateProducer  caloPtrVecOutIn_ size " <<  caloPtrVecOutIn_.size() << " caloPtrVecInOut_ size " << caloPtrVecInOut_.size()  << "\n";
  
   // put all products in the event
   // Barrel
   //std::cout  << "ConversionTrackCandidateProducer Putting in the event " << (*outInTrackCandidate_p).size() << " Out In track Candidates " << "\n";
   auto const refprodOutInTrackC = theEvent.put(std::move(outInTrackCandidate_p), OutInTrackCandidateCollection_);
   //std::cout  << "ConversionTrackCandidateProducer  refprodOutInTrackC size  " <<  (*(refprodOutInTrackC.product())).size()  <<  "\n";
   //
   //std::cout  << "ConversionTrackCandidateProducer Putting in the event  " << (*inOutTrackCandidate_p).size() << " In Out track Candidates " <<  "\n";
   auto const refprodInOutTrackC = theEvent.put(std::move(inOutTrackCandidate_p), InOutTrackCandidateCollection_);
   //std::cout  << "ConversionTrackCandidateProducer  refprodInOutTrackC size  " <<  (*(refprodInOutTrackC.product())).size()  <<  "\n";
  
   edm::ValueMap<reco::CaloClusterPtr>::Filler fillerOI(*outInAssoc_p);
   fillerOI.insert(refprodOutInTrackC, caloPtrVecOutIn_.begin(), caloPtrVecOutIn_.end());
   fillerOI.fill();
   edm::ValueMap<reco::CaloClusterPtr>::Filler fillerIO(*inOutAssoc_p);
   fillerIO.insert(refprodInOutTrackC, caloPtrVecInOut_.begin(), caloPtrVecInOut_.end());
   fillerIO.fill();
  
   // std::cout  << "ConversionTrackCandidateProducer Putting in the event   OutIn track - SC association: size  " <<  (*outInAssoc_p).size() << "\n";
   theEvent.put(std::move(outInAssoc_p), OutInTrackSCAssociationCollection_);
  
   // std::cout << "ConversionTrackCandidateProducer Putting in the event   InOut track - SC association: size  " <<  (*inOutAssoc_p).size() << "\n";
   theEvent.put(std::move(inOutAssoc_p), InOutTrackSCAssociationCollection_);
  
   outInSeedFinder_.clear();
   inOutSeedFinder_.clear();
 }

References barrelecalCollection_, bcBarrelCollection_, bcEndcapCollection_, buildCollections(), caloPtrVecInOut_, caloPtrVecOutIn_, ConversionSeedFinder::clear(), endcapecalCollection_, edm::helper::Filler< Map >::fill(), edm::EventSetup::get(), edm::Event::get(), get, edm::Event::getHandle(), conversions_cfi::hcalTowers, hcalTowers_, inOutSeedFinder_, InOutTrackCandidateCollection_, InOutTrackSCAssociationCollection_, edm::helper::Filler< Map >::insert(), PixelPluginsPhase0_cfi::isBarrel, measurementTrkEvtToken_, eostools::move(), outInSeedFinder_, OutInTrackCandidateCollection_, OutInTrackSCAssociationCollection_, edm::ESHandle< T >::product(), edm::Event::put(), scHybridBarrelProducer_, scIslandEndcapProducer_, ConversionSeedFinder::setEvent(), setEventSetup(), theCaloGeom_, and theTrajectoryBuilder_.

◆ setEventSetup()

void ConversionTrackCandidateProducer::setEventSetup ( const edm::EventSetup & es )

private

Initialize EventSetup objects at each event.

Definition at line 189 of file ConversionTrackCandidateProducer.cc.

                                                                                        {
   outInSeedFinder_.setEventSetup(theEventSetup);
   inOutSeedFinder_.setEventSetup(theEventSetup);
   outInTrackFinder_.setEventSetup(theEventSetup);
   inOutTrackFinder_.setEventSetup(theEventSetup);
 }