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

	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

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, ElectronHcalHelper const &hcalHelper, 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_

bool	cutsFromDB

double	ecalIsoCut_offset_

double	ecalIsoCut_slope_

const edm::ESGetToken< EcalPFRecHitThresholds, EcalPFRecHitThresholdsRcd >	ecalPFRechitThresholdsToken_

edm::EDGetTokenT< EcalRecHitCollection >	endcapecalCollection_

std::vector< int >	flagsexclEB_

std::vector< int >	flagsexclEE_

edm::EDGetTokenT< HBHERecHitCollection >	hbheRecHits_

HcalPFCuts const *	hcalCuts = nullptr

edm::ESGetToken< HcalPFCuts, HcalPFCutsRcd >	hcalCutsToken_

std::unique_ptr< ElectronHcalHelper >	hcalHelper_

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_

const edm::ESGetToken< NavigationSchool, NavigationSchoolRecord >	navToken_

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_

const edm::ESGetToken< EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd >	sevlvToken_

edm::ESHandle< CaloGeometry >	theCaloGeom_

const edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	theCaloGeomToken_

std::unique_ptr< BaseCkfTrajectoryBuilder >	theTrajectoryBuilder_

const EcalPFRecHitThresholds *	thresholds = nullptr

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<>
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

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

Definition at line 50 of file ConversionTrackCandidateProducer.cc.

Constructor & Destructor Documentation

◆ ConversionTrackCandidateProducer()

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

Definition at line 145 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"))},
 
       hbheRecHits_{consumes(config.getParameter<edm::InputTag>("hbheRecHits"))},
       barrelecalCollection_{consumes(config.getParameter<edm::InputTag>("barrelEcalRecHitCollection"))},
       endcapecalCollection_{consumes(config.getParameter<edm::InputTag>("endcapEcalRecHitCollection"))},
       measurementTrkEvtToken_{consumes(edm::InputTag("MeasurementTrackerEvent"))},
 
       navToken_(esConsumes<edm::Transition::BeginRun>(edm::ESInputTag("", "SimpleNavigationSchool"))),
       theCaloGeomToken_(esConsumes()),
       sevlvToken_(esConsumes()),
       ecalPFRechitThresholdsToken_{esConsumes()},
       theTrajectoryBuilder_(createBaseCkfTrajectoryBuilder(
           config.getParameter<edm::ParameterSet>("TrajectoryBuilderPSet"), consumesCollector())),
       outInSeedFinder_{config, consumesCollector()},
       outInTrackFinder_{config, theTrajectoryBuilder_.get(), consumesCollector()},
       inOutSeedFinder_{config, consumesCollector()},
       inOutTrackFinder_{config, theTrajectoryBuilder_.get(), consumesCollector()} {
   OutInTrackCandidateCollection_ = config.getParameter<std::string>("outInTrackCandidateCollection");
   InOutTrackCandidateCollection_ = config.getParameter<std::string>("inOutTrackCandidateCollection");
 
   OutInTrackSCAssociationCollection_ = config.getParameter<std::string>("outInTrackCandidateSCAssociationCollection");
   InOutTrackSCAssociationCollection_ = config.getParameter<std::string>("inOutTrackCandidateSCAssociationCollection");
 
   cutsFromDB = config.getParameter<bool>("usePFThresholdsFromDB");
   if (cutsFromDB) {
     hcalCutsToken_ = esConsumes<HcalPFCuts, HcalPFCutsRcd, edm::Transition::BeginRun>(edm::ESInputTag("", "withTopo"));
   }
   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_);
 
   ElectronHcalHelper::Configuration cfgCone;
   cfgCone.hOverEConeSize = hOverEConeSize_;
   if (cfgCone.hOverEConeSize > 0) {
     cfgCone.onlyBehindCluster = false;
     cfgCone.checkHcalStatus = false;
 
     cfgCone.hbheRecHits = hbheRecHits_;
 
     cfgCone.eThresHB = config.getParameter<EgammaHcalIsolation::arrayHB>("recHitEThresholdHB");
     cfgCone.maxSeverityHB = config.getParameter<int>("maxHcalRecHitSeverity");
     cfgCone.eThresHE = config.getParameter<EgammaHcalIsolation::arrayHE>("recHitEThresholdHE");
     cfgCone.maxSeverityHE = cfgCone.maxSeverityHB;
   }
 
   hcalHelper_ = std::make_unique<ElectronHcalHelper>(cfgCone, consumesCollector());
 }

Member Function Documentation

◆ beginRun()

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

final

Definition at line 233 of file ConversionTrackCandidateProducer.cc.

References cutsFromDB, edm::EventSetup::getData(), hcalCuts, hcalCutsToken_, inOutSeedFinder_, navToken_, outInSeedFinder_, ConversionSeedFinder::setNavigationSchool(), and theTrajectoryBuilder_.

                                                                                                    {
   const NavigationSchool* navigation = &theEventSetup.getData(navToken_);
   theTrajectoryBuilder_->setNavigationSchool(navigation);
   outInSeedFinder_.setNavigationSchool(navigation);
   inOutSeedFinder_.setNavigationSchool(navigation);
 
   if (cutsFromDB) {
     hcalCuts = &theEventSetup.getData(hcalCutsToken_);
   }
 }

◆ 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,
		ElectronHcalHelper const &	hcalHelper,
		TrackCandidateCollection &	outInTracks,
		TrackCandidateCollection &	inOutTracks,
		std::vector< edm::Ptr< reco::CaloCluster >> &	vecRecOI,
		std::vector< edm::Ptr< reco::CaloCluster >> &	vecRecIO
	)

private

Definition at line 368 of file ConversionTrackCandidateProducer.cc.

References DetId::Ecal, run3scouting_cff::ecalIso, ecalIsoCut_offset_, ecalIsoCut_slope_, RecoTauCleanerPlugins::ecalIsolation, reco::CaloCluster::energy(), reco::CaloCluster::eta(), flagsexclEB_, flagsexclEE_, hcalCuts, ElectronHcalHelper::hcalESum(), inOutSeedFinder_, inOutTrackFinder_, PixelPluginsPhase0_cfi::isBarrel, isoConeR_, isoEMin_, isoEtaSlice_, isoEtMin_, isoInnerConeR_, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, OutInConversionSeedFinder::makeSeeds(), InOutConversionSeedFinder::makeSeeds(), maxHOverE_, minSCEt_, outInSeedFinder_, outInTrackFinder_, reco::CaloCluster::position(), ConversionSeedFinder::seeds(), ConversionSeedFinder::setCandidate(), InOutConversionSeedFinder::setTracks(), severitiesexclEB_, severitiesexclEE_, theCaloGeom_, thresholds, InOutConversionTrackFinder::tracks(), OutInConversionTrackFinder::tracks(), useNumXtals_, and vetoClusteredHits_.

Referenced by produce().

 {
   //  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());
     double HoE = hcalHelper.hcalESum(*sc, 0, hcalCuts) / 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, *thresholds);
     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";
     }
   }
 }

◆ fillDescriptions()

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

static

Definition at line 443 of file ConversionTrackCandidateProducer.cc.

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

                                                                                                   {
   // 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>("hbheRecHits", {"hbhereco"});
   desc.add<std::vector<double>>("recHitEThresholdHB", {0., 0., 0., 0.});
   desc.add<std::vector<double>>("recHitEThresholdHE", {0., 0., 0., 0., 0., 0., 0.});
   desc.add<bool>("usePFThresholdsFromDB", false);
   desc.add<int>("maxHcalRecHitSeverity", 999999);
 
   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("conversionTrackCandidatesDefault", desc);
   // or use the following to generate the label from the module's C++ type
   //descriptions.addWithDefaultLabel(desc);
 }

◆ produce()

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

override

Definition at line 244 of file ConversionTrackCandidateProducer.cc.

References barrelecalCollection_, bcBarrelCollection_, bcEndcapCollection_, buildCollections(), caloPtrVecInOut_, caloPtrVecOutIn_, ConversionSeedFinder::clear(), ecalPFRechitThresholdsToken_, endcapecalCollection_, edm::helper::Filler< Map >::fill(), edm::Event::get(), edm::EventSetup::getData(), edm::EventSetup::getHandle(), edm::Event::getHandle(), hcalHelper_, inOutSeedFinder_, InOutTrackCandidateCollection_, InOutTrackSCAssociationCollection_, edm::helper::Filler< Map >::insert(), PixelPluginsPhase0_cfi::isBarrel, measurementTrkEvtToken_, eostools::move(), outInSeedFinder_, OutInTrackCandidateCollection_, OutInTrackSCAssociationCollection_, edm::Event::put(), scHybridBarrelProducer_, scIslandEndcapProducer_, ConversionSeedFinder::setEvent(), setEventSetup(), sevlvToken_, theCaloGeom_, theCaloGeomToken_, theTrajectoryBuilder_, and thresholds.

                                                                                                      {
   // 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;
   }
 
   thresholds = &theEventSetup.getData(ecalPFRechitThresholdsToken_);
 
   // get the geometry from the event setup:
   theCaloGeom_ = theEventSetup.getHandle(theCaloGeomToken_);
 
   hcalHelper_->beginEvent(theEvent, theEventSetup);
 
   auto const& ecalhitsCollEB = theEvent.get(barrelecalCollection_);
   auto const& ecalhitsCollEE = theEvent.get(endcapecalCollection_);
 
   const EcalSeverityLevelAlgo* sevLevel = &theEventSetup.getData(sevlvToken_);
 
   caloPtrVecOutIn_.clear();
   caloPtrVecInOut_.clear();
 
   bool isBarrel = true;
   if (validBarrelBCHandle && validBarrelSCHandle)
     buildCollections(isBarrel,
                      scBarrelHandle,
                      bcBarrelHandle,
                      ecalhitsCollEB,
                      sevLevel,
                      *hcalHelper_,
                      *outInTrackCandidate_p,
                      *inOutTrackCandidate_p,
                      caloPtrVecOutIn_,
                      caloPtrVecInOut_);
 
   if (validEndcapBCHandle && validEndcapSCHandle) {
     isBarrel = false;
     buildCollections(isBarrel,
                      scEndcapHandle,
                      bcEndcapHandle,
                      ecalhitsCollEE,
                      sevLevel,
                      *hcalHelper_,
                      *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();
 }

◆ setEventSetup()

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

private

Initialize EventSetup objects at each event.

Definition at line 226 of file ConversionTrackCandidateProducer.cc.

References inOutSeedFinder_, inOutTrackFinder_, outInSeedFinder_, outInTrackFinder_, ConversionTrackFinder::setEventSetup(), and ConversionSeedFinder::setEventSetup().

Referenced by produce().

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