IsolatedPixelTrackCandidateL1TProducer.cc

Go to the documentation of this file.

#include <vector>
#include <memory>
#include <algorithm>
#include <cmath>

// Class header file
#include "Calibration/HcalIsolatedTrackReco/interface/IsolatedPixelTrackCandidateL1TProducer.h"
#include "DataFormats/HcalIsolatedTrack/interface/IsolatedPixelTrackCandidateFwd.h"
// Framework
#include "DataFormats/Common/interface/Handle.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/ESTransientHandle.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
#include "FWCore/Utilities/interface/Exception.h"
#include "FWCore/Utilities/interface/transform.h"
//

// Math
#include "Math/GenVector/VectorUtil.h"
#include "Math/GenVector/PxPyPzE4D.h"
#include "DataFormats/Math/interface/deltaR.h"

#include "Geometry/Records/interface/IdealGeometryRecord.h"
#include "DetectorDescription/Core/interface/DDLogicalPart.h"
#include "DetectorDescription/Core/interface/DDSolid.h"

//magF
#include "MagneticField/Engine/interface/MagneticField.h"
#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
#include "MagneticField/VolumeBasedEngine/interface/VolumeBasedMagneticField.h"

//for ECAL geometry
#include "Geometry/EcalAlgo/interface/EcalBarrelGeometry.h"
#include "Geometry/EcalAlgo/interface/EcalEndcapGeometry.h"
#include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h"
#include "Geometry/CaloGeometry/interface/CaloGeometry.h"
#include "Geometry/Records/interface/CaloGeometryRecord.h"

IsolatedPixelTrackCandidateL1TProducer::IsolatedPixelTrackCandidateL1TProducer(const edm::ParameterSet& config)
    : 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>();
}

IsolatedPixelTrackCandidateL1TProducer::~IsolatedPixelTrackCandidateL1TProducer() {}

void IsolatedPixelTrackCandidateL1TProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
  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);
}

void IsolatedPixelTrackCandidateL1TProducer::beginRun(const edm::Run& run, const edm::EventSetup& theEventSetup) {
  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();
  edm::LogVerbatim("IsoTrack") << "rEB " << rEB_ << " zEE " << zEE_ << " B " << bfVal_ << std::endl;
}

void IsolatedPixelTrackCandidateL1TProducer::produce(edm::Event& theEvent, const edm::EventSetup& theEventSetup) {
  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();
    }
  }
  edm::LogVerbatim("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;
    }
    edm::LogVerbatim("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());
    edm::LogVerbatim("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
    edm::LogVerbatim("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);
    edm::LogVerbatim("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++;
    }
  }
  edm::LogVerbatim("IsoTrack") << "Number of Isolated Track " << ntr << "\n";
  // put the product in the event
  theEvent.put(std::move(trackCollection));
}

double IsolatedPixelTrackCandidateL1TProducer::getDistInCM(double eta1, double phi1, double eta2, double phi2) {
  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;
}

std::pair<double, double> IsolatedPixelTrackCandidateL1TProducer::GetEtaPhiAtEcal(
    double etaIP, double phiIP, double pT, int charge, double vtxZ) {
  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;
}