Inheritance diagram for AlCaIsoTracksProducer:

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

void	endStream () override

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

	~AlCaIsoTracksProducer () override=default

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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

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

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

static std::unique_ptr< alCaIsoTracksProducer::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 > const &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::ESGetToken< CaloGeometry, CaloGeometryRecord >	tok_geom_

edm::EDGetTokenT< HBHERecHitCollection >	tok_hbhe_

edm::EDGetTokenT< trigger::TriggerFilterObjectWithRefs >	tok_hltGT_

edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	tok_magField_

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< alCaIsoTracksProducer::Counters > >
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 86 of file AlCaIsoTracksProducer.cc.

Constructor & Destructor Documentation

◆ AlCaIsoTracksProducer()

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

explicit

Definition at line 150 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_);
   // for event setup
   tok_geom_ = esConsumes<CaloGeometry, CaloGeometryRecord, edm::Transition::BeginRun>();
   tok_magField_ = esConsumes<MagneticField, IdealMagneticFieldRecord, edm::Transition::BeginRun>();
 
   edm::LogVerbatim("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::LogVerbatim("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::LogVerbatim("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::~AlCaIsoTracksProducer ( )

overridedefault

Member Function Documentation

◆ beginRun()

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

overrideprivate

Definition at line 463 of file AlCaIsoTracksProducer.cc.

References bField, geo, edm::EventSetup::getData(), hltConfig_, HLTConfigProvider::init(), nRun_, processName_, edm::RunBase::run(), tok_geom_, and tok_magField_.

                                                                                     {
   bool changed(false);
   edm::LogVerbatim("HcalIsoTrack") << "Run[" << nRun_ << "] " << iRun.run() << " hltconfig.init "
                                    << hltConfig_.init(iRun, iSetup, processName_, changed);
 
   bField = &(iSetup.getData(tok_magField_));
   geo = &(iSetup.getData(tok_geom_));
 }

◆ endRun()

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

overrideprivate

Definition at line 472 of file AlCaIsoTracksProducer.cc.

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

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

◆ endStream()

void AlCaIsoTracksProducer::endStream ( )

override

Definition at line 452 of file AlCaIsoTracksProducer.cc.

References nAll_, nGood_, and nRange_.

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

◆ fillDescriptions()

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

static

Definition at line 249 of file AlCaIsoTracksProducer.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, ProducerED_cfi::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);
 }

◆ globalEndJob()

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

static

Definition at line 458 of file AlCaIsoTracksProducer.cc.

References submitPVResolutionJobs::count.

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

◆ initializeGlobalCache()

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

inlinestatic

Definition at line 91 of file AlCaIsoTracksProducer.cc.

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

◆ produce()

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

override

Definition at line 293 of file AlCaIsoTracksProducer.cc.

References photonIsolationHIProducer_cfi::hbhe, iEvent, edm::InputTag::instance(), edm::InputTag::label(), labelEB_, labelEE_, labelGenTrack_, labelHBHE_, labelIsoTk_, labelRecVtx_, labelTriggerEvent_, labelTriggerResults_, eostools::move(), nAll_, nGood_, nRange_, preScale_, pTrackHigh_, pTrackLow_, 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, triggerResults, validateGeometry_cfg::valid, L1BJetProducer_cff::vtx, x, y, and z.

                                                                                  {
   nAll_++;
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("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;
   auto const& triggerEventHandle = iEvent.getHandle(tok_trigEvt_);
   if (!triggerEventHandle.isValid()) {
     edm::LogWarning("HcalIsoTrack") << "Cannot access the collection " << labelTriggerEvent_;
     valid = false;
   }
   auto const& triggerResults = iEvent.getHandle(tok_trigRes_);
   if (!triggerResults.isValid()) {
     edm::LogWarning("HcalIsoTrack") << "Cannot access the collection " << labelTriggerResults_;
     valid = false;
   }
 
   auto trkCollection = iEvent.getHandle(tok_genTrack_);
   if (!trkCollection.isValid()) {
     edm::LogWarning("HcalIsoTrack") << "Cannot access the collection " << labelGenTrack_;
     valid = false;
   }
 
   auto const& recVtxs = iEvent.getHandle(tok_recVtx_);
   if (!recVtxs.isValid()) {
     edm::LogWarning("HcalIsoTrack") << "Cannot access the collection " << labelGenTrack_;
     valid = false;
   }
 
   auto const& beamSpotH = iEvent.getHandle(tok_bs_);
   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 EDM_ML_DEBUG
   edm::LogVerbatim("HcalIsoTrack") << "Primary Vertex " << leadPV;
 #endif
 
   auto barrelRecHitsHandle = iEvent.getHandle(tok_EB_);
   if (!barrelRecHitsHandle.isValid()) {
     edm::LogWarning("HcalIsoTrack") << "Cannot access the collection " << labelEB_;
     valid = false;
   }
   auto endcapRecHitsHandle = iEvent.getHandle(tok_EE_);
   if (!endcapRecHitsHandle.isValid()) {
     edm::LogWarning("HcalIsoTrack") << "Cannot access the collection " << labelEE_;
     valid = false;
   }
   auto hbhe = iEvent.getHandle(tok_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);
   auto const& l1trigobj = iEvent.getHandle(tok_hltGT_);
 
   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 EDM_ML_DEBUG
       edm::LogVerbatim("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());
 }

◆ select()

reco::HcalIsolatedTrackCandidateCollection * AlCaIsoTracksProducer::select	(	edm::Handle< edm::TriggerResults > const &	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 477 of file AlCaIsoTracksProducer.cc.

References a_charIsoR_, a_mipR_, bField, spr::chargeIsolationCone(), hcalRecHitTable_cff::detId, spr::eCone_ecal(), eEcalMax_, eIsolate_, reco::TrackBase::eta(), JetChargeProducer_cfi::exp, spr::find(), geo, spr::goodTrack(), ValidationMatrix::hlt, mps_fire::i, hcalRecHitTable_cff::ieta, maxRestrictionP_, beamSpotPI::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(), slopeRestrictionP_, theTrackQuality_, JetHT_cfg::trackCollection, triggerResults, and trigNames_.

Referenced by produce().

                   {
   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::LogVerbatim("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);
   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 EDM_ML_DEBUG
     edm::LogVerbatim("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 EDM_ML_DEBUG
     edm::LogVerbatim("HcalIsoTrack") << "qltyFlag|okECAL|okHCAL : " << qltyFlag << "|" << trkDetItr->okECAL << "|"
                                      << trkDetItr->okHCAL;
 #endif
     if (qltyFlag && trkDetItr->okECAL && trkDetItr->okHCAL) {
       double t_p = pTrack->p();
       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 EDM_ML_DEBUG
       edm::LogVerbatim("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;
 }

◆ setPtEtaPhi()

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

private

Definition at line 573 of file AlCaIsoTracksProducer.cc.

References 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();
     }
   }
 }