Utils/src/RecoilTools.cc

#include "MitPhysics/Utils/interface/RecoilTools.h"
#include "MitPhysics/Utils/interface/JetTools.h"
#include <TFile.h>

ClassImp(mithep::RecoilTools)

using namespace mithep;

RecoilTools::RecoilTools(TString iJetLowPtMVAFile,TString iJetHighPtMVAFile,TString iCutFile) { 
  fJetIDMVA = new JetIDMVA();
  fJetIDMVA->Initialize( JetIDMVA::kLoose,iJetLowPtMVAFile,iJetHighPtMVAFile,JetIDMVA::kBaseline,iCutFile);
}
//--------------------------------------------------------------------------------------------------
RecoilTools::~RecoilTools() { 
  delete fJetIDMVA;
}
//--------------------------------------------------------------------------------------------------
bool RecoilTools::filter(const PFJet *iJet,Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2) { 
  double pDEta1 = iJet->Eta() - iEta1;
  double pDPhi1 = fabs(iJet->Phi() - iPhi1); if(pDPhi1 > 2.*TMath::Pi()-pDPhi1) pDPhi1 = 2.*TMath::Pi()-pDPhi1;
  double pDR1   = sqrt(pDEta1*pDEta1 + pDPhi1*pDPhi1);
  if(pDR1 < 0.5) return false;
  double pDEta2 = iJet->Eta() - iEta2;
  double pDPhi2 = fabs(iJet->Phi() - iPhi2); if(pDPhi2 > 2.*TMath::Pi()-pDPhi2) pDPhi2 = 2.*TMath::Pi()-pDPhi2;
  double pDR2   = sqrt(pDEta2*pDEta2 + pDPhi2*pDPhi2);
  if(pDR2 < 0.5) return false;
  return true;
}

//--------------------------------------------------------------------------------------------------
Met RecoilTools::pfRecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
                          const PFMet *iMet) { 
  Met lPFMet(iMet->Px(),iMet->Py()); 
  lPFMet.SetSumEt(iMet->SumEt());
  lPFMet.SetMex  (lPFMet.Mex()+iVisPt*cos(iVisPhi));  
  lPFMet.SetMey  (lPFMet.Mey()+iVisPt*sin(iVisPhi));
  lPFMet.SetSumEt(lPFMet.SumEt()-iVisSumEt);
  return lPFMet;
}
//--------------------------------------------------------------------------------------------------
Met RecoilTools::trackMet(const PFCandidateCol *iCands,const Vertex *iVertex,Double_t iDZCut) { 
  double trkMetx  = 0;
  double trkMety  = 0;
  double trkSumEt = 0; 
  for(UInt_t i=0; i<iCands->GetEntries(); ++i) {
    const PFCandidate *pfcand = iCands->At(i);
    if( (pfcand->HasTrackerTrk() && (fabs(pfcand->TrackerTrk()->DzCorrected(*iVertex))< iDZCut)) ||
        (pfcand->HasGsfTrk()     && (fabs(pfcand->GsfTrk()->DzCorrected(*iVertex))    < iDZCut)) ) {
      trkMetx  -= pfcand->Px();
      trkMety  -= pfcand->Py();
      trkSumEt += pfcand->Pt();
    }
  }
  Met lMet(trkMetx,trkMety);
  lMet.SetSumEt(trkSumEt);
  return lMet;
}

//--------------------------------------------------------------------------------------------------
//Compute the recoil => here this requires the vector sum of the visible components
//VisPt    => Vector sum pT  of the visible non-recoiling components
//VisPhi   => Vector sum Phi of the visible non-recoiling components
//visSumEt => Vector sum Et  =f the visible non-recoiling components
Met RecoilTools::trackRecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
                             const PFCandidateCol *iCands,const Vertex *iVertex,double iDZCut) { 
  Met lTrkMet = trackMet(iCands,iVertex,iDZCut);
  lTrkMet.SetMex  (lTrkMet.Mex()+iVisPt*cos(iVisPhi));  
  lTrkMet.SetMey  (lTrkMet.Mey()+iVisPt*sin(iVisPhi));
  lTrkMet.SetSumEt(lTrkMet.SumEt()-iVisSumEt);
  return lTrkMet;
}
//--------------------------------------------------------------------------------------------------
void RecoilTools::addNeut(const PFJet *iJet,FourVectorM &iVec,Double_t &iSumEt, 
                          FactorizedJetCorrector *iJetCorrector,const PileupEnergyDensityCol *iPUEnergyDensity,
                          int iSign) { 
  FourVectorM lVec(0,0,0,0);
  double lPt = fJetIDMVA->correctedPt(iJet,iJetCorrector,iPUEnergyDensity);
  lPt *= (iJet->NeutralEmEnergy()/iJet->E() + iJet->NeutralHadronEnergy()/iJet->E());
  lVec.SetPt(lPt); lVec.SetEta(iJet->Eta()); lVec.SetPhi(iJet->Phi()); lVec.SetM(iJet->Mass());
  if(iSign > 0) iVec -= lVec;
  if(iSign < 0) iVec += lVec;
  iSumEt += lPt;
  //=== Above was a bug in the training
  //if(iSign > 0) iSumEt += lPt;
  //if(iSign < 0) iSumEt -= lPt;
}

//--------------------------------------------------------------------------------------------------
//Corrected Jets
void RecoilTools::addNeut(const PFJet *iJet,FourVectorM &iVec,Double_t &iSumEt,int iSign) { 
  FourVectorM lVec(0,0,0,0);
  double lPt = iJet->Pt();
  lPt *= (iJet->NeutralEmEnergy()/iJet->E() + iJet->NeutralHadronEnergy()/iJet->E());
  lVec.SetPt(lPt); lVec.SetEta(iJet->Eta()); lVec.SetPhi(iJet->Phi()); lVec.SetM(iJet->Mass());
  if(iSign > 0) iVec   -= lVec;
  if(iSign < 0) iVec   += lVec;
  iSumEt += lPt;
  //=== Above was a bug in the training
  //if(iSign > 0) iSumEt += lPt;
  //if(iSign < 0) iSumEt -= lPt;
}

//--------------------------------------------------------------------------------------------------
Met RecoilTools::NoPUMet( const PFJetCol       *iJets,FactorizedJetCorrector *iJetCorrector,
                          const PileupEnergyDensityCol *iPileupEnergyDensity,
                          const PFCandidateCol *iCands,const Vertex *iVertex,const VertexCol *iVertices,
                          Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,Double_t iDZCut) { 

  FourVectorM lVec        (0,0,0,0); double lSumEt          = 0; 
  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) { 
    const PFCandidate *pPF = iCands->At(i0);
    const Track* pTrack = pPF->TrackerTrk();
    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
    if(pTrack        ==  0                           ) continue;
    if(  !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue; 
    lVec     -= pPF->Mom();
    lSumEt   += pPF->Pt();
  }
  int lNPass = 0;
  for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
    const PFJet *pJet = iJets->At(i0);
    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                       continue; //Quick cleaning==> if not done already
    if(!fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
    addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity);
    lNPass++;
  }
  Met lMet(lVec.Px(),lVec.Py());
  lMet.SetSumEt( lSumEt);
  return lMet;
}
//--------------------------------------------------------------------------------------------------
//Corrected Jets
Met RecoilTools::NoPUMet( const PFJetCol       *iJets,
                          const PFCandidateCol *iCands,const Vertex *iVertex,const VertexCol *iVertices,
                          Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,Double_t iDZCut) { 

  FourVectorM lVec        (0,0,0,0); double lSumEt          = 0; 
  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) { 
    const PFCandidate *pPF = iCands->At(i0);
    const Track* pTrack = pPF->TrackerTrk();
    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
    if(pTrack        ==  0                           ) continue;
    if(  !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue; 
    lVec     -= pPF->Mom();
    lSumEt   += pPF->Pt();
  }
  for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
    const PFJet *pJet = iJets->At(i0);
    if(!fJetIDMVA->pass(pJet,iVertex,iVertices))                          continue;
    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                             continue; //Quick cleaning==> if not done already
    addNeut(pJet,lVec,lSumEt);
  }
  Met lMet(lVec.Px(),lVec.Py());
  lMet.SetSumEt(lSumEt);
  return lMet;
}
//--------------------------------------------------------------------------------------------------
Met RecoilTools::NoPURecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
                            const PFJetCol            *iJets,FactorizedJetCorrector *iJetCorrector,
                            const PileupEnergyDensityCol *iPileupEnergyDensity,
                            const PFCandidateCol   *iCands   ,const Vertex *iVertex,
                            const VertexCol *iVertices,
                            Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
                            Double_t iDZCut) { 
  
  Met lNoPUMet = NoPUMet(iJets,iJetCorrector,iPileupEnergyDensity,iCands,iVertex,iVertices,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
  lNoPUMet.SetMex  (lNoPUMet.Mex()+iVisPt*cos(iVisPhi));  
  lNoPUMet.SetMey  (lNoPUMet.Mey()+iVisPt*sin(iVisPhi));
  lNoPUMet.SetSumEt(lNoPUMet.SumEt()-iVisSumEt);
  return lNoPUMet;
}
//--------------------------------------------------------------------------------------------------
//Corrected Jets
Met RecoilTools::NoPURecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
                            const PFJetCol       *iJets,const PFCandidateCol *iCands,
                            const Vertex *iVertex,const VertexCol            *iVertices,
                            Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
                            Double_t iDZCut) { 
  
  Met lNoPUMet = NoPUMet(iJets,iCands,iVertex,iVertices,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
  lNoPUMet.SetMex  (lNoPUMet.Mex()+iVisPt*cos(iVisPhi));  
  lNoPUMet.SetMey  (lNoPUMet.Mey()+iVisPt*sin(iVisPhi));
  lNoPUMet.SetSumEt(lNoPUMet.SumEt()-iVisSumEt);
  return lNoPUMet;
}
//--------------------------------------------------------------------------------------------------
Met RecoilTools::PUCMet( const PFJetCol       *iJets,FactorizedJetCorrector *iJetCorrector,
                         const PileupEnergyDensityCol *iPileupEnergyDensity,
                         const PFCandidateCol *iCands,
                         const Vertex *iVertex,const VertexCol *iVertices,
                         Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
                         Double_t iDZCut) { 

  FourVectorM lVec        (0,0,0,0); double lSumEt          = 0; 
  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) { 
    const PFCandidate *pPF = iCands->At(i0);
    const Track* pTrack = pPF->TrackerTrk();
    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
    if(pTrack == 0                                   && 
       (pPF->PFType() == PFCandidate::eGamma         || 
        pPF->PFType() == PFCandidate::eEGammaHF      || 
        pPF->PFType() == PFCandidate::eNeutralHadron || 
        pPF->PFType() == PFCandidate::eHadronHF      ))
      {lVec -= pPF->Mom(); lSumEt += pPF->Pt();}
    if(pTrack        ==  0                           ) continue;
    if(  !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue; 
    lVec     -= pPF->Mom();
    lSumEt   += pPF->Pt();
  }
  for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
    const PFJet *pJet = iJets->At(i0);
    if(!JetTools::passPFLooseId(pJet))                                             continue;
    if(fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                      continue; //Quick cleaning==> if not done already
    addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity,-1);
  }
  Met lMet(lVec.Px(),lVec.Py());
  lMet.SetSumEt(lSumEt);
  return lMet;
}
//--------------------------------------------------------------------------------------------------
//Corrected jets
Met RecoilTools::PUCMet( const PFJetCol       *iJets,const PFCandidateCol *iCands,
                         const Vertex *iVertex,const VertexCol *iVertices,
                         Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
                         Double_t iDZCut) { 

  FourVectorM lVec        (0,0,0,0); double lSumEt          = 0; 
  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) { 
    const PFCandidate *pPF = iCands->At(i0);
    const Track* pTrack = pPF->TrackerTrk();
    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
    if(pTrack == 0                                   && 
       (pPF->PFType() == PFCandidate::eGamma         || 
        pPF->PFType() == PFCandidate::eEGammaHF      || 
        pPF->PFType() == PFCandidate::eNeutralHadron || 
        pPF->PFType() == PFCandidate::eHadronHF      ))
      {lVec -= pPF->Mom(); lSumEt += pPF->Pt();}
    if(pTrack        ==  0                           ) continue;
    if(  !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue; 
    lVec     -= pPF->Mom();
    lSumEt   += pPF->Pt();
  }
  for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
    const PFJet *pJet = iJets->At(i0);
    if(!JetTools::passPFLooseId(pJet))                                   continue;
    if(fJetIDMVA->pass(pJet,iVertex,iVertices))                          continue;
    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                            continue; //Quick cleaning==> if not done already
    addNeut(pJet,lVec,lSumEt,-1);
  }
  Met lMet(lVec.Px(),lVec.Py());
  lMet.SetSumEt(lSumEt);
  return lMet;
}
//----> This MET is a bug need to fix it
//--------------------------------------------------------------------------------------------------
Met RecoilTools::PUCRecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
                           const PFJetCol       *iJets,FactorizedJetCorrector *iJetCorrector,
                           const PileupEnergyDensityCol *iPileupEnergyDensity,
                           const PFCandidateCol *iCands,const Vertex *iVertex,
                           const VertexCol *iVertices,
                           Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
                           Double_t iDZCut) { 
  Met lPUCMet = PUCMet(iJets,iJetCorrector,iPileupEnergyDensity,iCands,iVertex,iVertices,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
  lPUCMet.SetMex  (lPUCMet.Mex()+iVisPt*cos(iVisPhi));  
  lPUCMet.SetMey  (lPUCMet.Mey()+iVisPt*sin(iVisPhi));
  lPUCMet.SetSumEt(lPUCMet.SumEt()-iVisSumEt);
  return lPUCMet;
}
//--------------------------------------------------------------------------------------------------
//Corrected Jets
Met RecoilTools::PUCRecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
                           const PFJetCol       *iJets,
                           const PFCandidateCol *iCands,const Vertex *iVertex,
                           const VertexCol *iVertices,
                           Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
                           Double_t iDZCut) { 
  Met lPUCMet = PUCMet(iJets,iCands,iVertex,iVertices,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
  lPUCMet.SetMex  (lPUCMet.Mex()+iVisPt*cos(iVisPhi));  
  lPUCMet.SetMey  (lPUCMet.Mey()+iVisPt*sin(iVisPhi));
  lPUCMet.SetSumEt(lPUCMet.SumEt()-iVisSumEt);
  return lPUCMet;
}
//--------------------------------------------------------------------------------------------------
Met RecoilTools::PUMet( const PFJetCol       *iJets,FactorizedJetCorrector *iJetCorrector,
                        const PileupEnergyDensityCol *iPileupEnergyDensity,
                        const PFCandidateCol *iCands,const Vertex *iVertex,
                        const VertexCol      *iVertices,
                        Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
                        Double_t iDZCut) { 

  FourVectorM lVec        (0,0,0,0); double lSumEt          = 0; 
  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) { 
    const PFCandidate *pPF = iCands->At(i0);
    const Track* pTrack = pPF->TrackerTrk();
    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
    if(pTrack        ==  0                           ) continue;
    if(   ((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue; 
    lVec     -= pPF->Mom();
    lSumEt   += pPF->Pt();
  }
  for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
    const PFJet *pJet = iJets->At(i0);
    if(!JetTools::passPFLooseId(pJet))                                             continue;
    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                                      continue; //Quick cleaning
    if(fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
    addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity);
  }
  Met lMet(lVec.Px(),lVec.Py());
  lMet.SetSumEt(lSumEt);
  return lMet;
}
//--------------------------------------------------------------------------------------------------
//Corrected Jets
Met RecoilTools::PUMet( const PFJetCol       *iJets,
                        const PFCandidateCol *iCands,const Vertex *iVertex,const VertexCol *iVertices,
                        Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
                        Double_t iDZCut) { 

  FourVectorM lVec        (0,0,0,0); double lSumEt          = 0; 
  for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) { 
    const PFCandidate *pPF = iCands->At(i0);
    const Track* pTrack = pPF->TrackerTrk();
    if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
    if(pTrack        ==  0                           ) continue;
    if(   ((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) ||
           (pPF->HasGsfTrk()     && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex))    <iDZCut)))) continue; 
    lVec     -= pPF->Mom();
    lSumEt   += pPF->Pt();
  }
  for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
    const PFJet *pJet = iJets->At(i0);
    if(!JetTools::passPFLooseId(pJet))                                   continue;
    if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2))                            continue; //Quick cleaning
    if(fJetIDMVA->pass(pJet,iVertex,iVertices))                          continue;
    addNeut(pJet,lVec,lSumEt);
  }
  Met lMet(lVec.Px(),lVec.Py());
  lMet.SetSumEt(lSumEt);
  return lMet;
}
//--------------------------------------------------------------------------------------------------
Met RecoilTools::PURecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
                          const PFJetCol       *iJets,FactorizedJetCorrector *iJetCorrector,
                          const PileupEnergyDensityCol *iPileupEnergyDensity,
                          const PFCandidateCol *iCands,const Vertex *iVertex,
                          const VertexCol      *iVertices,
                          Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
                          Double_t iDZCut) { 
  Met lPUMet = PUMet(iJets,iJetCorrector,iPileupEnergyDensity,iCands,iVertex,iVertices,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
  lPUMet.SetMex  (lPUMet.Mex()+iVisPt*cos(iVisPhi));  
  lPUMet.SetMey  (lPUMet.Mey()+iVisPt*sin(iVisPhi));
  lPUMet.SetSumEt(lPUMet.SumEt()-iVisSumEt);
  return lPUMet;
}
//--------------------------------------------------------------------------------------------------
//Corrected Jets
Met RecoilTools::PURecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
                          const PFJetCol       *iJets,
                          const PFCandidateCol *iCands,const Vertex *iVertex,const VertexCol *iVertices,
                          Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
                          Double_t iDZCut) { 
  Met lPUMet = PUMet(iJets,iCands,iVertex,iVertices,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
  lPUMet.SetMex  (lPUMet.Mex()+iVisPt*cos(iVisPhi));  
  lPUMet.SetMey  (lPUMet.Mey()+iVisPt*sin(iVisPhi));
  lPUMet.SetSumEt(lPUMet.SumEt()-iVisSumEt);
  return lPUMet;
}
Revision:	1.4
Committed:	Fri Apr 13 14:24:00 2012 UTC (13 years ago) by pharris
Content type:	text/plain
Branch:	MAIN
Changes since 1.3:	+12 -4 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	pharris	1.1	#include "MitPhysics/Utils/interface/RecoilTools.h"
2			#include "MitPhysics/Utils/interface/JetTools.h"
3			#include <TFile.h>
4
5			ClassImp(mithep::RecoilTools)
6
7			using namespace mithep;
8
9	pharris	1.3	RecoilTools::RecoilTools(TString iJetLowPtMVAFile,TString iJetHighPtMVAFile,TString iCutFile) {
10	pharris	1.1	fJetIDMVA = new JetIDMVA();
11	pharris	1.3	fJetIDMVA->Initialize( JetIDMVA::kLoose,iJetLowPtMVAFile,iJetHighPtMVAFile,JetIDMVA::kBaseline,iCutFile);
12	pharris	1.1	}
13			//--------------------------------------------------------------------------------------------------
14			RecoilTools::~RecoilTools() {
15			delete fJetIDMVA;
16			}
17			//--------------------------------------------------------------------------------------------------
18			bool RecoilTools::filter(const PFJet *iJet,Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2) {
19			double pDEta1 = iJet->Eta() - iEta1;
20			double pDPhi1 = fabs(iJet->Phi() - iPhi1); if(pDPhi1 > 2.TMath::Pi()-pDPhi1) pDPhi1 = 2.TMath::Pi()-pDPhi1;
21			double pDR1 = sqrt(pDEta1pDEta1 + pDPhi1pDPhi1);
22			if(pDR1 < 0.5) return false;
23			double pDEta2 = iJet->Eta() - iEta2;
24			double pDPhi2 = fabs(iJet->Phi() - iPhi2); if(pDPhi2 > 2.TMath::Pi()-pDPhi2) pDPhi2 = 2.TMath::Pi()-pDPhi2;
25			double pDR2 = sqrt(pDEta2pDEta2 + pDPhi2pDPhi2);
26			if(pDR2 < 0.5) return false;
27			return true;
28			}
29
30			//--------------------------------------------------------------------------------------------------
31			Met RecoilTools::pfRecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
32			const PFMet *iMet) {
33			Met lPFMet(iMet->Px(),iMet->Py());
34			lPFMet.SetSumEt(iMet->SumEt());
35			lPFMet.SetMex (lPFMet.Mex()+iVisPt*cos(iVisPhi));
36			lPFMet.SetMey (lPFMet.Mey()+iVisPt*sin(iVisPhi));
37			lPFMet.SetSumEt(lPFMet.SumEt()-iVisSumEt);
38			return lPFMet;
39			}
40			//--------------------------------------------------------------------------------------------------
41			Met RecoilTools::trackMet(const PFCandidateCol iCands,const Vertex iVertex,Double_t iDZCut) {
42			double trkMetx = 0;
43			double trkMety = 0;
44			double trkSumEt = 0;
45			for(UInt_t i=0; i<iCands->GetEntries(); ++i) {
46			const PFCandidate *pfcand = iCands->At(i);
47			if( (pfcand->HasTrackerTrk() && (fabs(pfcand->TrackerTrk()->DzCorrected(*iVertex))< iDZCut)) \|\|
48			(pfcand->HasGsfTrk() && (fabs(pfcand->GsfTrk()->DzCorrected(*iVertex)) < iDZCut)) ) {
49			trkMetx -= pfcand->Px();
50			trkMety -= pfcand->Py();
51			trkSumEt += pfcand->Pt();
52			}
53			}
54			Met lMet(trkMetx,trkMety);
55			lMet.SetSumEt(trkSumEt);
56			return lMet;
57			}
58
59			//--------------------------------------------------------------------------------------------------
60			//Compute the recoil => here this requires the vector sum of the visible components
61			//VisPt => Vector sum pT of the visible non-recoiling components
62			//VisPhi => Vector sum Phi of the visible non-recoiling components
63			//visSumEt => Vector sum Et =f the visible non-recoiling components
64			Met RecoilTools::trackRecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
65			const PFCandidateCol iCands,const Vertex iVertex,double iDZCut) {
66			Met lTrkMet = trackMet(iCands,iVertex,iDZCut);
67			lTrkMet.SetMex (lTrkMet.Mex()+iVisPt*cos(iVisPhi));
68			lTrkMet.SetMey (lTrkMet.Mey()+iVisPt*sin(iVisPhi));
69			lTrkMet.SetSumEt(lTrkMet.SumEt()-iVisSumEt);
70			return lTrkMet;
71			}
72			//--------------------------------------------------------------------------------------------------
73			void RecoilTools::addNeut(const PFJet *iJet,FourVectorM &iVec,Double_t &iSumEt,
74			FactorizedJetCorrector iJetCorrector,const PileupEnergyDensityCol iPUEnergyDensity,
75			int iSign) {
76			FourVectorM lVec(0,0,0,0);
77			double lPt = fJetIDMVA->correctedPt(iJet,iJetCorrector,iPUEnergyDensity);
78			lPt *= (iJet->NeutralEmEnergy()/iJet->E() + iJet->NeutralHadronEnergy()/iJet->E());
79			lVec.SetPt(lPt); lVec.SetEta(iJet->Eta()); lVec.SetPhi(iJet->Phi()); lVec.SetM(iJet->Mass());
80			if(iSign > 0) iVec -= lVec;
81			if(iSign < 0) iVec += lVec;
82			iSumEt += lPt;
83	pharris	1.4	//=== Above was a bug in the training
84			//if(iSign > 0) iSumEt += lPt;
85			//if(iSign < 0) iSumEt -= lPt;
86	pharris	1.1	}
87	pharris	1.2
88			//--------------------------------------------------------------------------------------------------
89			//Corrected Jets
90			void RecoilTools::addNeut(const PFJet *iJet,FourVectorM &iVec,Double_t &iSumEt,int iSign) {
91			FourVectorM lVec(0,0,0,0);
92			double lPt = iJet->Pt();
93			lPt *= (iJet->NeutralEmEnergy()/iJet->E() + iJet->NeutralHadronEnergy()/iJet->E());
94			lVec.SetPt(lPt); lVec.SetEta(iJet->Eta()); lVec.SetPhi(iJet->Phi()); lVec.SetM(iJet->Mass());
95	pharris	1.4	if(iSign > 0) iVec -= lVec;
96			if(iSign < 0) iVec += lVec;
97	pharris	1.2	iSumEt += lPt;
98	pharris	1.4	//=== Above was a bug in the training
99			//if(iSign > 0) iSumEt += lPt;
100			//if(iSign < 0) iSumEt -= lPt;
101	pharris	1.2	}
102
103	pharris	1.1	//--------------------------------------------------------------------------------------------------
104			Met RecoilTools::NoPUMet( const PFJetCol iJets,FactorizedJetCorrector iJetCorrector,
105			const PileupEnergyDensityCol *iPileupEnergyDensity,
106	pharris	1.3	const PFCandidateCol iCands,const Vertex iVertex,const VertexCol *iVertices,
107	pharris	1.1	Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,Double_t iDZCut) {
108
109			FourVectorM lVec (0,0,0,0); double lSumEt = 0;
110			for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
111			const PFCandidate *pPF = iCands->At(i0);
112			const Track* pTrack = pPF->TrackerTrk();
113			if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
114			if(pTrack == 0 ) continue;
115			if( !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) \|\|
116			(pPF->HasGsfTrk() && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex)) <iDZCut)))) continue;
117			lVec -= pPF->Mom();
118			lSumEt += pPF->Pt();
119			}
120	pharris	1.4	int lNPass = 0;
121	pharris	1.1	for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
122			const PFJet *pJet = iJets->At(i0);
123	pharris	1.4	if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2)) continue; //Quick cleaning==> if not done already
124	pharris	1.3	if(!fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
125	pharris	1.1	addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity);
126	pharris	1.4	lNPass++;
127	pharris	1.1	}
128			Met lMet(lVec.Px(),lVec.Py());
129	pharris	1.4	lMet.SetSumEt( lSumEt);
130	pharris	1.1	return lMet;
131			}
132			//--------------------------------------------------------------------------------------------------
133	pharris	1.2	//Corrected Jets
134	pharris	1.3	Met RecoilTools::NoPUMet( const PFJetCol *iJets,
135			const PFCandidateCol iCands,const Vertex iVertex,const VertexCol *iVertices,
136	pharris	1.2	Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,Double_t iDZCut) {
137
138			FourVectorM lVec (0,0,0,0); double lSumEt = 0;
139			for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
140			const PFCandidate *pPF = iCands->At(i0);
141			const Track* pTrack = pPF->TrackerTrk();
142			if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
143			if(pTrack == 0 ) continue;
144			if( !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) \|\|
145			(pPF->HasGsfTrk() && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex)) <iDZCut)))) continue;
146			lVec -= pPF->Mom();
147			lSumEt += pPF->Pt();
148			}
149			for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
150			const PFJet *pJet = iJets->At(i0);
151	pharris	1.3	if(!fJetIDMVA->pass(pJet,iVertex,iVertices)) continue;
152	pharris	1.2	if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2)) continue; //Quick cleaning==> if not done already
153			addNeut(pJet,lVec,lSumEt);
154			}
155			Met lMet(lVec.Px(),lVec.Py());
156			lMet.SetSumEt(lSumEt);
157			return lMet;
158			}
159			//--------------------------------------------------------------------------------------------------
160	pharris	1.1	Met RecoilTools::NoPURecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
161	pharris	1.3	const PFJetCol iJets,FactorizedJetCorrector iJetCorrector,
162	pharris	1.1	const PileupEnergyDensityCol *iPileupEnergyDensity,
163	pharris	1.3	const PFCandidateCol iCands ,const Vertex iVertex,
164			const VertexCol *iVertices,
165	pharris	1.1	Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
166			Double_t iDZCut) {
167
168	pharris	1.3	Met lNoPUMet = NoPUMet(iJets,iJetCorrector,iPileupEnergyDensity,iCands,iVertex,iVertices,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
169	pharris	1.1	lNoPUMet.SetMex (lNoPUMet.Mex()+iVisPt*cos(iVisPhi));
170			lNoPUMet.SetMey (lNoPUMet.Mey()+iVisPt*sin(iVisPhi));
171			lNoPUMet.SetSumEt(lNoPUMet.SumEt()-iVisSumEt);
172			return lNoPUMet;
173			}
174			//--------------------------------------------------------------------------------------------------
175	pharris	1.2	//Corrected Jets
176			Met RecoilTools::NoPURecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
177	pharris	1.3	const PFJetCol iJets,const PFCandidateCol iCands,
178			const Vertex iVertex,const VertexCol iVertices,
179	pharris	1.2	Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
180			Double_t iDZCut) {
181
182	pharris	1.3	Met lNoPUMet = NoPUMet(iJets,iCands,iVertex,iVertices,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
183	pharris	1.2	lNoPUMet.SetMex (lNoPUMet.Mex()+iVisPt*cos(iVisPhi));
184			lNoPUMet.SetMey (lNoPUMet.Mey()+iVisPt*sin(iVisPhi));
185			lNoPUMet.SetSumEt(lNoPUMet.SumEt()-iVisSumEt);
186			return lNoPUMet;
187			}
188			//--------------------------------------------------------------------------------------------------
189	pharris	1.1	Met RecoilTools::PUCMet( const PFJetCol iJets,FactorizedJetCorrector iJetCorrector,
190			const PileupEnergyDensityCol *iPileupEnergyDensity,
191	pharris	1.3	const PFCandidateCol *iCands,
192			const Vertex iVertex,const VertexCol iVertices,
193	pharris	1.1	Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
194			Double_t iDZCut) {
195
196			FourVectorM lVec (0,0,0,0); double lSumEt = 0;
197			for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
198			const PFCandidate *pPF = iCands->At(i0);
199			const Track* pTrack = pPF->TrackerTrk();
200			if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
201			if(pTrack == 0 &&
202			(pPF->PFType() == PFCandidate::eGamma \|\|
203			pPF->PFType() == PFCandidate::eEGammaHF \|\|
204			pPF->PFType() == PFCandidate::eNeutralHadron \|\|
205			pPF->PFType() == PFCandidate::eHadronHF ))
206			{lVec -= pPF->Mom(); lSumEt += pPF->Pt();}
207			if(pTrack == 0 ) continue;
208			if( !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) \|\|
209			(pPF->HasGsfTrk() && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex)) <iDZCut)))) continue;
210			lVec -= pPF->Mom();
211			lSumEt += pPF->Pt();
212			}
213			for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
214			const PFJet *pJet = iJets->At(i0);
215	pharris	1.3	if(!JetTools::passPFLooseId(pJet)) continue;
216			if(fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
217			if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2)) continue; //Quick cleaning==> if not done already
218	pharris	1.1	addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity,-1);
219			}
220			Met lMet(lVec.Px(),lVec.Py());
221			lMet.SetSumEt(lSumEt);
222			return lMet;
223			}
224	pharris	1.2	//--------------------------------------------------------------------------------------------------
225			//Corrected jets
226	pharris	1.3	Met RecoilTools::PUCMet( const PFJetCol iJets,const PFCandidateCol iCands,
227			const Vertex iVertex,const VertexCol iVertices,
228	pharris	1.2	Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
229			Double_t iDZCut) {
230
231			FourVectorM lVec (0,0,0,0); double lSumEt = 0;
232			for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
233			const PFCandidate *pPF = iCands->At(i0);
234			const Track* pTrack = pPF->TrackerTrk();
235			if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
236			if(pTrack == 0 &&
237			(pPF->PFType() == PFCandidate::eGamma \|\|
238			pPF->PFType() == PFCandidate::eEGammaHF \|\|
239			pPF->PFType() == PFCandidate::eNeutralHadron \|\|
240			pPF->PFType() == PFCandidate::eHadronHF ))
241			{lVec -= pPF->Mom(); lSumEt += pPF->Pt();}
242			if(pTrack == 0 ) continue;
243			if( !((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) \|\|
244			(pPF->HasGsfTrk() && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex)) <iDZCut)))) continue;
245			lVec -= pPF->Mom();
246			lSumEt += pPF->Pt();
247			}
248			for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
249			const PFJet *pJet = iJets->At(i0);
250			if(!JetTools::passPFLooseId(pJet)) continue;
251	pharris	1.3	if(fJetIDMVA->pass(pJet,iVertex,iVertices)) continue;
252	pharris	1.2	if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2)) continue; //Quick cleaning==> if not done already
253			addNeut(pJet,lVec,lSumEt,-1);
254			}
255			Met lMet(lVec.Px(),lVec.Py());
256			lMet.SetSumEt(lSumEt);
257			return lMet;
258			}
259	pharris	1.1	//----> This MET is a bug need to fix it
260			//--------------------------------------------------------------------------------------------------
261			Met RecoilTools::PUCRecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
262			const PFJetCol iJets,FactorizedJetCorrector iJetCorrector,
263			const PileupEnergyDensityCol *iPileupEnergyDensity,
264			const PFCandidateCol iCands,const Vertex iVertex,
265	pharris	1.3	const VertexCol *iVertices,
266	pharris	1.1	Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
267			Double_t iDZCut) {
268	pharris	1.3	Met lPUCMet = PUCMet(iJets,iJetCorrector,iPileupEnergyDensity,iCands,iVertex,iVertices,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
269	pharris	1.1	lPUCMet.SetMex (lPUCMet.Mex()+iVisPt*cos(iVisPhi));
270			lPUCMet.SetMey (lPUCMet.Mey()+iVisPt*sin(iVisPhi));
271			lPUCMet.SetSumEt(lPUCMet.SumEt()-iVisSumEt);
272			return lPUCMet;
273			}
274			//--------------------------------------------------------------------------------------------------
275	pharris	1.2	//Corrected Jets
276			Met RecoilTools::PUCRecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
277			const PFJetCol *iJets,
278			const PFCandidateCol iCands,const Vertex iVertex,
279	pharris	1.3	const VertexCol *iVertices,
280	pharris	1.2	Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
281			Double_t iDZCut) {
282	pharris	1.3	Met lPUCMet = PUCMet(iJets,iCands,iVertex,iVertices,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
283	pharris	1.2	lPUCMet.SetMex (lPUCMet.Mex()+iVisPt*cos(iVisPhi));
284			lPUCMet.SetMey (lPUCMet.Mey()+iVisPt*sin(iVisPhi));
285			lPUCMet.SetSumEt(lPUCMet.SumEt()-iVisSumEt);
286			return lPUCMet;
287			}
288			//--------------------------------------------------------------------------------------------------
289	pharris	1.1	Met RecoilTools::PUMet( const PFJetCol iJets,FactorizedJetCorrector iJetCorrector,
290			const PileupEnergyDensityCol *iPileupEnergyDensity,
291			const PFCandidateCol iCands,const Vertex iVertex,
292	pharris	1.3	const VertexCol *iVertices,
293	pharris	1.1	Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
294			Double_t iDZCut) {
295
296			FourVectorM lVec (0,0,0,0); double lSumEt = 0;
297			for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
298			const PFCandidate *pPF = iCands->At(i0);
299			const Track* pTrack = pPF->TrackerTrk();
300			if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
301			if(pTrack == 0 ) continue;
302			if( ((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) \|\|
303			(pPF->HasGsfTrk() && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex)) <iDZCut)))) continue;
304			lVec -= pPF->Mom();
305			lSumEt += pPF->Pt();
306			}
307			for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
308			const PFJet *pJet = iJets->At(i0);
309	pharris	1.3	if(!JetTools::passPFLooseId(pJet)) continue;
310			if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2)) continue; //Quick cleaning
311			if(fJetIDMVA->pass(pJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity)) continue;
312	pharris	1.1	addNeut(pJet,lVec,lSumEt,iJetCorrector,iPileupEnergyDensity);
313			}
314			Met lMet(lVec.Px(),lVec.Py());
315			lMet.SetSumEt(lSumEt);
316			return lMet;
317			}
318			//--------------------------------------------------------------------------------------------------
319	pharris	1.2	//Corrected Jets
320			Met RecoilTools::PUMet( const PFJetCol *iJets,
321	pharris	1.3	const PFCandidateCol iCands,const Vertex iVertex,const VertexCol *iVertices,
322	pharris	1.2	Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
323			Double_t iDZCut) {
324
325			FourVectorM lVec (0,0,0,0); double lSumEt = 0;
326			for(UInt_t i0 = 0; i0 < iCands->GetEntries(); i0++) {
327			const PFCandidate *pPF = iCands->At(i0);
328			const Track* pTrack = pPF->TrackerTrk();
329			if(pPF->GsfTrk()) pTrack = pPF->GsfTrk();
330			if(pTrack == 0 ) continue;
331			if( ((pPF->HasTrackerTrk() && (fabs(pPF->TrackerTrk()->DzCorrected(*iVertex))<iDZCut)) \|\|
332			(pPF->HasGsfTrk() && (fabs(pPF->GsfTrk()->DzCorrected(*iVertex)) <iDZCut)))) continue;
333			lVec -= pPF->Mom();
334			lSumEt += pPF->Pt();
335			}
336			for(UInt_t i0 = 0; i0 < iJets->GetEntries(); i0++) {
337			const PFJet *pJet = iJets->At(i0);
338			if(!JetTools::passPFLooseId(pJet)) continue;
339			if(!filter(pJet,iPhi1,iEta1,iPhi2,iEta2)) continue; //Quick cleaning
340	pharris	1.3	if(fJetIDMVA->pass(pJet,iVertex,iVertices)) continue;
341	pharris	1.2	addNeut(pJet,lVec,lSumEt);
342			}
343			Met lMet(lVec.Px(),lVec.Py());
344			lMet.SetSumEt(lSumEt);
345			return lMet;
346			}
347			//--------------------------------------------------------------------------------------------------
348	pharris	1.1	Met RecoilTools::PURecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
349			const PFJetCol iJets,FactorizedJetCorrector iJetCorrector,
350			const PileupEnergyDensityCol *iPileupEnergyDensity,
351			const PFCandidateCol iCands,const Vertex iVertex,
352	pharris	1.3	const VertexCol *iVertices,
353	pharris	1.1	Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
354			Double_t iDZCut) {
355	pharris	1.3	Met lPUMet = PUMet(iJets,iJetCorrector,iPileupEnergyDensity,iCands,iVertex,iVertices,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
356	pharris	1.1	lPUMet.SetMex (lPUMet.Mex()+iVisPt*cos(iVisPhi));
357			lPUMet.SetMey (lPUMet.Mey()+iVisPt*sin(iVisPhi));
358			lPUMet.SetSumEt(lPUMet.SumEt()-iVisSumEt);
359			return lPUMet;
360			}
361	pharris	1.2	//--------------------------------------------------------------------------------------------------
362			//Corrected Jets
363			Met RecoilTools::PURecoil(Double_t iVisPt,Double_t iVisPhi,Double_t iVisSumEt,
364			const PFJetCol *iJets,
365	pharris	1.3	const PFCandidateCol iCands,const Vertex iVertex,const VertexCol *iVertices,
366	pharris	1.2	Double_t iPhi1,Double_t iEta1,Double_t iPhi2,Double_t iEta2,
367			Double_t iDZCut) {
368	pharris	1.3	Met lPUMet = PUMet(iJets,iCands,iVertex,iVertices,iPhi1,iEta1,iPhi2,iEta2,iDZCut);
369	pharris	1.2	lPUMet.SetMex (lPUMet.Mex()+iVisPt*cos(iVisPhi));
370			lPUMet.SetMey (lPUMet.Mey()+iVisPt*sin(iVisPhi));
371			lPUMet.SetSumEt(lPUMet.SumEt()-iVisSumEt);
372			return lPUMet;
373			}