#include <IsolatedPixelTrackCandidateL1TProducer.h>

Inheritance diagram for IsolatedPixelTrackCandidateL1TProducer:

Classes
struct	seedAtEC

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

double	getDistInCM (double eta1, double phi1, double eta2, double phi2)

std::pair< double, double >	GetEtaPhiAtEcal (double etaIP, double phiIP, double pT, int charge, double vtxZ)

	IsolatedPixelTrackCandidateL1TProducer (const edm::ParameterSet &ps)

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

	~IsolatedPixelTrackCandidateL1TProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	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)

Private Attributes
const std::string	bfield_

double	bfVal_

const double	ebEtaBoundary_

const double	maxPForIsolationValue_

const double	minPTrackValue_

const double	pixelIsolationConeSizeAtEC_

const double	prelimCone_

double	rEB_

const double	tauAssocCone_

const double	tauUnbiasCone_

const edm::EDGetTokenT< trigger::TriggerFilterObjectWithRefs >	tok_hlt_

const edm::EDGetTokenT< l1t::TauBxCollection >	tok_l1_

const edm::EDGetTokenT< reco::VertexCollection >	tok_vert_

const std::vector< edm::EDGetTokenT< reco::TrackCollection > >	toks_pix_

const double	vtxCutIsol_

const double	vtxCutSeed_

double	zEE_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Definition at line 45 of file IsolatedPixelTrackCandidateL1TProducer.h.

Constructor & Destructor Documentation

◆ IsolatedPixelTrackCandidateL1TProducer()

IsolatedPixelTrackCandidateL1TProducer::IsolatedPixelTrackCandidateL1TProducer ( const edm::ParameterSet & ps )

Definition at line 35 of file IsolatedPixelTrackCandidateL1TProducer.cc.

     : tok_hlt_(consumes<trigger::TriggerFilterObjectWithRefs>(config.getParameter<edm::InputTag>("L1GTSeedLabel"))),
       tok_l1_(consumes<l1t::TauBxCollection>(config.getParameter<edm::InputTag>("L1eTauJetsSource"))),
       tok_vert_(consumes<reco::VertexCollection>(config.getParameter<edm::InputTag>("VertexLabel"))),
       toks_pix_(
           edm::vector_transform(config.getParameter<std::vector<edm::InputTag> >("PixelTracksSources"),
                                 [this](edm::InputTag const& tag) { return consumes<reco::TrackCollection>(tag); })),
       bfield_(config.getParameter<std::string>("MagFieldRecordName")),
       prelimCone_(config.getParameter<double>("ExtrapolationConeSize")),
       pixelIsolationConeSizeAtEC_(config.getParameter<double>("PixelIsolationConeSizeAtEC")),
       vtxCutSeed_(config.getParameter<double>("MaxVtxDXYSeed")),
       vtxCutIsol_(config.getParameter<double>("MaxVtxDXYIsol")),
       tauAssocCone_(config.getParameter<double>("tauAssociationCone")),
       tauUnbiasCone_(config.getParameter<double>("tauUnbiasCone")),
       minPTrackValue_(config.getParameter<double>("minPTrack")),
       maxPForIsolationValue_(config.getParameter<double>("maxPTrackForIsolation")),
       ebEtaBoundary_(config.getParameter<double>("EBEtaBoundary")),
       rEB_(-1),
       zEE_(-1),
       bfVal_(0) {
   // Register the product
   produces<reco::IsolatedPixelTrackCandidateCollection>();
 }

References GlobalPosition_Frontier_DevDB_cff::tag.

◆ ~IsolatedPixelTrackCandidateL1TProducer()

IsolatedPixelTrackCandidateL1TProducer::~IsolatedPixelTrackCandidateL1TProducer ( )

override

Definition at line 59 of file IsolatedPixelTrackCandidateL1TProducer.cc.

59 {}

Member Function Documentation

◆ beginRun()

void IsolatedPixelTrackCandidateL1TProducer::beginRun	(	const edm::Run &	run,
		const edm::EventSetup &	theEventSetup
	)

override

Definition at line 81 of file IsolatedPixelTrackCandidateL1TProducer.cc.

                                                                                                            {
   edm::ESHandle<CaloGeometry> pG;
   theEventSetup.get<CaloGeometryRecord>().get(pG);
  
   const double rad(dynamic_cast<const EcalBarrelGeometry*>(pG->getSubdetectorGeometry(DetId::Ecal, EcalBarrel))
                        ->avgRadiusXYFrontFaceCenter());
   const double zz(dynamic_cast<const EcalEndcapGeometry*>(pG->getSubdetectorGeometry(DetId::Ecal, EcalEndcap))
                       ->avgAbsZFrontFaceCenter());
  
   rEB_ = rad;
   zEE_ = zz;
  
   edm::ESHandle<MagneticField> vbfField;
   theEventSetup.get<IdealMagneticFieldRecord>().get(vbfField);
   const VolumeBasedMagneticField* vbfCPtr = dynamic_cast<const VolumeBasedMagneticField*>(&(*vbfField));
   GlobalVector BField = vbfCPtr->inTesla(GlobalPoint(0, 0, 0));
   bfVal_ = BField.mag();
   LogTrace("IsoTrack") << "rEB " << rEB_ << " zEE " << zEE_ << " B " << bfVal_ << std::endl;
 }

References TrackTriggerSetup_cfi::BField, bfVal_, DetId::Ecal, EcalBarrel, EcalEndcap, edm::EventSetup::get(), get, CaloGeometry::getSubdetectorGeometry(), VolumeBasedMagneticField::inTesla(), LogTrace, rEB_, zEE_, and geometryCSVtoXML::zz.

◆ fillDescriptions()

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

static

Definition at line 61 of file IsolatedPixelTrackCandidateL1TProducer.cc.

                                                                                                         {
   edm::ParameterSetDescription desc;
   std::vector<edm::InputTag> tracksrc = {edm::InputTag("hltPixelTracks")};
   desc.add<edm::InputTag>("L1eTauJetsSource", edm::InputTag("hltGtStage2Digis", "Tau"));
   desc.add<double>("tauAssociationCone", 0.0);
   desc.add<double>("tauUnbiasCone", 1.2);
   desc.add<std::vector<edm::InputTag> >("PixelTracksSources", tracksrc);
   desc.add<double>("ExtrapolationConeSize", 1.0);
   desc.add<double>("PixelIsolationConeSizeAtEC", 40);
   desc.add<edm::InputTag>("L1GTSeedLabel", edm::InputTag("hltL1sV0SingleJet60"));
   desc.add<double>("MaxVtxDXYSeed", 101.0);
   desc.add<double>("MaxVtxDXYIsol", 101.0);
   desc.add<edm::InputTag>("VertexLabel", edm::InputTag("hltTrimmedPixelVertices"));
   desc.add<std::string>("MagFieldRecordName", "VolumeBasedMagneticField");
   desc.add<double>("minPTrack", 5.0);
   desc.add<double>("maxPTrackForIsolation", 3.0);
   desc.add<double>("EBEtaBoundary", 1.479);
   descriptions.add("isolPixelTrackProdL1T", desc);
 }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), HLT_2018_cff::InputTag, AlCaHLTBitMon_QueryRunRegistry::string, and SiPixelMonitorTrack_cfi::tracksrc.

◆ getDistInCM()

double IsolatedPixelTrackCandidateL1TProducer::getDistInCM	(	double	eta1,
		double	phi1,
		double	eta2,
		double	phi2
	)

Definition at line 281 of file IsolatedPixelTrackCandidateL1TProducer.cc.

                                                                                                              {
   double Rec;
   double theta1 = 2 * atan(exp(-eta1));
   double theta2 = 2 * atan(exp(-eta2));
   if (std::abs(eta1) < 1.479)
     Rec = rEB_;  //radius of ECAL barrel
   else if (std::abs(eta1) > 1.479 && std::abs(eta1) < 7.0)
     Rec = tan(theta1) * zEE_;  //distance from IP to ECAL endcap
   else
     return 1000;
  
   //|vect| times tg of acos(scalar product)
   double angle =
       acos((sin(theta1) * sin(theta2) * (sin(phi1) * sin(phi2) + cos(phi1) * cos(phi2)) + cos(theta1) * cos(theta2)));
   if (angle < M_PI_2)
     return std::abs((Rec / sin(theta1)) * tan(angle));
   else
     return 1000;
 }

References funct::abs(), angle(), funct::cos(), HLT_2018_cff::eta1, HLT_2018_cff::eta2, JetChargeProducer_cfi::exp, M_PI_2, rEB_, funct::sin(), funct::tan(), and zEE_.

Referenced by produce().

◆ GetEtaPhiAtEcal()

std::pair< double, double > IsolatedPixelTrackCandidateL1TProducer::GetEtaPhiAtEcal	(	double	etaIP,
		double	phiIP,
		double	pT,
		int	charge,
		double	vtxZ
	)

Definition at line 301 of file IsolatedPixelTrackCandidateL1TProducer.cc.

                                                                     {
   double deltaPhi = 0;
   double etaEC = 100;
   double phiEC = 100;
  
   double Rcurv = 9999999;
   if (bfVal_ != 0)
     Rcurv = pT * 33.3 * 100 / (bfVal_ * 10);  //r(m)=pT(GeV)*33.3/B(kG)
  
   double ecDist = zEE_;  //distance to ECAL andcap from IP (cm), 317 - ecal (not preshower), preshower -300
   double ecRad = rEB_;   //radius of ECAL barrel (cm)
   double theta = 2 * atan(exp(-etaIP));
   double zNew = 0;
   if (theta > M_PI_2)
     theta = M_PI - theta;
   if (std::abs(etaIP) < ebEtaBoundary_) {
     if ((0.5 * ecRad / Rcurv) > 1) {
       etaEC = 10000;
       deltaPhi = 0;
     } else {
       deltaPhi = -charge * asin(0.5 * ecRad / Rcurv);
       double alpha1 = 2 * asin(0.5 * ecRad / Rcurv);
       double z = ecRad / tan(theta);
       if (etaIP > 0)
         zNew = z * (Rcurv * alpha1) / ecRad + vtxZ;  //new z-coordinate of track
       else
         zNew = -z * (Rcurv * alpha1) / ecRad + vtxZ;  //new z-coordinate of track
       double zAbs = std::abs(zNew);
       if (zAbs < ecDist) {
         etaEC = -log(tan(0.5 * atan(ecRad / zAbs)));
         deltaPhi = -charge * asin(0.5 * ecRad / Rcurv);
       }
       if (zAbs > ecDist) {
         zAbs = (std::abs(etaIP) / etaIP) * ecDist;
         double Zflight = std::abs(zAbs - vtxZ);
         double alpha = (Zflight * ecRad) / (z * Rcurv);
         double Rec = 2 * Rcurv * sin(alpha / 2);
         deltaPhi = -charge * alpha / 2;
         etaEC = -log(tan(0.5 * atan(Rec / ecDist)));
       }
     }
   } else {
     zNew = (std::abs(etaIP) / etaIP) * ecDist;
     double Zflight = std::abs(zNew - vtxZ);
     double Rvirt = std::abs(Zflight * tan(theta));
     double Rec = 2 * Rcurv * sin(Rvirt / (2 * Rcurv));
     deltaPhi = -(charge) * (Rvirt / (2 * Rcurv));
     etaEC = -log(tan(0.5 * atan(Rec / ecDist)));
   }
  
   if (zNew < 0)
     etaEC = -etaEC;
   phiEC = phiIP + deltaPhi;
  
   if (phiEC < -M_PI)
     phiEC += M_2_PI;
   if (phiEC > M_PI)
     phiEC -= M_2_PI;
  
   std::pair<double, double> retVal(etaEC, phiEC);
   return retVal;
 }

References funct::abs(), zMuMuMuonUserData::alpha, bfVal_, ALCARECOTkAlJpsiMuMu_cff::charge, SiPixelRawToDigiRegional_cfi::deltaPhi, ebEtaBoundary_, JetChargeProducer_cfi::exp, dqm-mbProfile::log, M_PI, M_PI_2, PVValHelper::pT, rEB_, funct::sin(), funct::tan(), theta(), z, and zEE_.

Referenced by produce().

◆ produce()

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

override

Definition at line 101 of file IsolatedPixelTrackCandidateL1TProducer.cc.

                                                                                                            {
   auto trackCollection = std::make_unique<reco::IsolatedPixelTrackCandidateCollection>();
  
   //create vector of refs from input collections
   std::vector<reco::TrackRef> pixelTrackRefs;
  
   for (unsigned int iPix = 0; iPix < toks_pix_.size(); iPix++) {
     edm::Handle<reco::TrackCollection> iPixCol;
     theEvent.getByToken(toks_pix_[iPix], iPixCol);
     for (reco::TrackCollection::const_iterator pit = iPixCol->begin(); pit != iPixCol->end(); pit++) {
       pixelTrackRefs.push_back(reco::TrackRef(iPixCol, pit - iPixCol->begin()));
     }
   }
  
   edm::Handle<l1t::TauBxCollection> l1eTauJets;
   theEvent.getByToken(tok_l1_, l1eTauJets);
  
   edm::Handle<reco::VertexCollection> pVert;
   theEvent.getByToken(tok_vert_, pVert);
  
   double ptTriggered = -10;
   double etaTriggered = -100;
   double phiTriggered = -100;
  
   edm::Handle<trigger::TriggerFilterObjectWithRefs> l1trigobj;
   theEvent.getByToken(tok_hlt_, l1trigobj);
  
   std::vector<edm::Ref<l1t::TauBxCollection> > l1tauobjref;
   std::vector<edm::Ref<l1t::JetBxCollection> > l1jetobjref;
  
   //  l1trigobj->getObjects(trigger::TriggerTau, l1tauobjref);
   l1trigobj->getObjects(trigger::TriggerL1Tau, l1tauobjref);
   //  l1trigobj->getObjects(trigger::TriggerJet, l1jetobjref);
   l1trigobj->getObjects(trigger::TriggerL1Jet, l1jetobjref);
  
   for (auto p : l1tauobjref) {
     if (p->pt() > ptTriggered) {
       ptTriggered = p->pt();
       phiTriggered = p->phi();
       etaTriggered = p->eta();
     }
   }
   for (auto p : l1jetobjref) {
     if (p->pt() > ptTriggered) {
       ptTriggered = p->pt();
       phiTriggered = p->phi();
       etaTriggered = p->eta();
     }
   }
   LogTrace("IsoTrack") << "Sizes " << l1tauobjref.size() << ":" << l1jetobjref.size() << " Trig " << ptTriggered << ":"
                        << etaTriggered << ":" << phiTriggered << std::endl;
  
   double drMaxL1Track_ = tauAssocCone_;
   int ntr = 0;
   std::vector<seedAtEC> VecSeedsatEC;
   //loop to select isolated tracks
   for (unsigned iS = 0; iS < pixelTrackRefs.size(); iS++) {
     bool vtxMatch = false;
     //associate to vertex (in Z)
     reco::VertexCollection::const_iterator vitSel;
     double minDZ = 1000;
     bool found(false);
     for (reco::VertexCollection::const_iterator vit = pVert->begin(); vit != pVert->end(); vit++) {
       if (std::abs(pixelTrackRefs[iS]->dz(vit->position())) < minDZ) {
         minDZ = std::abs(pixelTrackRefs[iS]->dz(vit->position()));
         vitSel = vit;
         found = true;
       }
     }
     //cut on dYX:
     if (found) {
       if (std::abs(pixelTrackRefs[iS]->dxy(vitSel->position())) < vtxCutSeed_)
         vtxMatch = true;
     } else {
       vtxMatch = true;
     }
     LogTrace("IsoTrack") << "minZD " << minDZ << " Found " << found << ":" << vtxMatch << std::endl;
  
     //select tracks not matched to triggered L1 jet
     double R = reco::deltaR(etaTriggered, phiTriggered, pixelTrackRefs[iS]->eta(), pixelTrackRefs[iS]->phi());
     LogTrace("IsoTrack") << "Distance to L1 " << R << ":" << tauUnbiasCone_ << " Result " << (R < tauUnbiasCone_)
                          << std::endl;
     if (R < tauUnbiasCone_)
       continue;
  
     //check taujet matching
     bool tmatch = false;
     l1t::TauBxCollection::const_iterator selj;
     for (l1t::TauBxCollection::const_iterator tj = l1eTauJets->begin(); tj != l1eTauJets->end(); tj++) {
       if (reco::deltaR(pixelTrackRefs[iS]->momentum().eta(),
                        pixelTrackRefs[iS]->momentum().phi(),
                        tj->momentum().eta(),
                        tj->momentum().phi()) > drMaxL1Track_)
         continue;
       selj = tj;
       tmatch = true;
     }  //loop over L1 tau
     LogTrace("IsoTrack") << "tMatch " << tmatch << std::endl;
  
     //propagate seed track to ECAL surface:
     std::pair<double, double> seedCooAtEC;
     // in case vertex is found:
     if (found)
       seedCooAtEC = GetEtaPhiAtEcal(pixelTrackRefs[iS]->eta(),
                                     pixelTrackRefs[iS]->phi(),
                                     pixelTrackRefs[iS]->pt(),
                                     pixelTrackRefs[iS]->charge(),
                                     vitSel->z());
     //in case vertex is not found:
     else
       seedCooAtEC = GetEtaPhiAtEcal(pixelTrackRefs[iS]->eta(),
                                     pixelTrackRefs[iS]->phi(),
                                     pixelTrackRefs[iS]->pt(),
                                     pixelTrackRefs[iS]->charge(),
                                     0);
     seedAtEC seed(iS, (tmatch || vtxMatch), seedCooAtEC.first, seedCooAtEC.second);
     VecSeedsatEC.push_back(seed);
     LogTrace("IsoTrack") << "Seed " << seedCooAtEC.first << seedCooAtEC.second << std::endl;
   }
   for (unsigned int i = 0; i < VecSeedsatEC.size(); i++) {
     unsigned int iSeed = VecSeedsatEC[i].index;
     if (!VecSeedsatEC[i].ok)
       continue;
     if (pixelTrackRefs[iSeed]->p() < minPTrackValue_)
       continue;
     l1t::TauBxCollection::const_iterator selj;
     for (l1t::TauBxCollection::const_iterator tj = l1eTauJets->begin(); tj != l1eTauJets->end(); tj++) {
       if (reco::deltaR(pixelTrackRefs[iSeed]->momentum().eta(),
                        pixelTrackRefs[iSeed]->momentum().phi(),
                        tj->momentum().eta(),
                        tj->momentum().phi()) > drMaxL1Track_)
         continue;
       selj = tj;
     }  //loop over L1 tau
     double maxP = 0;
     double sumP = 0;
     for (unsigned int j = 0; j < VecSeedsatEC.size(); j++) {
       if (i == j)
         continue;
       unsigned int iSurr = VecSeedsatEC[j].index;
       //define preliminary cone around seed track impact point from which tracks will be extrapolated:
       if (reco::deltaR(pixelTrackRefs[iSeed]->eta(),
                        pixelTrackRefs[iSeed]->phi(),
                        pixelTrackRefs[iSurr]->eta(),
                        pixelTrackRefs[iSurr]->phi()) > prelimCone_)
         continue;
       double minDZ2(1000);
       bool found(false);
       reco::VertexCollection::const_iterator vitSel2;
       for (reco::VertexCollection::const_iterator vit = pVert->begin(); vit != pVert->end(); vit++) {
         if (std::abs(pixelTrackRefs[iSurr]->dz(vit->position())) < minDZ2) {
           minDZ2 = std::abs(pixelTrackRefs[iSurr]->dz(vit->position()));
           vitSel2 = vit;
           found = true;
         }
       }
       //cut ot dXY:
       if (found && std::abs(pixelTrackRefs[iSurr]->dxy(vitSel2->position())) > vtxCutIsol_)
         continue;
       //calculate distance at ECAL surface and update isolation:
       if (getDistInCM(VecSeedsatEC[i].eta, VecSeedsatEC[i].phi, VecSeedsatEC[j].eta, VecSeedsatEC[j].phi) <
           pixelIsolationConeSizeAtEC_) {
         sumP += pixelTrackRefs[iSurr]->p();
         if (pixelTrackRefs[iSurr]->p() > maxP)
           maxP = pixelTrackRefs[iSurr]->p();
       }
     }
     if (maxP < maxPForIsolationValue_) {
       reco::IsolatedPixelTrackCandidate newCandidate(
           pixelTrackRefs[iSeed], l1t::TauRef(l1eTauJets, selj - l1eTauJets->begin()), maxP, sumP);
       newCandidate.setEtaPhiEcal(VecSeedsatEC[i].eta, VecSeedsatEC[i].phi);
       trackCollection->push_back(newCandidate);
       ntr++;
     }
   }
   LogTrace("IsoTrack") << "Number of Isolated Track " << ntr << "\n";
   // put the product in the event
   theEvent.put(std::move(trackCollection));
 }