Inheritance diagram for AlCaIsoTracksProducer:

Public Member Functions
	AlCaIsoTracksProducer (edm::ParameterSet const &, const AlCaIsoTracks::Counters *count)

void	endStream () override

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

	~AlCaIsoTracksProducer () override

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< AlCaIsoTracks::Counters > >
	EDProducer ()=default

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

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

static void	globalEndJob (const AlCaIsoTracks::Counters *counters)

static std::unique_ptr< AlCaIsoTracks::Counters >	initializeGlobalCache (edm::ParameterSet const &)

Private Member Functions
void	beginRun (edm::Run const &, edm::EventSetup const &) override

void	endRun (edm::Run const &, edm::EventSetup const &) override

reco::HcalIsolatedTrackCandidateCollection *	select (edm::Handle< edm::TriggerResults > &triggerResults, const std::vector< std::string > &triggerNames_, edm::Handle< reco::TrackCollection > &trkCollection, math::XYZPoint &leadPV, edm::Handle< EcalRecHitCollection > &barrelRecHitsHandle, edm::Handle< EcalRecHitCollection > &endcapRecHitsHandle, edm::Handle< HBHERecHitCollection > &hbhe, double ptL1, double etaL1, double phiL1)

void	setPtEtaPhi (std::vector< edm::Ref< l1extra::L1JetParticleCollection > > &objref, double &ptL1, double &etaL1, double &phiL1)

Private Attributes
double	a_charIsoR_

const double	a_coneR_

const double	a_mipR_

const MagneticField *	bField

const double	eEcalMax_

const double	eIsolate_

const CaloGeometry *	geo

HLTConfigProvider	hltConfig_

const edm::InputTag	labelBS_

const edm::InputTag	labelEB_

const edm::InputTag	labelEE_

const edm::InputTag	labelGenTrack_

const edm::InputTag	labelHBHE_

const edm::InputTag	labelHltGT_

const std::string	labelIsoTk_

const edm::InputTag	labelRecVtx_

const edm::InputTag	labelTriggerEvent_

const edm::InputTag	labelTriggerResults_

const double	maxRestrictionP_

unsigned int	nAll_

unsigned int	nGood_

unsigned int	nRange_

unsigned int	nRun_

const int	preScale_

const std::string	processName_

const double	pTrackHigh_

const double	pTrackLow_

const double	pTrackMin_

spr::trackSelectionParameters	selectionParameter_

const double	slopeRestrictionP_

const std::string	theTrackQuality_

edm::EDGetTokenT< reco::BeamSpot >	tok_bs_

edm::EDGetTokenT< EcalRecHitCollection >	tok_EB_

edm::EDGetTokenT< EcalRecHitCollection >	tok_EE_

edm::EDGetTokenT< reco::TrackCollection >	tok_genTrack_

edm::EDGetTokenT< HBHERecHitCollection >	tok_hbhe_

edm::EDGetTokenT< trigger::TriggerFilterObjectWithRefs >	tok_hltGT_

edm::EDGetTokenT< reco::VertexCollection >	tok_recVtx_

edm::EDGetTokenT< trigger::TriggerEvent >	tok_trigEvt_

edm::EDGetTokenT< edm::TriggerResults >	tok_trigRes_

const std::vector< std::string >	trigNames_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< AlCaIsoTracks::Counters > >
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 88 of file AlCaIsoTracksProducer.cc.

Constructor & Destructor Documentation

AlCaIsoTracksProducer::AlCaIsoTracksProducer	(	edm::ParameterSet const &	iConfig,
		const AlCaIsoTracks::Counters *	count
	)

explicit

Definition at line 140 of file AlCaIsoTracksProducer.cc.

                                                                                                                   :
   nRun_(0), nAll_(0), nGood_(0), nRange_(0),
   trigNames_(iConfig.getParameter<std::vector<std::string> >("triggers")),
   theTrackQuality_(iConfig.getParameter<std::string>("trackQuality")),
   processName_(iConfig.getParameter<std::string>("processName")),
   a_coneR_(iConfig.getParameter<double>("coneRadius")),
   a_mipR_(iConfig.getParameter<double>("coneRadiusMIP")),
   maxRestrictionP_(iConfig.getParameter<double>("maxTrackP")),
   slopeRestrictionP_(iConfig.getParameter<double>("slopeTrackP")),
   pTrackMin_(iConfig.getParameter<double>("minimumTrackP")),
   eEcalMax_(iConfig.getParameter<double>("maximumEcalEnergy")),
   eIsolate_(iConfig.getParameter<double>("isolationEnergy")),
   pTrackLow_(iConfig.getParameter<double>("momentumRangeLow")),
   pTrackHigh_(iConfig.getParameter<double>("momentumRangeHigh")),
   preScale_(iConfig.getParameter<int>("preScaleFactor")),
   labelGenTrack_(iConfig.getParameter<edm::InputTag>("TrackLabel")),
   labelRecVtx_(iConfig.getParameter<edm::InputTag>("VertexLabel")),
   labelBS_(iConfig.getParameter<edm::InputTag>("BeamSpotLabel")),
   labelEB_(iConfig.getParameter<edm::InputTag>("EBRecHitLabel")),
   labelEE_(iConfig.getParameter<edm::InputTag>("EERecHitLabel")),
   labelHBHE_(iConfig.getParameter<edm::InputTag>("HBHERecHitLabel")),
   labelHltGT_(iConfig.getParameter<edm::InputTag>("L1GTSeedLabel")),
   labelTriggerEvent_(iConfig.getParameter<edm::InputTag>("TriggerEventLabel")),
   labelTriggerResults_(iConfig.getParameter<edm::InputTag>("TriggerResultLabel")),
   labelIsoTk_(iConfig.getParameter<std::string>("IsoTrackLabel"))  {
   // Get the run parameters
   // Different isolation cuts are described in DN-2016/029
   // Tight cut uses 2 GeV; Loose cut uses 10 GeV
   // Eta dependent cut uses (maxRestrictionP_ * exp(|ieta|*log(2.5)/18))
   // with the factor for exponential slopeRestrictionP_ = log(2.5)/18
   // maxRestrictionP_ = 8 GeV as came from a study
   const double isolationRadius(28.9);
   selectionParameter_.minPt           = iConfig.getParameter<double>("minTrackPt");;
   selectionParameter_.minQuality      = reco::TrackBase::qualityByName(theTrackQuality_);
   selectionParameter_.maxDxyPV        = iConfig.getParameter<double>("maxDxyPV");
   selectionParameter_.maxDzPV         = iConfig.getParameter<double>("maxDzPV");
   selectionParameter_.maxChi2         = iConfig.getParameter<double>("maxChi2");
   selectionParameter_.maxDpOverP      = iConfig.getParameter<double>("maxDpOverP");
   selectionParameter_.minOuterHit     = iConfig.getParameter<int>("minOuterHit");
   selectionParameter_.minLayerCrossed = iConfig.getParameter<int>("minLayerCrossed");
   selectionParameter_.maxInMiss       = iConfig.getParameter<int>("maxInMiss");
   selectionParameter_.maxOutMiss      = iConfig.getParameter<int>("maxOutMiss");
   a_charIsoR_                         = a_coneR_ + isolationRadius;
 
   // define tokens for access
   tok_hltGT_    = consumes<trigger::TriggerFilterObjectWithRefs>(labelHltGT_);
   tok_trigEvt_  = consumes<trigger::TriggerEvent>(labelTriggerEvent_);
   tok_trigRes_  = consumes<edm::TriggerResults>(labelTriggerResults_);
   tok_genTrack_ = consumes<reco::TrackCollection>(labelGenTrack_);
   tok_recVtx_   = consumes<reco::VertexCollection>(labelRecVtx_);
   tok_bs_       = consumes<reco::BeamSpot>(labelBS_);
   tok_EB_       = consumes<EcalRecHitCollection>(labelEB_);
   tok_EE_       = consumes<EcalRecHitCollection>(labelEE_);
   tok_hbhe_     = consumes<HBHERecHitCollection>(labelHBHE_);
 
   edm::LogInfo("HcalIsoTrack") <<"Parameters read from config file \n" 
                    <<"\t minPt "           << selectionParameter_.minPt
                    <<"\t theTrackQuality " << theTrackQuality_
                    <<"\t minQuality "      << selectionParameter_.minQuality
                    <<"\t maxDxyPV "        << selectionParameter_.maxDxyPV          
                    <<"\t maxDzPV "         << selectionParameter_.maxDzPV          
                    <<"\t maxChi2 "         << selectionParameter_.maxChi2          
                    <<"\t maxDpOverP "      << selectionParameter_.maxDpOverP
                    <<"\t minOuterHit "     << selectionParameter_.minOuterHit
                    <<"\t minLayerCrossed " << selectionParameter_.minLayerCrossed
                    <<"\t maxInMiss "       << selectionParameter_.maxInMiss
                    <<"\t maxOutMiss "      << selectionParameter_.maxOutMiss << "\n"
                    <<"\t a_coneR "         << a_coneR_
                    <<"\t a_charIsoR "      << a_charIsoR_
                    <<"\t a_mipR "          << a_mipR_
                    <<"\t pTrackMin "       << pTrackMin_
                    <<"\t eEcalMax "        << eEcalMax_ 
                    <<"\t maxRestrictionP_ "<< maxRestrictionP_
                    <<"\t slopeRestrictionP_ " << slopeRestrictionP_
                    <<"\t eIsolate_ "       << eIsolate_
                    <<"\t Process "         << processName_ << "\n"
                    <<"\t Precale factor "  << preScale_
                    <<"\t in momentum range " << pTrackLow_
                    <<":" << pTrackHigh_;
   for (unsigned int k=0; k<trigNames_.size(); ++k)
     edm::LogInfo("HcalIsoTrack") << "Trigger[" << k << "] " << trigNames_[k];
 
   //create also IsolatedPixelTrackCandidateCollection which contains isolation info and reference to primary track
   produces<reco::HcalIsolatedTrackCandidateCollection>(labelIsoTk_);
   produces<reco::VertexCollection>(labelRecVtx_.label());
   produces<EcalRecHitCollection>(labelEB_.instance());
   produces<EcalRecHitCollection>(labelEE_.instance());
   produces<HBHERecHitCollection>(labelHBHE_.label());
 
   edm::LogInfo("HcalIsoTrack") << " Expected to produce the collections:\n"
                    << "reco::HcalIsolatedTrackCandidateCollection "
                    << " with label HcalIsolatedTrackCollection\n"
                    << "reco::VertexCollection with label " << labelRecVtx_.label() << "\n"
                    << "EcalRecHitCollection with label EcalRecHitsEB\n"
                    << "EcalRecHitCollection with label EcalRecHitsEE\n"
                    << "HBHERecHitCollection with label " << labelHBHE_.label();
 }

AlCaIsoTracksProducer::~AlCaIsoTracksProducer ( )

override

Definition at line 239 of file AlCaIsoTracksProducer.cc.

239 { }

Member Function Documentation

void AlCaIsoTracksProducer::beginRun	(	edm::Run const &	iRun,
		edm::EventSetup const &	iSetup
	)

overrideprivate

Definition at line 450 of file AlCaIsoTracksProducer.cc.

References bField, geo, edm::EventSetup::get(), hltConfig_, HLTConfigProvider::init(), nRun_, processName_, edm::ESHandle< T >::product(), and edm::RunBase::run().

                                                                                     {
   bool changed(false);
   edm::LogInfo("HcalIsoTrack") << "Run[" << nRun_ << "] " << iRun.run() 
                    << " hltconfig.init " << hltConfig_.init(iRun,iSetup,processName_,changed);
 
   edm::ESHandle<MagneticField> bFieldH;
   iSetup.get<IdealMagneticFieldRecord>().get(bFieldH);
   bField = bFieldH.product();
   edm::ESHandle<CaloGeometry> pG;
   iSetup.get<CaloGeometryRecord>().get(pG);
   geo    = pG.product();
 }

void AlCaIsoTracksProducer::endRun	(	edm::Run const &	iRun,
		edm::EventSetup const &
	)

overrideprivate

Definition at line 463 of file AlCaIsoTracksProducer.cc.

References nRun_, and edm::RunBase::run().

                                                                            {
   edm::LogInfo("HcalIsoTrack") << "endRun [" << nRun_ << "] " << iRun.run();
   ++nRun_;
 }

void AlCaIsoTracksProducer::endStream ( )

override

Definition at line 438 of file AlCaIsoTracksProducer.cc.

References nAll_, nGood_, and nRange_.

                                       {
   globalCache()->nAll_   += nAll_;
   globalCache()->nGood_  += nGood_;
   globalCache()->nRange_ += nRange_;
 }

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

static

Definition at line 241 of file AlCaIsoTracksProducer.cc.

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

                                                                                        {
   edm::ParameterSetDescription desc;
   // producer for  (HCAL isolated tracks)
   desc.add<edm::InputTag>("TrackLabel",   edm::InputTag("generalTracks"));
   desc.add<edm::InputTag>("VertexLabel",  edm::InputTag("offlinePrimaryVertices"));
   desc.add<edm::InputTag>("BeamSpotLabel",edm::InputTag("offlineBeamSpot"));
   desc.add<edm::InputTag>("EBRecHitLabel",edm::InputTag("ecalRecHit","EcalRecHitsEB"));
   desc.add<edm::InputTag>("EERecHitLabel",edm::InputTag("ecalRecHit","EcalRecHitsEE"));
   desc.add<edm::InputTag>("HBHERecHitLabel",edm::InputTag("hbhereco"));
   desc.add<edm::InputTag>("L1GTSeedLabel",edm::InputTag("hltL1sV0SingleJet60"));
   desc.add<edm::InputTag>("TriggerEventLabel",edm::InputTag("hltTriggerSummaryAOD","","HLT"));
   desc.add<edm::InputTag>("TriggerResultLabel",edm::InputTag("TriggerResults","","HLT"));
   desc.add<std::string>("IsoTrackLabel","HcalIsolatedTrackCollection");
   std::vector<std::string> triggers = {"HLT_IsoTrackHB","HLT_IsoTrackHE"};
   desc.add<std::vector<std::string> >("triggers", triggers);
   desc.add<std::string>("processName", "HLT");
   // following 10 parameters are parameters to select good tracks
   desc.add<std::string>("trackQuality","highPurity");
   desc.add<double>("minTrackPt",       1.0);
   desc.add<double>("maxDxyPV",         10.0);
   desc.add<double>("maxDzPV",          100.0);
   desc.add<double>("maxChi2",          5.0);
   desc.add<double>("maxDpOverP",       0.1);
   desc.add<int>("minOuterHit",         4);
   desc.add<int>("minLayerCrossed",     8);
   desc.add<int>("maxInMiss",           2);
   desc.add<int>("maxOutMiss",          2);
   // Minimum momentum of selected isolated track and signal zone
   desc.add<double>("coneRadius",       34.98);
   desc.add<double>("minimumTrackP",    20.0);
   // signal zone in ECAL and MIP energy cutoff
   desc.add<double>("coneRadiusMIP",    14.0);
   desc.add<double>("maximumEcalEnergy",2.0);
   // following 3 parameters are for isolation cuts and described in the code
   desc.add<double>("maxTrackP",        8.0);
   desc.add<double>("slopeTrackP",      0.05090504066);
   desc.add<double>("isolationEnergy",  10.0);
   // Prescale events only containing isolated tracks in the range
   desc.add<double>("momentumRangeLow", 20.0);
   desc.add<double>("momentumRangeHigh",40.0);
   desc.add<int>("preScaleFactor",      10);
   descriptions.add("alcaisotrk",desc);
 }

void AlCaIsoTracksProducer::globalEndJob ( const AlCaIsoTracks::Counters * counters )

static

Definition at line 444 of file AlCaIsoTracksProducer.cc.

References AlCaIsoTracks::Counters::nAll_, AlCaIsoTracks::Counters::nGood_, and AlCaIsoTracks::Counters::nRange_.

                                                                            {
   edm::LogInfo("HcalIsoTrack") << "Finds " << count->nGood_ <<" good tracks in "
                    << count->nAll_ << " events and " << count->nRange_
                    << " events in the momentum raange";
 }

static std::unique_ptr<AlCaIsoTracks::Counters> AlCaIsoTracksProducer::initializeGlobalCache ( edm::ParameterSet const & )

inlinestatic

Definition at line 93 of file AlCaIsoTracksProducer.cc.

References Ecal2004TBTDCRanges_v1_cff::endRun, fillDescriptions(), photonIsolationHIProducer_cfi::hbhe, TauGenJetsDecayModeSelectorAllHadrons_cfi::select, setPtEtaPhi(), and triggerResults.

                                                                                              {
     return std::make_unique<AlCaIsoTracks::Counters>();
   }

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

override

Definition at line 285 of file AlCaIsoTracksProducer.cc.

References edm::SortedCollection< T, SORT >::begin(), edm::EventBase::bunchCrossing(), edm::SortedCollection< T, SORT >::end(), edm::EventID::event(), edm::Event::getByToken(), trigger::TriggerRefsCollections::getObjects(), photonIsolationHIProducer_cfi::hbhe, edm::EventBase::id(), edm::InputTag::instance(), edm::HandleBase::isValid(), edm::InputTag::label(), labelEB_, labelEE_, labelGenTrack_, labelHBHE_, labelIsoTk_, labelRecVtx_, labelTriggerEvent_, labelTriggerResults_, edm::EventBase::luminosityBlock(), eostools::move(), nAll_, nGood_, nRange_, reco::BeamSpot::position(), preScale_, edm::Handle< T >::product(), pTrackHigh_, pTrackLow_, edm::Event::put(), edm::EventID::run(), select(), setPtEtaPhi(), tok_bs_, tok_EB_, tok_EE_, tok_genTrack_, tok_hbhe_, tok_hltGT_, tok_recVtx_, tok_trigEvt_, tok_trigRes_, trigger::TriggerL1CenJet, trigger::TriggerL1ForJet, trigger::TriggerL1TauJet, edm::TriggerNames::triggerNames(), edm::Event::triggerNames(), triggerResults, badGlobalMuonTaggersAOD_cff::vtx, x, y, and z.

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

                                                                                  {
 
   nAll_++;
 #ifdef DebugLog
   edm::LogInfo("HcalIsoTrack") << "Run " << iEvent.id().run() << " Event " 
                    << iEvent.id().event() << " Luminosity " 
                    << iEvent.luminosityBlock() << " Bunch " 
                    << iEvent.bunchCrossing();
 #endif
   bool valid(true);
   //Step1: Get all the relevant containers
   trigger::TriggerEvent triggerEvent;
   edm::Handle<trigger::TriggerEvent> triggerEventHandle;
   iEvent.getByToken(tok_trigEvt_, triggerEventHandle);
   if (!triggerEventHandle.isValid()) {
     edm::LogWarning("HcalIsoTrack") << "Cannot access the collection " << labelTriggerEvent_;
     valid = false;
   }
   edm::Handle<edm::TriggerResults> triggerResults;
   iEvent.getByToken(tok_trigRes_, triggerResults);
   if (!triggerResults.isValid()) {
     edm::LogWarning("HcalIsoTrack") << "Cannot access the collection " << labelTriggerResults_;
     valid = false;
   }
 
   edm::Handle<reco::TrackCollection> trkCollection;
   iEvent.getByToken(tok_genTrack_, trkCollection);
   if (!trkCollection.isValid()) {
     edm::LogWarning("HcalIsoTrack") << "Cannot access the collection " << labelGenTrack_;
     valid = false;
   }
 
   edm::Handle<reco::VertexCollection> recVtxs;
   iEvent.getByToken(tok_recVtx_, recVtxs);  
   if (!recVtxs.isValid()) {
     edm::LogWarning("HcalIsoTrack") << "Cannot access the collection " << labelGenTrack_;
     valid = false;
   }
 
   edm::Handle<reco::BeamSpot> beamSpotH;
   iEvent.getByToken(tok_bs_, beamSpotH);
   math::XYZPoint leadPV(0,0,0);
   if (valid) {
     if (!recVtxs->empty() && !((*recVtxs)[0].isFake())) {
       leadPV = math::XYZPoint((*recVtxs)[0].x(),(*recVtxs)[0].y(),
                   (*recVtxs)[0].z());
     } else if (beamSpotH.isValid()) {
       leadPV = beamSpotH->position();
     }
   }
 #ifdef DebugLog
   edm::LogInfo("HcalIsoTrack") << "Primary Vertex " << leadPV;
 #endif
 
   edm::Handle<EcalRecHitCollection> barrelRecHitsHandle;
   iEvent.getByToken(tok_EB_, barrelRecHitsHandle);
   if (!barrelRecHitsHandle.isValid()) {
     edm::LogWarning("HcalIsoTrack") << "Cannot access the collection " << labelEB_;
     valid = false;
   }
   edm::Handle<EcalRecHitCollection> endcapRecHitsHandle;
   iEvent.getByToken(tok_EE_, endcapRecHitsHandle);
   if (!endcapRecHitsHandle.isValid()) {
     edm::LogWarning("HcalIsoTrack") << "Cannot access the collection " << labelEE_;
     valid = false;
   }
   edm::Handle<HBHERecHitCollection> hbhe;
   iEvent.getByToken(tok_hbhe_, hbhe);
   if (!hbhe.isValid()) {
     edm::LogWarning("HcalIsoTrack") << "Cannot access the collection " << labelHBHE_;
     valid = false;
   }
 
   //Get L1 trigger object
   double ptL1(0), etaL1(0), phiL1(0);
   edm::Handle<trigger::TriggerFilterObjectWithRefs> l1trigobj;
   iEvent.getByToken(tok_hltGT_, l1trigobj);
 
   if (l1trigobj.isValid()) {
     std::vector< edm::Ref<l1extra::L1JetParticleCollection> > l1tauobjref;
     l1trigobj->getObjects(trigger::TriggerL1TauJet, l1tauobjref);
     setPtEtaPhi(l1tauobjref,ptL1,etaL1,phiL1);
 
     std::vector< edm::Ref<l1extra::L1JetParticleCollection> > l1jetobjref;
     l1trigobj->getObjects(trigger::TriggerL1CenJet, l1jetobjref);
     setPtEtaPhi(l1jetobjref,ptL1,etaL1,phiL1);
 
     std::vector< edm::Ref<l1extra::L1JetParticleCollection> > l1forjetobjref;
     l1trigobj->getObjects(trigger::TriggerL1ForJet, l1forjetobjref);
     setPtEtaPhi(l1forjetobjref,ptL1,etaL1,phiL1);
   } else {
     valid = false;
   }
 
   auto outputHcalIsoTrackColl = std::make_unique<reco::HcalIsolatedTrackCandidateCollection>();
   auto outputVColl = std::make_unique<reco::VertexCollection>();
   auto outputEBColl = std::make_unique<EBRecHitCollection>();
   auto outputEEColl = std::make_unique<EERecHitCollection>();
   auto outputHBHEColl = std::make_unique<HBHERecHitCollection>();
 
   //For valid HLT record
   if (!valid) {
     edm::LogWarning("HcalIsoTrack") << "Error! Can't get some of the products";
   } else {
     trigger::TriggerEvent triggerEvent = *(triggerEventHandle.product());
     if (triggerResults.isValid()) {
       const edm::TriggerNames & triggerNames = iEvent.triggerNames(*triggerResults);
       const std::vector<std::string> & triggerNames_ = triggerNames.triggerNames();
       reco::HcalIsolatedTrackCandidateCollection* isotk = select(triggerResults, triggerNames_, trkCollection, leadPV, barrelRecHitsHandle, endcapRecHitsHandle, hbhe, ptL1, etaL1, phiL1);
 #ifdef DebugLog
       edm::LogInfo("HcalIsoTrack") << "AlCaIsoTracksProducer::select returns "
                    << isotk->size() << " isolated tracks";
 #endif
     
       if (!isotk->empty()) {
     int  ntrin(0), ntrout(0);
     for (reco::HcalIsolatedTrackCandidateCollection::const_iterator itr=isotk->begin(); itr!=isotk->end(); ++itr) {
       if (itr->p() > pTrackLow_ && itr->p() < pTrackHigh_) ntrin++;
       else                                                 ntrout++;
     }
     bool selectEvent = ntrout > 0;
     if (!selectEvent && ntrin > 0) {
       ++nRange_;
       if      (preScale_ <= 1)         selectEvent = true;
       else if (nRange_%preScale_ == 1) selectEvent = true;
     }
     if (selectEvent) {
       for (reco::HcalIsolatedTrackCandidateCollection::const_iterator itr=isotk->begin(); itr!=isotk->end(); ++itr)
         outputHcalIsoTrackColl->push_back(*itr);
     
       for (reco::VertexCollection::const_iterator vtx=recVtxs->begin(); vtx!=recVtxs->end(); ++vtx)
         outputVColl->push_back(*vtx);
       
       for (edm::SortedCollection<EcalRecHit>::const_iterator ehit=barrelRecHitsHandle->begin(); ehit!=barrelRecHitsHandle->end(); ++ehit)
         outputEBColl->push_back(*ehit);
     
       for (edm::SortedCollection<EcalRecHit>::const_iterator ehit=endcapRecHitsHandle->begin(); ehit!=endcapRecHitsHandle->end(); ++ehit)
         outputEEColl->push_back(*ehit);
     
       for (std::vector<HBHERecHit>::const_iterator hhit=hbhe->begin(); hhit!=hbhe->end(); ++hhit)
         outputHBHEColl->push_back(*hhit);
       ++nGood_;
     }
       }
     }
   }
   iEvent.put(std::move(outputHcalIsoTrackColl), labelIsoTk_);
   iEvent.put(std::move(outputVColl),            labelRecVtx_.label());
   iEvent.put(std::move(outputEBColl),           labelEB_.instance());
   iEvent.put(std::move(outputEEColl),           labelEE_.instance());
   iEvent.put(std::move(outputHBHEColl),         labelHBHE_.label());
 }

reco::HcalIsolatedTrackCandidateCollection * AlCaIsoTracksProducer::select	(	edm::Handle< edm::TriggerResults > &	triggerResults,
		const std::vector< std::string > &	triggerNames_,
		edm::Handle< reco::TrackCollection > &	trkCollection,
		math::XYZPoint &	leadPV,
		edm::Handle< EcalRecHitCollection > &	barrelRecHitsHandle,
		edm::Handle< EcalRecHitCollection > &	endcapRecHitsHandle,
		edm::Handle< HBHERecHitCollection > &	hbhe,
		double	ptL1,
		double	etaL1,
		double	phiL1
	)

private

Definition at line 469 of file AlCaIsoTracksProducer.cc.

References a_charIsoR_, a_mipR_, edm::HLTGlobalStatus::accept(), bField, spr::chargeIsolationCone(), spr::eCone_ecal(), eEcalMax_, eIsolate_, reco::TrackBase::eta(), JetChargeProducer_cfi::exp, spr::find(), geo, spr::goodTrack(), ValidationMatrix::hlt, mps_fire::i, HcalDetId::ieta(), HcalDetId::ietaAbs(), HcalDetId::iphi(), maxRestrictionP_, nTracks(), convertSQLiteXML::ok, reco::TrackBase::p(), phi, reco::TrackBase::phi(), spr::propagateCALO(), reco::TrackBase::pt(), pTrackMin_, reco::TrackBase::px(), reco::TrackBase::py(), reco::TrackBase::pz(), selectionParameter_, reco::HcalIsolatedTrackCandidate::SetEnergyEcal(), reco::HcalIsolatedTrackCandidate::SetEtaPhiEcal(), reco::HcalIsolatedTrackCandidate::SetEtaPhiHcal(), reco::HcalIsolatedTrackCandidate::setL1(), reco::HcalIsolatedTrackCandidate::SetMaxP(), reco::HcalIsolatedTrackCandidate::setTrack(), edm::HLTGlobalStatus::size(), slopeRestrictionP_, theTrackQuality_, findElectronsInSiStrips_cfi::trackCollection, and trigNames_.

Referenced by Vispa.Views.LineDecayView.LineDecayContainer::createObject(), Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::find(), Vispa.Views.LineDecayView.LineDecayContainer::mousePressEvent(), Vispa.Gui.PortConnection.PointToPointConnection::mousePressEvent(), Vispa.Gui.VispaWidget.VispaWidget::mousePressEvent(), produce(), and Vispa.Views.AbstractView.AbstractView::restoreSelection().

                                                            {
   
   reco::HcalIsolatedTrackCandidateCollection* trackCollection=new reco::HcalIsolatedTrackCandidateCollection;
   bool ok(false);
 
   // Find a good HLT trigger
   for (unsigned int iHLT=0; iHLT<triggerResults->size(); iHLT++) {
     int hlt    = triggerResults->accept(iHLT);
     for (unsigned int i=0; i<trigNames_.size(); ++i) {
       if (triggerNames_[iHLT].find(trigNames_[i])!=std::string::npos) {
     if (hlt > 0) {
       ok = true;
     }
     edm::LogInfo("HcalIsoTrack") << "The trigger we are looking for "
                      << triggerNames_[iHLT] << " Flag " 
                      << hlt << ":" << ok;
       }
     }
   }
 
   //Propagate tracks to calorimeter surface)
   std::vector<spr::propagatedTrackDirection> trkCaloDirections;
   spr::propagateCALO(trkCollection, geo, bField, theTrackQuality_,
              trkCaloDirections, false);
 
   std::vector<spr::propagatedTrackDirection>::const_iterator trkDetItr;
   unsigned int nTracks(0), nselTracks(0);
   for (trkDetItr = trkCaloDirections.begin(),nTracks=0; 
        trkDetItr != trkCaloDirections.end(); trkDetItr++,nTracks++) {
     const reco::Track* pTrack = &(*(trkDetItr->trkItr));
     math::XYZTLorentzVector v4(pTrack->px(), pTrack->py(), 
                    pTrack->pz(), pTrack->p());
 #ifdef DebugLog
     edm::LogInfo("HcalIsoTrack") << "This track : " << nTracks 
                  << " (pt|eta|phi|p) :" << pTrack->pt() 
                  << "|" << pTrack->eta() << "|" 
                  << pTrack->phi() << "|" << pTrack->p();
 #endif      
     //Selection of good track
     bool qltyFlag  = spr::goodTrack(pTrack,leadPV,selectionParameter_,false);
 #ifdef DebugLog
     edm::LogInfo("HcalIsoTrack") << "qltyFlag|okECAL|okHCAL : " << qltyFlag
                  << "|" << trkDetItr->okECAL << "|"  
                  << trkDetItr->okHCAL;
 #endif
     if (qltyFlag && trkDetItr->okECAL && trkDetItr->okHCAL) {
       double t_p        = pTrack->p();
       nselTracks++;
       int    nRH_eMipDR(0), nNearTRKs(0);
       double eMipDR = spr::eCone_ecal(geo, barrelRecHitsHandle, 
                       endcapRecHitsHandle,
                       trkDetItr->pointHCAL,
                       trkDetItr->pointECAL, a_mipR_,
                       trkDetItr->directionECAL, 
                       nRH_eMipDR);
       double hmaxNearP = spr::chargeIsolationCone(nTracks,
                           trkCaloDirections,
                           a_charIsoR_,
                           nNearTRKs, false);
       HcalDetId detId = (HcalDetId)(trkDetItr->detIdHCAL);
       int       ieta = detId.ietaAbs();
       double eIsolation = (maxRestrictionP_*exp(slopeRestrictionP_*((double)(ieta))));
       if (eIsolation < eIsolate_) eIsolation = eIsolate_;
 #ifdef DebugLog
       edm::LogInfo("HcalIsoTrack") << "This track : " << nTracks 
                    << " (pt|eta|phi|p) :"  << pTrack->pt() 
                    << "|" << pTrack->eta() << "|" 
                    << pTrack->phi() << "|" << t_p 
                    << " e_MIP " << eMipDR 
                    << " Chg Isolation " << hmaxNearP
                    << ":" << eIsolation;
 #endif
       if (t_p>pTrackMin_ && eMipDR<eEcalMax_ && hmaxNearP<eIsolation) {
     reco::HcalIsolatedTrackCandidate newCandidate(v4);
     newCandidate.SetMaxP(hmaxNearP);
     newCandidate.SetEnergyEcal(eMipDR);
     newCandidate.setL1(ptL1,etaL1,phiL1);
     newCandidate.SetEtaPhiEcal((trkDetItr->pointECAL).eta(),
                    (trkDetItr->pointECAL).phi());
     HcalDetId detId = HcalDetId(trkDetItr->detIdHCAL);
     newCandidate.SetEtaPhiHcal((trkDetItr->pointHCAL).eta(),
                    (trkDetItr->pointHCAL).phi(),
                    detId.ieta(), detId.iphi());
     int indx(0);
     for (reco::TrackCollection::const_iterator trkItr1=trkCollection->begin(); 
          trkItr1 != trkCollection->end(); ++trkItr1,++indx) {
       const reco::Track* pTrack1 = &(*trkItr1);
       if (pTrack1 == pTrack) {
         reco::TrackRef tRef = reco::TrackRef(trkCollection,indx);
         newCandidate.setTrack(tRef);
         break;
       }
     }
     trackCollection->push_back(newCandidate);
       }
     }
   }
   return trackCollection;
 }

void AlCaIsoTracksProducer::setPtEtaPhi	(	std::vector< edm::Ref< l1extra::L1JetParticleCollection > > &	objref,
		double &	ptL1,
		double &	etaL1,
		double &	phiL1
	)

private

Definition at line 575 of file AlCaIsoTracksProducer.cc.

References DEFINE_FWK_MODULE, AlCaHLTBitMon_ParallelJobs::p, and EnergyCorrector::pt.

Referenced by produce().

                                                                                                                                                {
 
   for (unsigned int p=0; p<objref.size(); p++) {
     if (objref[p]->pt()>ptL1) {
       ptL1  = objref[p]->pt(); 
       phiL1 = objref[p]->phi();
       etaL1 = objref[p]->eta();
     }
   }
 }