#include <ConversionTrackCandidateProducer.h>

Inheritance diagram for ConversionTrackCandidateProducer:

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

	ConversionTrackCandidateProducer (const edm::ParameterSet &ps)

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

	~ConversionTrackCandidateProducer ()

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
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

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

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

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

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

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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

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

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

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::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

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

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_, 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 ( )

Definition at line 141 of file ConversionTrackCandidateProducer.cc.

141 {}

Member Function Documentation

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

finaloverridevirtual

Reimplemented from edm::stream::EDProducerBase.

Definition at line 151 of file ConversionTrackCandidateProducer.cc.

References edm::EventSetup::get(), edm::ESHandle< class >::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 308 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_, i, isoConeR_, isoEMin_, isoEtaSlice_, isoEtMin_, isoInnerConeR_, maxHOverE_, minSCEt_, reco::CaloCluster::position(), edm::Handle< T >::product(), EgammaRecHitIsolation::setUseNumCrystals(), EgammaRecHitIsolation::setVetoClustered(), severitiesexclEB_, severitiesexclEE_, theCaloGeom_, theInOutSeedFinder_, theInOutTrackFinder_, theOutInSeedFinder_, theOutInTrackFinder_, useNumXtals_, and vetoClusteredHits_.

Referenced by produce().

 {
 
   //  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 (unsigned i = 0; i < scHandle->size(); ++i ) {
 
     reco::CaloClusterPtr aClus= scHandle->ptrAt(i);
   
     // 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
	)

overridevirtual

Implements edm::stream::EDProducerBase.

Definition at line 162 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(), measurementTrkEvtToken_, nEvt_, OutInTrackCandidateCollection_, OutInTrackSuperClusterAssociationCollection_, 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
   std::auto_ptr<TrackCandidateCollection> outInTrackCandidate_p(new TrackCandidateCollection); 
   //  In Out  Track Candidates
   std::auto_ptr<TrackCandidateCollection> inOutTrackCandidate_p(new TrackCandidateCollection); 
   //   Track Candidate  calo  Cluster Association
   std::auto_ptr<reco::TrackCandidateCaloClusterPtrAssociation> outInAssoc_p(new reco::TrackCandidateCaloClusterPtrAssociation);
   std::auto_ptr<reco::TrackCandidateCaloClusterPtrAssociation> inOutAssoc_p(new 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( 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( 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( outInAssoc_p, OutInTrackSuperClusterAssociationCollection_);
  
  // std::cout << "ConversionTrackCandidateProducer Putting in the event   InOut track - SC association: size  " <<  (*inOutAssoc_p).size() << "\n";  
  theEvent.put( inOutAssoc_p, InOutTrackSuperClusterAssociationCollection_);
 
  theOutInSeedFinder_->clear();
  theInOutSeedFinder_->clear();
  
 
   
 }

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

private

Initialize EventSetup objects at each event.

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