#include <ConversionTrackCandidateProducer.h>

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

	~ConversionTrackCandidateProducer () 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

Private Member Functions
void	buildCollections (bool detector, const edm::Handle< edm::View< reco::CaloCluster > > &scHandle, const edm::Handle< edm::View< reco::CaloCluster > > &bcHandle, edm::Handle< EcalRecHitCollection > ecalRecHitHandle, const EcalRecHitCollection &ecalRecHits, const EcalSeverityLevelAlgo *sevLev, const edm::Handle< CaloTowerCollection > &hcalTowersHandle, 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_

std::string	InOutTrackCandidateCollection_

std::string	InOutTrackSuperClusterAssociationCollection_

double	isoConeR_

double	isoEMin_

double	isoEtaSlice_

double	isoEtMin_

double	isoInnerConeR_

double	maxHOverE_

edm::EDGetTokenT< MeasurementTrackerEvent >	measurementTrkEvtToken_

double	minSCEt_

int	nEvt_

std::string	OutInTrackCandidateCollection_

std::string	OutInTrackSuperClusterAssociationCollection_

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

std::unique_ptr< InOutConversionTrackFinder >	theInOutTrackFinder_

std::unique_ptr< OutInConversionSeedFinder >	theOutInSeedFinder_

std::unique_ptr< OutInConversionTrackFinder >	theOutInTrackFinder_

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 38 of file ConversionTrackCandidateProducer.h.

Constructor & Destructor Documentation

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

Definition at line 55 of file ConversionTrackCandidateProducer.cc.

References barrelecalCollection_, bcBarrelCollection_, bcEndcapCollection_, ecalIsoCut_offset_, ecalIsoCut_slope_, endcapecalCollection_, flagsexclEB_, flagsexclEE_, edm::ParameterSet::getParameter(), hcalTowers_, hOverEConeSize_, InOutTrackCandidateCollection_, InOutTrackSuperClusterAssociationCollection_, HLT_2018_cff::InputTag, isoConeR_, isoEMin_, isoEtaSlice_, isoEtMin_, isoInnerConeR_, maxHOverE_, measurementTrkEvtToken_, minSCEt_, nEvt_, OutInTrackCandidateCollection_, OutInTrackSuperClusterAssociationCollection_, scHybridBarrelProducer_, scIslandEndcapProducer_, severitiesexclEB_, severitiesexclEE_, AlCaHLTBitMon_QueryRunRegistry::string, useNumXtals_, and vetoClusteredHits_.

     : theTrajectoryBuilder_(createBaseCkfTrajectoryBuilder(
           config.getParameter<edm::ParameterSet>("TrajectoryBuilderPSet"), consumesCollector())),
       theOutInSeedFinder_(new OutInConversionSeedFinder(config, consumesCollector())),
       theOutInTrackFinder_(new OutInConversionTrackFinder(config, theTrajectoryBuilder_.get())),
       theInOutSeedFinder_(new InOutConversionSeedFinder(config, consumesCollector())),
       theInOutTrackFinder_(new InOutConversionTrackFinder(config, theTrajectoryBuilder_.get())) {
   //std::cout << "ConversionTrackCandidateProducer CTOR " << "\n";
   nEvt_ = 0;
 
   // use onfiguration file to setup input/output collection names
 
   bcBarrelCollection_ =
       consumes<edm::View<reco::CaloCluster> >(config.getParameter<edm::InputTag>("bcBarrelCollection"));
   bcEndcapCollection_ =
       consumes<edm::View<reco::CaloCluster> >(config.getParameter<edm::InputTag>("bcEndcapCollection"));
 
   scHybridBarrelProducer_ =
       consumes<edm::View<reco::CaloCluster> >(config.getParameter<edm::InputTag>("scHybridBarrelProducer"));
   scIslandEndcapProducer_ =
       consumes<edm::View<reco::CaloCluster> >(config.getParameter<edm::InputTag>("scIslandEndcapProducer"));
 
   OutInTrackCandidateCollection_ = config.getParameter<std::string>("outInTrackCandidateCollection");
   InOutTrackCandidateCollection_ = config.getParameter<std::string>("inOutTrackCandidateCollection");
 
   OutInTrackSuperClusterAssociationCollection_ =
       config.getParameter<std::string>("outInTrackCandidateSCAssociationCollection");
   InOutTrackSuperClusterAssociationCollection_ =
       config.getParameter<std::string>("inOutTrackCandidateSCAssociationCollection");
 
   barrelecalCollection_ =
       consumes<EcalRecHitCollection>(config.getParameter<edm::InputTag>("barrelEcalRecHitCollection"));
   endcapecalCollection_ =
       consumes<EcalRecHitCollection>(config.getParameter<edm::InputTag>("endcapEcalRecHitCollection"));
   hcalTowers_ = consumes<CaloTowerCollection>(config.getParameter<edm::InputTag>("hcalTowers"));
   measurementTrkEvtToken_ = consumes<MeasurementTrackerEvent>(edm::InputTag("MeasurementTrackerEvent"));
   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
   const std::vector<std::string> flagnamesEB =
       config.getParameter<std::vector<std::string> >("RecHitFlagToBeExcludedEB");
 
   const std::vector<std::string> flagnamesEE =
       config.getParameter<std::vector<std::string> >("RecHitFlagToBeExcludedEE");
 
   flagsexclEB_ = StringToEnumValue<EcalRecHit::Flags>(flagnamesEB);
 
   flagsexclEE_ = StringToEnumValue<EcalRecHit::Flags>(flagnamesEE);
 
   const std::vector<std::string> severitynamesEB =
       config.getParameter<std::vector<std::string> >("RecHitSeverityToBeExcludedEB");
 
   severitiesexclEB_ = StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynamesEB);
 
   const std::vector<std::string> severitynamesEE =
       config.getParameter<std::vector<std::string> >("RecHitSeverityToBeExcludedEE");
 
   severitiesexclEE_ = StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynamesEE);
 
   // Register the product
   produces<TrackCandidateCollection>(OutInTrackCandidateCollection_);
   produces<TrackCandidateCollection>(InOutTrackCandidateCollection_);
 
   produces<reco::TrackCandidateCaloClusterPtrAssociation>(OutInTrackSuperClusterAssociationCollection_);
   produces<reco::TrackCandidateCaloClusterPtrAssociation>(InOutTrackSuperClusterAssociationCollection_);
 }

ConversionTrackCandidateProducer::~ConversionTrackCandidateProducer ( )

override

Definition at line 133 of file ConversionTrackCandidateProducer.cc.

133 {}

Member Function Documentation

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

final

Definition at line 142 of file ConversionTrackCandidateProducer.cc.

References edm::EventSetup::get(), edm::ESHandle< T >::product(), theInOutSeedFinder_, theOutInSeedFinder_, and theTrajectoryBuilder_.

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

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

private

Definition at line 294 of file ConversionTrackCandidateProducer.cc.

References caloPtrVecInOut_, caloPtrVecOutIn_, EgammaRecHitIsolation::doFlagChecks(), EgammaRecHitIsolation::doSeverityChecks(), DetId::Ecal, ecalIsoCut_offset_, ecalIsoCut_slope_, RecoTauCleanerPlugins::ecalIsolation, reco::CaloCluster::energy(), reco::CaloCluster::eta(), flagsexclEB_, flagsexclEE_, EgammaRecHitIsolation::getEtSum(), EgammaTowerIsolation::getTowerESum(), hOverEConeSize_, isoConeR_, isoEMin_, isoEtaSlice_, isoEtMin_, isoInnerConeR_, maxHOverE_, minSCEt_, reco::CaloCluster::position(), edm::Handle< T >::product(), SimDataFormats::CaloAnalysis::sc, EgammaRecHitIsolation::setUseNumCrystals(), EgammaRecHitIsolation::setVetoClustered(), severitiesexclEB_, severitiesexclEE_, theCaloGeom_, theInOutSeedFinder_, theInOutTrackFinder_, theOutInSeedFinder_, theOutInTrackFinder_, useNumXtals_, and vetoClusteredHits_.

Referenced by produce().

 {
   //std::cout << "ConversionTrackCandidateProducer is barrel " << isBarrel <<  "\n";
   //std::cout << "ConversionTrackCandidateProducer builcollections sc size " << scHandle->size() <<  "\n";
   //std::cout << "ConversionTrackCandidateProducer builcollections bc size " << bcHandle->size() <<  "\n";
   //const CaloGeometry* geometry = theCaloGeom_.product();
 
   //  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());
     const CaloTowerCollection* hcalTowersColl = hcalTowersHandle.product();
     EgammaTowerIsolation towerIso(hOverEConeSize_, 0., 0., -1, hcalTowersColl);
     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(ecalRecHitHandle.product(), severitiesexclEB_);
     } else {
       ecalIso.doFlagChecks(flagsexclEE_);
       ecalIso.doSeverityChecks(ecalRecHitHandle.product(), severitiesexclEE_);
     }
 
     double ecalIsolation = ecalIso.getEtSum(sc);
     if (ecalIsolation > ecalIsoCut_offset_ + ecalIsoCut_slope_ * scEt)
       continue;
 
     // Now launch the seed finding
     theOutInSeedFinder_->setCandidate(pClus->energy(),
                                       GlobalPoint(pClus->position().x(), pClus->position().y(), pClus->position().z()));
     theOutInSeedFinder_->makeSeeds(bcHandle);
 
     std::vector<Trajectory> theOutInTracks =
         theOutInTrackFinder_->tracks(theOutInSeedFinder_->seeds(), outInTrackCandidates);
 
     theInOutSeedFinder_->setCandidate(pClus->energy(),
                                       GlobalPoint(pClus->position().x(), pClus->position().y(), pClus->position().z()));
     theInOutSeedFinder_->setTracks(theOutInTracks);
     theInOutSeedFinder_->makeSeeds(bcHandle);
 
     std::vector<Trajectory> theInOutTracks =
         theInOutTrackFinder_->tracks(theInOutSeedFinder_->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 (std::vector<Trajectory>::const_iterator it = theOutInTracks.begin(); it != theOutInTracks.end(); ++it) {
       caloPtrVecOutIn_.push_back(aClus);
       //     std::cout  << "ConversionTrackCandidateProducer Barrel OutIn Tracks Number of hits " << (*it).foundHits() << "\n";
     }
 
     for (std::vector<Trajectory>::const_iterator it = theInOutTracks.begin(); it != theInOutTracks.end(); ++it) {
       caloPtrVecInOut_.push_back(aClus);
       //     std::cout  << "ConversionTrackCandidateProducer Barrel InOut Tracks Number of hits " << (*it).foundHits() << "\n";
     }
   }
 }

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

override

Definition at line 151 of file ConversionTrackCandidateProducer.cc.

References barrelecalCollection_, bcBarrelCollection_, bcEndcapCollection_, buildCollections(), caloPtrVecInOut_, caloPtrVecOutIn_, data, endcapecalCollection_, edm::helper::Filler< Map >::fill(), edm::EventSetup::get(), edm::Event::getByToken(), hcalTowers_, InOutTrackCandidateCollection_, InOutTrackSuperClusterAssociationCollection_, edm::helper::Filler< Map >::insert(), PixelPluginsPhase0_cfi::isBarrel, edm::HandleBase::isValid(), measurementTrkEvtToken_, eostools::move(), nEvt_, OutInTrackCandidateCollection_, OutInTrackSuperClusterAssociationCollection_, edm::ESHandle< T >::product(), edm::Event::put(), scHybridBarrelProducer_, scIslandEndcapProducer_, setEventSetup(), theCaloGeom_, theInOutSeedFinder_, theOutInSeedFinder_, and theTrajectoryBuilder_.

                                                                                                      {
   using namespace edm;
   nEvt_++;
   //  std::cout << "ConversionTrackCandidateProducer Analyzing event number " <<   theEvent.id() <<  " Global Counter " << nEvt_ << "\n";
 
   // get the trajectory builder and initialize it with the data
   edm::Handle<MeasurementTrackerEvent> data;
   theEvent.getByToken(measurementTrkEvtToken_, data);
   theTrajectoryBuilder_->setEvent(theEvent, theEventSetup, &*data);
 
   // this need to be done after the initialization of the TrajectoryBuilder!
   setEventSetup(theEventSetup);
 
   theOutInSeedFinder_->setEvent(theEvent);
   theInOutSeedFinder_->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;
   edm::Handle<edm::View<reco::CaloCluster> > bcBarrelHandle;
   theEvent.getByToken(bcBarrelCollection_, bcBarrelHandle);
   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;
   edm::Handle<edm::View<reco::CaloCluster> > bcEndcapHandle;
   theEvent.getByToken(bcEndcapCollection_, bcEndcapHandle);
   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;
   edm::Handle<edm::View<reco::CaloCluster> > scBarrelHandle;
   theEvent.getByToken(scHybridBarrelProducer_, scBarrelHandle);
   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;
   edm::Handle<edm::View<reco::CaloCluster> > scEndcapHandle;
   theEvent.getByToken(scIslandEndcapProducer_, scEndcapHandle);
   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_);
 
   // get Hcal towers collection
   Handle<CaloTowerCollection> hcalTowersHandle;
   theEvent.getByToken(hcalTowers_, hcalTowersHandle);
 
   edm::Handle<EcalRecHitCollection> ecalhitsCollEB;
   edm::Handle<EcalRecHitCollection> ecalhitsCollEE;
 
   theEvent.getByToken(endcapecalCollection_, ecalhitsCollEE);
   theEvent.getByToken(barrelecalCollection_, ecalhitsCollEB);
 
   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,
                      *ecalhitsCollEB,
                      sevLevel,
                      hcalTowersHandle,
                      *outInTrackCandidate_p,
                      *inOutTrackCandidate_p,
                      caloPtrVecOutIn_,
                      caloPtrVecInOut_);
 
   if (validEndcapBCHandle && validEndcapSCHandle) {
     isBarrel = false;
     buildCollections(isBarrel,
                      scEndcapHandle,
                      bcEndcapHandle,
                      ecalhitsCollEE,
                      *ecalhitsCollEE,
                      sevLevel,
                      hcalTowersHandle,
                      *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";
   const edm::OrphanHandle<TrackCandidateCollection> 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";
   const edm::OrphanHandle<TrackCandidateCollection> 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), OutInTrackSuperClusterAssociationCollection_);
 
   // std::cout << "ConversionTrackCandidateProducer Putting in the event   InOut track - SC association: size  " <<  (*inOutAssoc_p).size() << "\n";
   theEvent.put(std::move(inOutAssoc_p), InOutTrackSuperClusterAssociationCollection_);
 
   theOutInSeedFinder_->clear();
   theInOutSeedFinder_->clear();
 }

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

private

Initialize EventSetup objects at each event.

Definition at line 135 of file ConversionTrackCandidateProducer.cc.

References theInOutSeedFinder_, theInOutTrackFinder_, theOutInSeedFinder_, and theOutInTrackFinder_.

Referenced by produce().

                                                                                        {
   theOutInSeedFinder_->setEventSetup(theEventSetup);
   theInOutSeedFinder_->setEventSetup(theEventSetup);
   theOutInTrackFinder_->setEventSetup(theEventSetup);
   theInOutTrackFinder_->setEventSetup(theEventSetup);
 }