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	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () 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 87 of file AlCaIsoTracksProducer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 149 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 243 of file AlCaIsoTracksProducer.cc.

243 {}

Member Function Documentation

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

overrideprivate

Definition at line 467 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 480 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 456 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 245 of file AlCaIsoTracksProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), HLT_2018_cff::InputTag, 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 462 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 92 of file AlCaIsoTracksProducer.cc.

References Ecal2004TBTDCRanges_v1_cff::endRun, fillDescriptions(), photonIsolationHIProducer_cfi::hbhe, singleTopDQM_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 289 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_, PDWG_DiPhoton_SD_cff::triggerEvent, trigger::TriggerL1CenJet, trigger::TriggerL1ForJet, trigger::TriggerL1TauJet, L1TEGammaOffline_cfi::triggerNames, edm::TriggerNames::triggerNames(), edm::Event::triggerNames(), triggerResults, validateGeometry_cfg::valid, 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 485 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, LEDCalibrationChannels::ieta, 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_, duplicaterechits_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 582 of file AlCaIsoTracksProducer.cc.

References DEFINE_FWK_MODULE, AlCaHLTBitMon_ParallelJobs::p, and DiDispStaMuonMonitor_cfi::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();
     }
   }
 }