Inheritance diagram for ProduceIsolationMap:

Public Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override

	ProduceIsolationMap (const edm::ParameterSet &)

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

Private Attributes
edm::EDGetTokenT< reco::TrackCollection >	inputCollectionToken_

double	IsolationConeDR_

TrackAssociatorParameters	parameters_

double	TKIsolationPtcut_

edm::EDGetTokenT< reco::TrackCollection >	TKToken_

TrackDetectorAssociator	trackAssociator_

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

Definition at line 69 of file Skim_ProduceIsolationMap.cc.

Constructor & Destructor Documentation

◆ ProduceIsolationMap()

ProduceIsolationMap::ProduceIsolationMap ( const edm::ParameterSet & iConfig )

explicit

Definition at line 96 of file Skim_ProduceIsolationMap.cc.

                                                                        {
   TKToken_ = consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("TKLabel"));
   inputCollectionToken_ = consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("inputCollection"));
   TKIsolationPtcut_ = iConfig.getParameter<double>("TkIsolationPtCut");
   IsolationConeDR_ = iConfig.getParameter<double>("IsolationConeDR");
  
   // TrackAssociator parameters
   edm::ParameterSet parameters = iConfig.getParameter<edm::ParameterSet>("TrackAssociatorParameters");
   edm::ConsumesCollector iC = consumesCollector();
   parameters_.loadParameters(parameters, iC);
   trackAssociator_.useDefaultPropagator();
  
   //register your products
   produces<ValueMap<HSCPIsolation> >();
 }

References edm::ParameterSet::getParameter().

◆ ~ProduceIsolationMap()

ProduceIsolationMap::~ProduceIsolationMap ( )

override

Definition at line 112 of file Skim_ProduceIsolationMap.cc.

112 {}

Member Function Documentation

◆ produce()

void ProduceIsolationMap::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

override

Definition at line 114 of file Skim_ProduceIsolationMap.cc.

                                                                                {
   using namespace edm;
   using namespace std;
  
   using reco::TrackCollection;
  
   Handle<TrackCollection> TKHandle;
   iEvent.getByToken(TKToken_, TKHandle);
   if (!TKHandle.isValid()) {
     edm::LogError("ProduceIsolationMap") << "TK Tracks collection not found";
     return;
   }
  
   //Create empty output collections
   unique_ptr<ValueMap<HSCPIsolation> > trackHSCPIsolMap(new ValueMap<HSCPIsolation>);
   ValueMap<HSCPIsolation>::Filler filler(*trackHSCPIsolMap);
  
   //loop through tracks.
   Handle<TrackCollection> tkTracks;
   iEvent.getByToken(inputCollectionToken_, tkTracks);
   std::vector<HSCPIsolation> IsolationInfoColl(tkTracks->size());
  
   int TkIndex = 0;
   for (TrackCollection::const_iterator itTrack = tkTracks->begin(); itTrack != tkTracks->end(); ++itTrack, TkIndex++) {
     TrackDetMatchInfo info =
         trackAssociator_.associate(iEvent, iSetup, *itTrack, parameters_, TrackDetectorAssociator::InsideOut);
  
     if (!info.ecalRecHits.empty()) {
       IsolationInfoColl[TkIndex].Set_ECAL_Energy(info.coneEnergy(IsolationConeDR_, TrackDetMatchInfo::EcalRecHits));
     }
     if (!info.hcalRecHits.empty()) {
       IsolationInfoColl[TkIndex].Set_HCAL_Energy(info.coneEnergy(IsolationConeDR_, TrackDetMatchInfo::HcalRecHits));
     }
     //      if(info.hcalRecHits.size()>0){IsolationInfoColl[TkIndex].Set_HCAL_Energy(info.hcalConeEnergy());}
     //      if(info.ecalRecHits.size()>0){IsolationInfoColl[TkIndex].Set_ECAL_Energy(info.ecalConeEnergy());}
  
     double SumPt = 0;
     double Count = 0;
     double CountHighPt = 0;
     for (TrackCollection::const_iterator itTrack2 = TKHandle->begin(); itTrack2 != TKHandle->end(); ++itTrack2) {
       if (fabs(itTrack->pt() - itTrack2->pt()) < 0.1 && fabs(itTrack->eta() - itTrack2->eta()) < 0.05)
         continue;
       float dR = deltaR(itTrack->momentum(), itTrack2->momentum());
       if (dR > IsolationConeDR_)
         continue;
       SumPt += itTrack2->pt();
       Count++;
       if (itTrack2->pt() < TKIsolationPtcut_)
         continue;
       CountHighPt++;
     }
     IsolationInfoColl[TkIndex].Set_TK_CountHighPt(CountHighPt);
     IsolationInfoColl[TkIndex].Set_TK_Count(Count);
     IsolationInfoColl[TkIndex].Set_TK_SumEt(SumPt);
   }
  
   filler.insert(tkTracks, IsolationInfoColl.begin(), IsolationInfoColl.end());
   filler.fill();
   iEvent.put(std::move(trackHSCPIsolMap));
 }