InDetPerfPlot_TrackParameters.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/

 
 
#include "InDetPhysValMonitoringUtilities.h"
 
#include "InDetPerfPlot_TrackParameters.h"
#include "AthContainers/ConstAccessor.h"
#include <cmath>
using namespace IDPVM;
 
InDetPerfPlot_TrackParameters::InDetPerfPlot_TrackParameters(InDetPlotBase* pParent, const std::string& sDir, bool hasHGTDReco) :
  InDetPlotBase(pParent, sDir), m_hasHGTDReco{hasHGTDReco}{
  //nop
  //variable initialised at declaration
}
 
void
InDetPerfPlot_TrackParameters::initializePlots() {
 
  book(m_reco_d0,     "reco_d0");
  book(m_reco_z0,     "reco_z0");
  book(m_reco_z0sin,  "reco_z0sin");
  book(m_reco_phi,    "reco_phi");
  book(m_reco_theta,  "reco_theta");
  book(m_reco_eta,    "reco_eta");
  book(m_reco_qoverp, "reco_qoverp");
  book(m_reco_pt,     "reco_pt");
  book(m_reco_lowpt,     "reco_lowpt");
  book(m_reco_chi2,   "reco_chi2");
  book(m_reco_ndof,   "reco_ndof");
  book(m_reco_chi2Overndof, "reco_chi2Overndof");
  book(m_reco_author,  "reco_author");
  if(m_hasHGTDReco){
    book(m_reco_time,    "reco_time");
    if (m_iDetailLevel >= 100){
       book(m_reco_HGTDChi2,             "reco_HGTDChi2");
       book(m_reco_timeResolution,       "reco_timeResolution");
       book(m_reco_meanTime,             "reco_meanTime");
       book(m_reco_meanTimeResolution,   "reco_meanTimeResolution");
    }
    book(m_reco_hasValidTime_eff_vs_eta, "reco_hasValidTime_eff_vs_eta");
  }
 
  book(m_truth_d0,     "truth_d0");
  book(m_truth_z0,     "truth_z0");
  book(m_truth_z0sin,  "truth_z0sin");
  book(m_truth_phi,    "truth_phi");
  book(m_truth_theta,  "truth_theta");
  book(m_truth_eta,    "truth_eta");
  book(m_truth_qoverp, "truth_qoverp");
  book(m_truth_pt,     "truth_pt");
  book(m_truth_lowpt,     "truth_lowpt");
  book(m_truth_prodR,  "truth_prodR");
  book(m_truth_prodZ,  "truth_prodZ");
  book(m_truth_time, "truth_time");
 
  book(m_reco_pt_vs_eta, "reco_pt_vs_eta");
  book(m_reco_phi_vs_eta, "reco_phi_vs_eta");
 
  book(m_reco_d0_z0, "reco_d0_vs_z0");
  book(m_reco_d0_z0sin, "reco_d0_vs_z0sin");
 
  book(m_truth_pt_vs_eta, "truth_pt_vs_eta");
  book(m_truth_phi_vs_eta, "truth_phi_vs_eta");
 
  book(m_truth_hits, "truth_hits");
  book(m_truth_hits_vs_eta, "truth_hits_vs_eta");
 
}
 
void
InDetPerfPlot_TrackParameters::fill(const xAOD::TruthParticle& particle, float weight) {
 
  // quantities with xAOD::TruthParticle accessors:
  float eta = particle.eta();
  float pt = particle.pt() / Gaudi::Units::GeV;
  float phi = particle.phi();
 
  static const SG::ConstAccessor<float> d0Acc("d0");
  static const SG::ConstAccessor<float> z0Acc("z0");
  static const SG::ConstAccessor<float> thetaAcc("theta");
  static const SG::ConstAccessor<float> qOverPAcc("qOverP");
  static const SG::ConstAccessor<float> prodRAcc("prodR");
  static const SG::ConstAccessor<float> prodZAcc("prodZ");
  static const SG::ConstAccessor<float> timeAcc("time");
  float d0 = d0Acc.isAvailable(particle) ? d0Acc(particle) : -9999.;
  float z0 = z0Acc.isAvailable(particle) ? z0Acc(particle) : -9999.;
  float theta = thetaAcc.isAvailable(particle) ? thetaAcc(particle) : -9999.;
  float z0sin = (z0Acc.isAvailable(particle) && z0Acc(particle)) ? z0 * std::sin(theta) : -9999.;
  float qOverP = qOverPAcc.isAvailable(particle) ? qOverPAcc(particle) : -9999.;
  float prodR = prodRAcc.isAvailable(particle) ? prodRAcc(particle) : -9999.;
  float prodZ = prodZAcc.isAvailable(particle) ? prodZAcc(particle) : -9999.;
  float time = timeAcc.isAvailable(particle) ? timeAcc(particle) : -9999.;
 
  if(d0 > -9000.) fillHisto(m_truth_d0, d0, weight);
  if(z0 > -9000.) fillHisto(m_truth_z0, z0, weight);
  if(theta > -9000.) fillHisto(m_truth_theta, theta, weight);
  if(phi > -9000.) fillHisto(m_truth_phi, phi, weight);
  if(z0sin > -9000.) fillHisto(m_truth_z0sin, z0sin, weight);
  if(qOverP > -9000.) fillHisto(m_truth_qoverp, qOverP, weight);
  if(prodR > -9000.) fillHisto(m_truth_prodR, prodR, weight);
  if(prodZ > -9000.) fillHisto(m_truth_prodZ, prodZ, weight);
  if(time > -9000.) fillHisto(m_truth_time, time, weight);
 
  fillHisto(m_truth_eta, eta, weight);
  fillHisto(m_truth_pt, pt, weight);
  fillHisto(m_truth_lowpt, pt, weight);
 
  fillHisto(m_truth_pt_vs_eta, pt, eta, weight);
  fillHisto(m_truth_phi_vs_eta, phi, eta, weight);
 
  static const SG::AuxElement::ConstAccessor< float > nSilHitsAcc("nSilHits");
  if (nSilHitsAcc.isAvailable(particle)) {
    float hits = nSilHitsAcc(particle);
    fillHisto(m_truth_hits, hits, weight);
    fillHisto(m_truth_hits_vs_eta, eta, hits, weight);
  }
}
 
void
InDetPerfPlot_TrackParameters::fill(const xAOD::TrackParticle& particle, float weight) {
 
  float pt = particle.pt() / Gaudi::Units::GeV;
  float eta = particle.eta();
  float phi = particle.phi0();
 
  float chi2 = particle.chiSquared();
  float ndof = particle.numberDoF();
  float chi2Overndof = ndof > 0 ? chi2 / ndof : 0;
 
 
  fillHisto(m_reco_d0, particle.d0(), weight);
  fillHisto(m_reco_z0, particle.z0(), weight);
  fillHisto(m_reco_z0sin, particle.z0()* std::sin(particle.theta()), weight);
 
  fillHisto(m_reco_phi, phi, weight);
  fillHisto(m_reco_theta, particle.theta(), weight);
  fillHisto(m_reco_eta, eta, weight);
  fillHisto(m_reco_qoverp, particle.qOverP(), weight);
  fillHisto(m_reco_pt, pt, weight);
  fillHisto(m_reco_lowpt, pt, weight);
 
  fillHisto(m_reco_pt_vs_eta, pt, eta, weight);
  fillHisto(m_reco_phi_vs_eta, phi, eta, weight);
 
  fillHisto(m_reco_d0_z0,    particle.d0(), particle.z0(), weight);
  fillHisto(m_reco_d0_z0sin, particle.d0(), particle.z0()*std::sin(particle.theta()), weight);
 
  fillHisto(m_reco_chi2, chi2, weight);
  fillHisto(m_reco_ndof, ndof, weight);
  fillHisto(m_reco_chi2Overndof, chi2Overndof, weight);
 
  std::bitset<xAOD::TrackPatternRecoInfo::NumberOfTrackRecoInfo>  patternInfo = particle.patternRecoInfo();
  for(unsigned int i = 0; i < xAOD::TrackPatternRecoInfo::NumberOfTrackRecoInfo; i++){
    if(patternInfo.test(i)) fillHisto(m_reco_author, i, weight);
  }
 
  if(m_hasHGTDReco){
    static const SG::Accessor< uint8_t > accValidTime("hasValidTime");
    static const SG::Accessor< float > accTime("time");
    if( accValidTime.isAvailable(particle) && accTime.isAvailable(particle) ) {
      if (particle.hasValidTime()) {
    fillHisto(m_reco_time, particle.time(), weight);
        if (m_iDetailLevel >= 100){
          static const SG::Accessor<float> hgtdMeanTime("HGTDMeanTime");
          static const SG::Accessor<float> hgtdMeanTimeResolution("HGTDMeanTimeResolution");
          static const SG::Accessor<float> hgtdTimeResolution("timeResolution");
          static const SG::ConstAccessor<float> hgtdChi2("HGTDChi2");
 
          if (hgtdMeanTime.isAvailable(particle)) {
            float chi2 = hgtdChi2(particle);
            fillHisto(m_reco_HGTDChi2, chi2>0 ? log10(chi2) : -std::numeric_limits<float>::infinity(), weight);
            fillHisto(m_reco_meanTime, hgtdMeanTime(particle), weight);
            fillHisto(m_reco_meanTimeResolution, hgtdMeanTimeResolution(particle), weight);
            fillHisto(m_reco_timeResolution, hgtdTimeResolution(particle), weight);
          }
        }
      }
    }
 
    if( accValidTime.isAvailable(particle) ) {
      fillHisto(m_reco_hasValidTime_eff_vs_eta, eta, particle.hasValidTime(), weight);
    }
  }
 
}
 
void
InDetPerfPlot_TrackParameters::finalizePlots() {
 
  //
  //Pie
  //
 
}