MuonMETAlgo Class Reference

#include <MuonMETAlgo.h>

Public Member Functions
void	GetMuDepDeltas (const reco::Muon *inputMuon, TrackDetMatchInfo &info, bool useTrackAssociatorPositions, bool useRecHits, bool useHO, double towerEtThreshold, double &deltax, double &deltay, double Bfield)
reco::CaloMET	makeMET (const reco::CaloMET &fMet, double fSumEt, const std::vector< CorrMETData > &fCorrections, const reco::MET::LorentzVector &)
reco::MET	makeMET (const reco::MET &, double fSumEt, const std::vector< CorrMETData > &fCorrections, const reco::MET::LorentzVector &fP4)
	MuonMETAlgo ()
template<class T >
void	MuonMETAlgo_run (const edm::View< reco::Muon > &inputMuons, const edm::ValueMap< reco::MuonMETCorrectionData > &vm_muCorrData, const edm::View< T > &v_uncorMET, std::vector< T > *v_corMET)
virtual void	run (const edm::View< reco::Muon > &inputMuons, const edm::ValueMap< reco::MuonMETCorrectionData > &vm_muCorrData, const edm::View< reco::MET > &uncorMET, reco::METCollection *corMET)
virtual void	run (const edm::View< reco::Muon > &inputMuons, const edm::ValueMap< reco::MuonMETCorrectionData > &vm_muCorrData, const edm::View< reco::CaloMET > &uncorMET, reco::CaloMETCollection *corMET)
virtual	~MuonMETAlgo ()

Static Public Member Functions
static void	correctMETforMuon (double &deltax, double &deltay, double bfield, int muonCharge, const math::XYZTLorentzVector &muonP4, const math::XYZPoint &muonVertex, MuonMETInfo &)

Detailed Description

Description: Correct MET for muons in the events.

Definition at line 39 of file MuonMETAlgo.h.

Constructor & Destructor Documentation

MuonMETAlgo::MuonMETAlgo ( )

inline

Definition at line 41 of file MuonMETAlgo.h.

{}

virtual MuonMETAlgo::~MuonMETAlgo ( )

inlinevirtual

Definition at line 42 of file MuonMETAlgo.h.

References correctMETforMuon(), GetMuDepDeltas(), info(), calomuons_cfi::inputMuons, makeMET(), MuonMETAlgo_run(), run(), distMuonMETValueMapProducer_cff::towerEtThreshold, PDWG_EXOHSCP_cff::useHO, ExoticaDQM_cfi::useRecHits, and distMuonMETValueMapProducer_cff::useTrackAssociatorPositions.

{}

Member Function Documentation

void MuonMETAlgo::correctMETforMuon ( double &  deltax, double &  deltay, double  bfield, int  muonCharge, const math::XYZTLorentzVector &  muonP4, const math::XYZPoint &  muonVertex, MuonMETInfo &  muonMETInfo  )

static

Definition at line 188 of file MuonMETAlgo.cc.

References funct::abs(), funct::cos(), MillePedeFileConverter_cfg::e, MuonMETInfo::ecalE, egammaTools::ecalPhi(), MuonMETInfo::ecalPos, MuonMETInfo::hcalE, MuonMETInfo::hcalPos, MuonMETInfo::hoE, MuonMETInfo::hoPos, calomuons_cfi::inputMuons, dqm-mbProfile::log, Pi, funct::pow(), run(), funct::sin(), mathSSE::sqrt(), groupFilesInBlocks::temp, MuonMETInfo::useAverage, MuonMETInfo::useHO, and MuonMETInfo::useTkAssociatorPositions.

Referenced by ~MuonMETAlgo().

                                                              {
  double mu_p = muonP4.P();
  double mu_pt = muonP4.Pt();
  double mu_phi = muonP4.Phi();
  double mu_eta = muonP4.Eta();
  double mu_vz = muonVertex.z() / 100.;
  double mu_pz = muonP4.Pz();

  double ecalPhi, ecalTheta;
  double hcalPhi, hcalTheta;
  double hoPhi, hoTheta;

  //should always be false for FWLite
  //unless you want to supply co-ordinates at
  //the calorimeter sub-detectors yourself
  if (muonMETInfo.useTkAssociatorPositions) {
    ecalPhi = muonMETInfo.ecalPos.Phi();
    ecalTheta = muonMETInfo.ecalPos.Theta();
    hcalPhi = muonMETInfo.hcalPos.Phi();
    hcalTheta = muonMETInfo.hcalPos.Theta();
    hoPhi = muonMETInfo.hoPos.Phi();
    hoTheta = muonMETInfo.hoPos.Theta();
  } else {
    /*
      use the analytical solution for the
      intersection of a helix with a cylinder
      to find the positions of the muon
      at the various calo surfaces
    */

    //radii of subdetectors in meters
    double rEcal = 1.290;
    double rHcal = 1.9;
    double rHo = 3.82;
    if (abs(mu_eta) > 0.3)
      rHo = 4.07;
    //distance from the center of detector to face of Ecal
    double zFaceEcal = 3.209;
    if (mu_eta < 0)
      zFaceEcal = -1 * zFaceEcal;
    //distance from the center of detector to face of Hcal
    double zFaceHcal = 3.88;
    if (mu_eta < 0)
      zFaceHcal = -1 * zFaceHcal;

    //now we have to get Phi
    //bending radius of the muon (units are meters)
    double bendr = mu_pt * 1000 / (300 * bfield);

    double tb_ecal = TMath::ACos(1 - rEcal * rEcal / (2 * bendr * bendr));  //helix time interval parameter
    double tb_hcal = TMath::ACos(1 - rHcal * rHcal / (2 * bendr * bendr));  //helix time interval parameter
    double tb_ho = TMath::ACos(1 - rHo * rHo / (2 * bendr * bendr));        //helix time interval parameter
    double xEcal, yEcal, zEcal;
    double xHcal, yHcal, zHcal;
    double xHo, yHo, zHo;
    //Ecal
    //in the barrel and if not a looper
    if (fabs(mu_pz * bendr * tb_ecal / mu_pt + mu_vz) < fabs(zFaceEcal) && rEcal < 2 * bendr) {
      xEcal = bendr * (TMath::Sin(tb_ecal + mu_phi) - TMath::Sin(mu_phi));
      yEcal = bendr * (-TMath::Cos(tb_ecal + mu_phi) + TMath::Cos(mu_phi));
      zEcal = bendr * tb_ecal * mu_pz / mu_pt + mu_vz;
    } else {  //endcap
      if (mu_pz > 0) {
        double te_ecal = (fabs(zFaceEcal) - mu_vz) * mu_pt / (bendr * mu_pz);
        xEcal = bendr * (TMath::Sin(te_ecal + mu_phi) - TMath::Sin(mu_phi));
        yEcal = bendr * (-TMath::Cos(te_ecal + mu_phi) + TMath::Cos(mu_phi));
        zEcal = fabs(zFaceEcal);
      } else {
        double te_ecal = -(fabs(zFaceEcal) + mu_vz) * mu_pt / (bendr * mu_pz);
        xEcal = bendr * (TMath::Sin(te_ecal + mu_phi) - TMath::Sin(mu_phi));
        yEcal = bendr * (-TMath::Cos(te_ecal + mu_phi) + TMath::Cos(mu_phi));
        zEcal = -fabs(zFaceEcal);
      }
    }

    //Hcal
    if (fabs(mu_pz * bendr * tb_hcal / mu_pt + mu_vz) < fabs(zFaceHcal) && rEcal < 2 * bendr) {  //in the barrel
      xHcal = bendr * (TMath::Sin(tb_hcal + mu_phi) - TMath::Sin(mu_phi));
      yHcal = bendr * (-TMath::Cos(tb_hcal + mu_phi) + TMath::Cos(mu_phi));
      zHcal = bendr * tb_hcal * mu_pz / mu_pt + mu_vz;
    } else {  //endcap
      if (mu_pz > 0) {
        double te_hcal = (fabs(zFaceHcal) - mu_vz) * mu_pt / (bendr * mu_pz);
        xHcal = bendr * (TMath::Sin(te_hcal + mu_phi) - TMath::Sin(mu_phi));
        yHcal = bendr * (-TMath::Cos(te_hcal + mu_phi) + TMath::Cos(mu_phi));
        zHcal = fabs(zFaceHcal);
      } else {
        double te_hcal = -(fabs(zFaceHcal) + mu_vz) * mu_pt / (bendr * mu_pz);
        xHcal = bendr * (TMath::Sin(te_hcal + mu_phi) - TMath::Sin(mu_phi));
        yHcal = bendr * (-TMath::Cos(te_hcal + mu_phi) + TMath::Cos(mu_phi));
        zHcal = -fabs(zFaceHcal);
      }
    }

    //Ho - just the barrel
    xHo = bendr * (TMath::Sin(tb_ho + mu_phi) - TMath::Sin(mu_phi));
    yHo = bendr * (-TMath::Cos(tb_ho + mu_phi) + TMath::Cos(mu_phi));
    zHo = bendr * tb_ho * mu_pz / mu_pt + mu_vz;

    ecalTheta = TMath::ACos(zEcal / sqrt(pow(xEcal, 2) + pow(yEcal, 2) + pow(zEcal, 2)));
    ecalPhi = atan2(yEcal, xEcal);
    hcalTheta = TMath::ACos(zHcal / sqrt(pow(xHcal, 2) + pow(yHcal, 2) + pow(zHcal, 2)));
    hcalPhi = atan2(yHcal, xHcal);
    hoTheta = TMath::ACos(zHo / sqrt(pow(xHo, 2) + pow(yHo, 2) + pow(zHo, 2)));
    hoPhi = atan2(yHo, xHo);

    /*
      the above prescription is for right handed helicies only
      Positively charged muons trace a left handed helix
      so we correct for that 
    */
    if (muonCharge > 0) {
      //Ecal
      double dphi = mu_phi - ecalPhi;
      if (fabs(dphi) > TMath::Pi())
        dphi = 2 * TMath::Pi() - fabs(dphi);
      ecalPhi = mu_phi - fabs(dphi);
      if (fabs(ecalPhi) > TMath::Pi()) {
        double temp = 2 * TMath::Pi() - fabs(ecalPhi);
        ecalPhi = -1 * temp * ecalPhi / fabs(ecalPhi);
      }

      //Hcal
      dphi = mu_phi - hcalPhi;
      if (fabs(dphi) > TMath::Pi())
        dphi = 2 * TMath::Pi() - fabs(dphi);
      hcalPhi = mu_phi - fabs(dphi);
      if (fabs(hcalPhi) > TMath::Pi()) {
        double temp = 2 * TMath::Pi() - fabs(hcalPhi);
        hcalPhi = -1 * temp * hcalPhi / fabs(hcalPhi);
      }

      //Ho
      dphi = mu_phi - hoPhi;
      if (fabs(dphi) > TMath::Pi())
        dphi = 2 * TMath::Pi() - fabs(dphi);
      hoPhi = mu_phi - fabs(dphi);
      if (fabs(hoPhi) > TMath::Pi()) {
        double temp = 2 * TMath::Pi() - fabs(hoPhi);
        hoPhi = -1 * temp * hoPhi / fabs(hoPhi);
      }
    }
  }

  //for isolated muons
  if (!muonMETInfo.useAverage) {
    double mu_Ex = muonMETInfo.ecalE * sin(ecalTheta) * cos(ecalPhi) +
                   muonMETInfo.hcalE * sin(hcalTheta) * cos(hcalPhi) + muonMETInfo.hoE * sin(hoTheta) * cos(hoPhi);
    double mu_Ey = muonMETInfo.ecalE * sin(ecalTheta) * sin(ecalPhi) +
                   muonMETInfo.hcalE * sin(hcalTheta) * sin(hcalPhi) + muonMETInfo.hoE * sin(hoTheta) * sin(hoPhi);

    deltax += mu_Ex;
    deltay += mu_Ey;

  } else {  //non-isolated muons - derive the correction

    //dE/dx in matter for iron:
    //-(11.4 + 0.96*fabs(log(p0*2.8)) + 0.033*p0*(1.0 - pow(p0, -0.33)) )*1e-3
    //from http://cmslxr.fnal.gov/lxr/source/TrackPropagation/SteppingHelixPropagator/src/SteppingHelixPropagator.ccyes,
    //line ~1100
    //normalisation is at 50 GeV
    double dEdx_normalization = -(11.4 + 0.96 * fabs(log(50 * 2.8)) + 0.033 * 50 * (1.0 - pow(50, -0.33))) * 1e-3;
    double dEdx_numerator = -(11.4 + 0.96 * fabs(log(mu_p * 2.8)) + 0.033 * mu_p * (1.0 - pow(mu_p, -0.33))) * 1e-3;

    double temp = 0.0;

    if (muonMETInfo.useHO) {
      //for the Towers, with HO
      if (fabs(mu_eta) < 0.2)
        temp = 2.75 * (1 - 0.00003 * mu_p);
      if (fabs(mu_eta) > 0.2 && fabs(mu_eta) < 1.0)
        temp = (2.38 + 0.0144 * fabs(mu_eta)) * (1 - 0.0003 * mu_p);
      if (fabs(mu_eta) > 1.0 && fabs(mu_eta) < 1.3)
        temp = 7.413 - 5.12 * fabs(mu_eta);
      if (fabs(mu_eta) > 1.3)
        temp = 2.084 - 0.743 * fabs(mu_eta);
    } else {
      if (fabs(mu_eta) < 1.0)
        temp = 2.33 * (1 - 0.0004 * mu_p);
      if (fabs(mu_eta) > 1.0 && fabs(mu_eta) < 1.3)
        temp = (7.413 - 5.12 * fabs(mu_eta)) * (1 - 0.0003 * mu_p);
      if (fabs(mu_eta) > 1.3)
        temp = 2.084 - 0.743 * fabs(mu_eta);
    }

    double dep = temp * dEdx_normalization / dEdx_numerator;
    if (dep < 0.5)
      dep = 0;
    //use the average phi of the 3 subdetectors
    if (fabs(mu_eta) < 1.3) {
      deltax += dep * cos((ecalPhi + hcalPhi + hoPhi) / 3);
      deltay += dep * sin((ecalPhi + hcalPhi + hoPhi) / 3);
    } else {
      deltax += dep * cos((ecalPhi + hcalPhi) / 2);
      deltay += dep * cos((ecalPhi + hcalPhi) / 2);
    }
  }
}

void MuonMETAlgo::GetMuDepDeltas	(	const reco::Muon *	inputMuon,
		TrackDetMatchInfo &	info,
		bool	useTrackAssociatorPositions,
		bool	useRecHits,
		bool	useHO,
		double	towerEtThreshold,
		double &	deltax,
		double &	deltay,
		double	Bfield
	)

Definition at line 96 of file MuonMETAlgo.cc.

References reco::Muon::calEnergy(), reco::LeafCandidate::charge(), TrackDetMatchInfo::crossedTowers, MuonMETInfo::ecalE, MuonMETInfo::ecalPos, reco::MuonIsolation::emEt, reco::MuonEnergy::emS9, reco::Muon::globalTrack(), reco::MuonIsolation::hadEt, reco::MuonEnergy::hadS9, MuonMETInfo::hcalE, MuonMETInfo::hcalPos, MuonMETInfo::hoE, MuonMETInfo::hoPos, reco::MuonEnergy::hoS9, reco::Muon::innerTrack(), reco::Muon::isGEMMuon(), reco::Muon::isGlobalMuon(), reco::Muon::isIsolationValid(), reco::Muon::isME0Muon(), reco::Muon::isolationR03(), reco::Muon::isRPCMuon(), reco::Muon::isTrackerMuon(), reco::Muon::outerTrack(), reco::MuonIsolation::sumPt, TtFullHadEvtBuilder_cfi::sumPt, distMuonMETValueMapProducer_cff::towerEtThreshold, HLT_2018_cff::towers, TrackDetMatchInfo::trkGlobPosAtEcal, TrackDetMatchInfo::trkGlobPosAtHcal, TrackDetMatchInfo::trkGlobPosAtHO, MuonMETInfo::useAverage, MuonMETInfo::useHO, PDWG_EXOHSCP_cff::useHO, MuonMETInfo::useTkAssociatorPositions, distMuonMETValueMapProducer_cff::useTrackAssociatorPositions, and reco::LeafCandidate::vertex().

Referenced by cms::MuonMETValueMapProducer::determine_deltax_deltay(), and ~MuonMETAlgo().

                                                {
  bool useAverage = false;
  //decide whether or not we want to correct on average based
  //on isolation information from the muon
  double sumPt = inputMuon->isIsolationValid() ? inputMuon->isolationR03().sumPt : 0.0;
  double sumEtEcal = inputMuon->isIsolationValid() ? inputMuon->isolationR03().emEt : 0.0;
  double sumEtHcal = inputMuon->isIsolationValid() ? inputMuon->isolationR03().hadEt : 0.0;

  if (sumPt > 3 || sumEtEcal + sumEtHcal > 5)
    useAverage = true;

  //get the energy using TrackAssociator if
  //the muon turns out to be isolated
  MuonMETInfo muMETInfo;
  muMETInfo.useAverage = useAverage;
  muMETInfo.useTkAssociatorPositions = useTrackAssociatorPositions;
  muMETInfo.useHO = useHO;

  TrackRef mu_track;
  if (inputMuon->isGlobalMuon()) {
    mu_track = inputMuon->globalTrack();
  } else if (inputMuon->isTrackerMuon() || inputMuon->isRPCMuon() || inputMuon->isGEMMuon() || inputMuon->isME0Muon()) {
    mu_track = inputMuon->innerTrack();
  } else
    mu_track = inputMuon->outerTrack();

  if (useTrackAssociatorPositions) {
    muMETInfo.ecalPos = info.trkGlobPosAtEcal;
    muMETInfo.hcalPos = info.trkGlobPosAtHcal;
    muMETInfo.hoPos = info.trkGlobPosAtHO;
  }

  if (!useAverage) {
    if (useRecHits) {
      muMETInfo.ecalE = inputMuon->calEnergy().emS9;
      muMETInfo.hcalE = inputMuon->calEnergy().hadS9;
      if (useHO)  //muMETInfo.hoE is 0 by default
        muMETInfo.hoE = inputMuon->calEnergy().hoS9;
    } else {  // use Towers (this is the default)
      //only include towers whose Et > 0.5 since
      //by default the MET only includes towers with Et > 0.5
      std::vector<const CaloTower*> towers = info.crossedTowers;
      for (vector<const CaloTower*>::const_iterator it = towers.begin(); it != towers.end(); it++) {
        if ((*it)->et() < towerEtThreshold)
          continue;
        muMETInfo.ecalE += (*it)->emEnergy();
        muMETInfo.hcalE += (*it)->hadEnergy();
        if (useHO)
          muMETInfo.hoE += (*it)->outerEnergy();
      }
    }  //use Towers
  }

  //This needs to be fixed!!!!!
  //The tracker has better resolution for pt < 200 GeV
  math::XYZTLorentzVector mup4;
  if (inputMuon->isGlobalMuon()) {
    if (inputMuon->globalTrack()->pt() < 200) {
      mup4 = LorentzVector(inputMuon->innerTrack()->px(),
                           inputMuon->innerTrack()->py(),
                           inputMuon->innerTrack()->pz(),
                           inputMuon->innerTrack()->p());
    } else {
      mup4 = LorentzVector(inputMuon->globalTrack()->px(),
                           inputMuon->globalTrack()->py(),
                           inputMuon->globalTrack()->pz(),
                           inputMuon->globalTrack()->p());
    }
  } else if (inputMuon->isTrackerMuon() || inputMuon->isRPCMuon() || inputMuon->isGEMMuon() || inputMuon->isME0Muon()) {
    mup4 = LorentzVector(inputMuon->innerTrack()->px(),
                         inputMuon->innerTrack()->py(),
                         inputMuon->innerTrack()->pz(),
                         inputMuon->innerTrack()->p());
  } else
    mup4 = LorentzVector(inputMuon->outerTrack()->px(),
                         inputMuon->outerTrack()->py(),
                         inputMuon->outerTrack()->pz(),
                         inputMuon->outerTrack()->p());

  //call function that does the work
  correctMETforMuon(deltax, deltay, Bfield, inputMuon->charge(), mup4, inputMuon->vertex(), muMETInfo);
}

reco::CaloMET MuonMETAlgo::makeMET	(	const reco::CaloMET &	fMet,
		double	fSumEt,
		const std::vector< CorrMETData > &	fCorrections,
		const reco::MET::LorentzVector &
	)

Referenced by ~MuonMETAlgo().

reco::MET MuonMETAlgo::makeMET	(	const reco::MET &	,
		double	fSumEt,
		const std::vector< CorrMETData > &	fCorrections,
		const reco::MET::LorentzVector &	fP4
	)

template<class T >

void MuonMETAlgo::MuonMETAlgo_run	(	const edm::View< reco::Muon > &	inputMuons,
		const edm::ValueMap< reco::MuonMETCorrectionData > &	vm_muCorrData,
		const edm::View< T > &	v_uncorMET,
		std::vector< T > *	v_corMET
	)

Definition at line 45 of file MuonMETAlgo.cc.

References reco::MuonMETCorrectionData::corrX(), reco::MuonMETCorrectionData::corrY(), dumpMFGeometry_cfg::delta, mps_fire::i, CorrMETData::mex, CorrMETData::mey, amptDefaultParameters_cff::mu, reco::LeafCandidate::p4(), edm::View< T >::refAt(), mps_fire::result, edm::View< T >::size(), mathSSE::sqrt(), CorrMETData::sumet, and reco::MuonMETCorrectionData::type().

Referenced by ~MuonMETAlgo().

                                                          {
  T uncorMETObj = v_uncorMET.front();

  double corMETX = uncorMETObj.px();
  double corMETY = uncorMETObj.py();

  double sumMuPx = 0.;
  double sumMuPy = 0.;
  double sumMuPt = 0.;
  double sumMuDepEx = 0.;
  double sumMuDepEy = 0.;
  double sumMuDepEt = 0.;

  for (unsigned int i = 0; i < inputMuons.size(); ++i) {
    reco::MuonMETCorrectionData muCorrData = vm_muCorrData[inputMuons.refAt(i)];

    if (muCorrData.type() == 0)
      continue;

    float deltax = muCorrData.corrX();
    float deltay = muCorrData.corrY();

    const reco::Muon* mu = &inputMuons[i];
    const LorentzVector& mup4 = mu->p4();

    sumMuPx += mup4.px();
    sumMuPy += mup4.py();
    sumMuPt += mup4.pt();
    sumMuDepEx += deltax;
    sumMuDepEy += deltay;
    sumMuDepEt += sqrt(deltax * deltax + deltay * deltay);
    corMETX = corMETX - mup4.px() + deltax;
    corMETY = corMETY - mup4.py() + deltay;
  }

  CorrMETData delta;
  delta.mex = sumMuDepEx - sumMuPx;
  delta.mey = sumMuDepEy - sumMuPy;
  delta.sumet = sumMuPt - sumMuDepEt;
  MET::LorentzVector correctedMET4vector(corMETX, corMETY, 0., sqrt(corMETX * corMETX + corMETY * corMETY));
  std::vector<CorrMETData> corrections = uncorMETObj.mEtCorr();
  corrections.push_back(delta);

  T result = makeMET(uncorMETObj, uncorMETObj.sumEt() + delta.sumet, corrections, correctedMET4vector);
  v_corMET->push_back(result);
}

virtual void MuonMETAlgo::run ( const edm::View< reco::Muon > &  inputMuons, const edm::ValueMap< reco::MuonMETCorrectionData > &  vm_muCorrData, const edm::View< reco::MET > &  uncorMET, reco::METCollection *  corMET  )

virtual

Referenced by correctMETforMuon(), cms::MuonMET::produce(), and ~MuonMETAlgo().

virtual void MuonMETAlgo::run ( const edm::View< reco::Muon > &  inputMuons, const edm::ValueMap< reco::MuonMETCorrectionData > &  vm_muCorrData, const edm::View< reco::CaloMET > &  uncorMET, reco::CaloMETCollection *  corMET  )

virtual