source: git/modules/PileUpJetID.cc@ 239e1d0

/** \class PileUpJetID
 *
 *  CMS PileUp Jet ID Variables
 *
 *  \author S. Zenz
 *
 */

#include "modules/PileUpJetID.h"

#include "classes/DelphesClasses.h"
#include "classes/DelphesFactory.h"
#include "classes/DelphesFormula.h"

#include "ExRootAnalysis/ExRootResult.h"
#include "ExRootAnalysis/ExRootFilter.h"
#include "ExRootAnalysis/ExRootClassifier.h"

#include "TMath.h"
#include "TString.h"
#include "TFormula.h"
#include "TRandom3.h"
#include "TObjArray.h"
//#include "TDatabasePDG.h"
#include "TLorentzVector.h"

#include <algorithm>
#include <stdexcept>
#include <iostream>
#include <sstream>

using namespace std;

//------------------------------------------------------------------------------

PileUpJetID::PileUpJetID() :
  fItJetInputArray(0),fTrackInputArray(0),fNeutralInputArray(0)
{

}

//------------------------------------------------------------------------------

PileUpJetID::~PileUpJetID()
{

}

//------------------------------------------------------------------------------

void PileUpJetID::Init()
{

  fJetPTMin = GetDouble("JetPTMin", 20.0);
  fParameterR = GetDouble("ParameterR", 0.5);
  fUseConstituents = GetInt("UseConstituents", 0);

  fMeanSqDeltaRMaxBarrel = GetDouble("MeanSqDeltaRMaxBarrel",0.1);
  fBetaMinBarrel = GetDouble("BetaMinBarrel",0.1);
  fMeanSqDeltaRMaxEndcap = GetDouble("MeanSqDeltaRMaxEndcap",0.1);
  fBetaMinEndcap = GetDouble("BetaMinEndcap",0.1);
  fMeanSqDeltaRMaxForward = GetDouble("MeanSqDeltaRMaxForward",0.1);
  fJetPTMinForNeutrals = GetDouble("JetPTMinForNeutrals", 20.0);
  fNeutralPTMin = GetDouble("NeutralPTMin", 2.0);

  fAverageEachTower = false; // for timing

  // import input array(s)

  fJetInputArray = ImportArray(GetString("JetInputArray", "FastJetFinder/jets"));
  fItJetInputArray = fJetInputArray->MakeIterator();

  fTrackInputArray = ImportArray(GetString("TrackInputArray", "ParticlePropagator/tracks"));
  fItTrackInputArray = fTrackInputArray->MakeIterator();

  fNeutralInputArray = ImportArray(GetString("NeutralInputArray", "ParticlePropagator/tracks"));
  fItNeutralInputArray = fNeutralInputArray->MakeIterator();

  // create output array(s)

  fOutputArray = ExportArray(GetString("OutputArray", "jets"));

  fNeutralsInPassingJets = ExportArray(GetString("NeutralsInPassingJets","eflowtowers"));

}

//------------------------------------------------------------------------------

void PileUpJetID::Finish()
{
  //  cout << "In finish" << endl;

  if(fItJetInputArray) delete fItJetInputArray;
  if(fItTrackInputArray) delete fItTrackInputArray;
  if(fItNeutralInputArray) delete fItNeutralInputArray;

}

//------------------------------------------------------------------------------

void PileUpJetID::Process()
{
  Candidate *candidate, *constituent;
  TLorentzVector momentum, area;

  Candidate *trk;

  // loop over all input candidates
  fItJetInputArray->Reset();
  while((candidate = static_cast<Candidate*>(fItJetInputArray->Next())))
  {
    momentum = candidate->Momentum;
    area = candidate->Area;

    float sumT0 = 0.;
    float sumT1 = 0.;
    float sumT10 = 0.;
    float sumT20 = 0.;
    float sumT30 = 0.;
    float sumT40 = 0.;
    float sumWeightsForT = 0.;
    candidate->NTimeHits = 0;

    float sumpt = 0.;
    float sumptch = 0.;
    float sumptchpv = 0.;
    float sumptchpu = 0.;
    float sumdrsqptsq = 0.;
    float sumptsq = 0.;
    int nc = 0;
    int nn = 0;
    float pt_ann[5];

    for (int i = 0 ; i < 5 ; i++) {
      pt_ann[i] = 0.;
    }

    if (fUseConstituents) {
      TIter itConstituents(candidate->GetCandidates());
      while((constituent = static_cast<Candidate*>(itConstituents.Next()))) {
        float pt = constituent->Momentum.Pt();
        float dr = candidate->Momentum.DeltaR(constituent->Momentum);
        //      cout << " There exists a constituent with dr=" << dr << endl;
        sumpt += pt;
        sumdrsqptsq += dr*dr*pt*pt;
        sumptsq += pt*pt;
        if (constituent->Charge == 0) {
          nn++;
        } else {
          if (constituent->IsRecoPU) {
            sumptchpu += pt;
          } else {
            sumptchpv += pt;
          }
          sumptch += pt;
          nc++;
        }
        for (int i = 0 ; i < 5 ; i++) {
          if (dr > 0.1*i && dr < 0.1*(i+1)) {
            pt_ann[i] += pt;
          }
        }
        float tow_sumT = 0;
        float tow_sumW = 0;
        for (int i = 0 ; i < constituent->ECalEnergyTimePairs.size() ; i++) {
          float w = TMath::Sqrt(constituent->ECalEnergyTimePairs[i].first);
          if (fAverageEachTower) {
            tow_sumT += w*constituent->ECalEnergyTimePairs[i].second;
            tow_sumW += w;
          } else {
            sumT0 += w*constituent->ECalEnergyTimePairs[i].second;
            sumT1 += w*gRandom->Gaus(constituent->ECalEnergyTimePairs[i].second,0.001);
            sumT10 += w*gRandom->Gaus(constituent->ECalEnergyTimePairs[i].second,0.010);
            sumT20 += w*gRandom->Gaus(constituent->ECalEnergyTimePairs[i].second,0.020);
            sumT30 += w*gRandom->Gaus(constituent->ECalEnergyTimePairs[i].second,0.030);
            sumT40 += w*gRandom->Gaus(constituent->ECalEnergyTimePairs[i].second,0.040);
            sumWeightsForT += w;
            candidate->NTimeHits++;
          }
        }
        if (fAverageEachTower && tow_sumW > 0.) {
          sumT0 += tow_sumT;
          sumT1 += tow_sumW*gRandom->Gaus(tow_sumT/tow_sumW,0.001);
          sumT10 += tow_sumW*gRandom->Gaus(tow_sumT/tow_sumW,0.0010);
          sumT20 += tow_sumW*gRandom->Gaus(tow_sumT/tow_sumW,0.0020);
          sumT30 += tow_sumW*gRandom->Gaus(tow_sumT/tow_sumW,0.0030);
          sumT40 += tow_sumW*gRandom->Gaus(tow_sumT/tow_sumW,0.0040);
          sumWeightsForT += tow_sumW;
          candidate->NTimeHits++;
        }
      }
    } else {
      // Not using constituents, using dr
      fItTrackInputArray->Reset();
      while ((trk = static_cast<Candidate*>(fItTrackInputArray->Next()))) {
        if (trk->Momentum.DeltaR(candidate->Momentum) < fParameterR) {
          float pt = trk->Momentum.Pt();
          sumpt += pt;
          sumptch += pt;
          if (trk->IsRecoPU) {
            sumptchpu += pt;
          } else {
            sumptchpv += pt;
          }
          float dr = candidate->Momentum.DeltaR(trk->Momentum);
          sumdrsqptsq += dr*dr*pt*pt;
          sumptsq += pt*pt;
          nc++;
          for (int i = 0 ; i < 5 ; i++) {
            if (dr > 0.1*i && dr < 0.1*(i+1)) {
              pt_ann[i] += pt;
            }
          }
        }
      }
      fItNeutralInputArray->Reset();
      while ((constituent = static_cast<Candidate*>(fItNeutralInputArray->Next()))) {
        if (constituent->Momentum.DeltaR(candidate->Momentum) < fParameterR) {
          float pt = constituent->Momentum.Pt();
          sumpt += pt;
          float dr = candidate->Momentum.DeltaR(constituent->Momentum);
          sumdrsqptsq += dr*dr*pt*pt;
          sumptsq += pt*pt;
          nn++;
          for (int i = 0 ; i < 5 ; i++) {
            if (dr > 0.1*i && dr < 0.1*(i+1)) {
            pt_ann[i] += pt;
            }
          }
        }
      }
    }

    if (sumptch > 0.) {
      candidate->Beta = sumptchpv/sumptch;
      candidate->BetaStar = sumptchpu/sumptch;
    } else {
      candidate->Beta = -999.;
      candidate->BetaStar = -999.;
    }
    if (sumptsq > 0.) {
      candidate->MeanSqDeltaR = sumdrsqptsq/sumptsq;
    } else {
      candidate->MeanSqDeltaR = -999.;
    }
    candidate->NCharged = nc;
    candidate->NNeutrals = nn;
    if (sumpt > 0.) {
      candidate->PTD = TMath::Sqrt(sumptsq) / sumpt;
      for (int i = 0 ; i < 5 ; i++) {
        candidate->FracPt[i] = pt_ann[i]/sumpt;
      }
    } else {
      candidate->PTD = -999.;
      for (int i = 0 ; i < 5 ; i++) {
        candidate->FracPt[i] = -999.;
      }
    }

    fOutputArray->Add(candidate);

    // New stuff
    /*
    fMeanSqDeltaRMaxBarrel = GetDouble("MeanSqDeltaRMaxBarrel",0.1);
    fBetaMinBarrel = GetDouble("BetaMinBarrel",0.1);
    fMeanSqDeltaRMaxEndcap = GetDouble("MeanSqDeltaRMaxEndcap",0.1);
    fBetaMinEndcap = GetDouble("BetaMinEndcap",0.1);
    fMeanSqDeltaRMaxForward = GetDouble("MeanSqDeltaRMaxForward",0.1);
    */

    bool passId = false;
    if (candidate->Momentum.Pt() > fJetPTMinForNeutrals && candidate->MeanSqDeltaR > -0.1) {
      if (fabs(candidate->Momentum.Eta())<1.5) {
        passId = ((candidate->Beta > fBetaMinBarrel) && (candidate->MeanSqDeltaR < fMeanSqDeltaRMaxBarrel));
      } else if (fabs(candidate->Momentum.Eta())<4.0) {
        passId = ((candidate->Beta > fBetaMinEndcap) && (candidate->MeanSqDeltaR < fMeanSqDeltaRMaxEndcap));
      } else {
        passId = (candidate->MeanSqDeltaR < fMeanSqDeltaRMaxForward);
      }
    }

    //    cout << " Pt Eta MeanSqDeltaR Beta PassId " << candidate->Momentum.Pt() 
    //   << " " << candidate->Momentum.Eta() << " " << candidate->MeanSqDeltaR << " " << candidate->Beta << " " << passId << endl;

    if (passId) {
      if (fUseConstituents) {
        TIter itConstituents(candidate->GetCandidates());
        while((constituent = static_cast<Candidate*>(itConstituents.Next()))) {
          if (constituent->Charge == 0 && constituent->Momentum.Pt() > fNeutralPTMin) {
            fNeutralsInPassingJets->Add(constituent);
            //      cout << "    Constitutent added Pt Eta Charge " << constituent->Momentum.Pt() << " " << constituent->Momentum.Eta() << " " << constituent->Charge << endl;
          }
        }
      } else { // use DeltaR
        fItNeutralInputArray->Reset();
        while ((constituent = static_cast<Candidate*>(fItNeutralInputArray->Next()))) {
          if (constituent->Momentum.DeltaR(candidate->Momentum) < fParameterR && constituent->Momentum.Pt() > fNeutralPTMin) {
            fNeutralsInPassingJets->Add(constituent);
            //            cout << "    Constitutent added Pt Eta Charge " << constituent->Momentum.Pt() << " " << constituent->Momentum.Eta() << " " << constituent->Charge << endl;
          }
        }
      }
    }


  }
}

//------------------------------------------------------------------------------