EcalVetoResult.cxx

 
#include "Ecal/Event/EcalVetoResult.h"
 
ClassImp(ldmx::EcalVetoResult);
 
namespace ldmx {
EcalVetoResult::EcalVetoResult() {}
 
EcalVetoResult::~EcalVetoResult() { Clear(); }
 
void EcalVetoResult::Clear() {
  passesVeto_ = false;
 
  nReadoutHits_ = 0;
  summedDet_ = 0;
  summedTightIso_ = 0;
  maxCellDep_ = 0;
  showerRMS_ = 0;
  xStd_ = 0;
  yStd_ = 0;
  avgLayerHit_ = 0;
  stdLayerHit_ = 0;
  deepestLayerHit_ = 0;
  ecalBackEnergy_ = 0;
  // MIP tracking
  nStraightTracks_ = 0;
  nLinregTracks_ = 0;
  firstNearPhLayer_ = 0;
  nNearPhHits_ = 0;
  photonTerritoryHits_ = 0;
  epAng_ = 0;
  epAngAtTarget_ = 0;
  epSep_ = 0;
  epDot_ = 0;
  epDotAtTarget_ = 0;
 
  electronContainmentEnergy_.clear();
  photonContainmentEnergy_.clear();
  outsideContainmentEnergy_.clear();
  outsideContainmentNHits_.clear();
  outsideContainmentXStd_.clear();
  outsideContainmentYStd_.clear();
 
  energySeg_.clear();
  xMeanSeg_.clear();
  yMeanSeg_.clear();
  xStdSeg_.clear();
  yStdSeg_.clear();
  layerMeanSeg_.clear();
  layerStdSeg_.clear();
 
  eContEnergy_.clear();
  eContXMean_.clear();
  eContYMean_.clear();
  gContEnergy_.clear();
  gContNHits_.clear();
  gContXMean_.clear();
  gContYMean_.clear();
  oContEnergy_.clear();
  oContNHits_.clear();
  oContXMean_.clear();
  oContYMean_.clear();
  oContXStd_.clear();
  oContYStd_.clear();
  oContLayerMean_.clear();
  oContLayerStd_.clear();
 
  discValue_ = 0;
 
  recoilPx_ = -9999;
  recoilPy_ = -9999;
  recoilPz_ = -9999;
  recoilX_ = -9999;
  recoilY_ = -9999;
 
  ecalLayerEdepReadout_.clear();
}
void EcalVetoResult::Clear() {…}
 
void EcalVetoResult::setVariables(
    int nReadoutHits, int deepestLayerHit, float summedDet,
    float summedTightIso, float maxCellDep, float showerRMS, float xStd,
    float yStd, float avgLayerHit, float stdLayerHit, float ecalBackEnergy,
    int nStraightTracks, int nLinregTracks, int firstNearPhLayer,
    int nNearPhHits, int photonTerritoryHits, float epAng, float epAngAtTarget,
    float epSep, float epDot, float epDotAtTarget,
 
    std::vector<float> electronContainmentEnergy,
    std::vector<float> photonContainmentEnergy,
    std::vector<float> outsideContainmentEnergy,
    std::vector<int> outsideContainmentNHits,
    std::vector<float> outsideContainmentXStd,
    std::vector<float> outsideContainmentYStd,
 
    std::vector<float> energySeg, std::vector<float> xMeanSeg,
    std::vector<float> yMeanSeg, std::vector<float> xStdSeg,
    std::vector<float> yStdSeg, std::vector<float> layerMeanSeg,
    std::vector<float> layerStdSeg,
 
    std::vector<std::vector<float>> eContEnergy,
    std::vector<std::vector<float>> eContXMean,
    std::vector<std::vector<float>> eContYMean,
    std::vector<std::vector<float>> gContEnergy,
    std::vector<std::vector<int>> gContNHits,
    std::vector<std::vector<float>> gContXMean,
    std::vector<std::vector<float>> gContYMean,
    std::vector<std::vector<float>> oContEnergy,
    std::vector<std::vector<int>> oContNHits,
    std::vector<std::vector<float>> oContXMean,
    std::vector<std::vector<float>> oContYMean,
    std::vector<std::vector<float>> oContXStd,
    std::vector<std::vector<float>> oContYStd,
    std::vector<std::vector<float>> oContLayerMean,
    std::vector<std::vector<float>> oContLayerStd,
 
    std::vector<float> EcalLayerEdepReadout, std::array<float, 3> recoilP,
    std::array<float, 3> recoilPos) {
  nReadoutHits_ = nReadoutHits;
  summedDet_ = summedDet;
  summedTightIso_ = summedTightIso;
  maxCellDep_ = maxCellDep;
  showerRMS_ = showerRMS;
  xStd_ = xStd;
  yStd_ = yStd;
  avgLayerHit_ = avgLayerHit;
  stdLayerHit_ = stdLayerHit;
  deepestLayerHit_ = deepestLayerHit;
  ecalBackEnergy_ = ecalBackEnergy;
  // MIP tracking
  nStraightTracks_ = nStraightTracks;
  nLinregTracks_ = nLinregTracks;
  firstNearPhLayer_ = firstNearPhLayer;
  nNearPhHits_ = nNearPhHits;
  photonTerritoryHits_ = photonTerritoryHits;
  epAng_ = epAng;
  epAngAtTarget_ = epAngAtTarget;
  epSep_ = epSep;
  epDot_ = epDot;
  epDotAtTarget_ = epDotAtTarget;
 
  electronContainmentEnergy_ = electronContainmentEnergy;
  photonContainmentEnergy_ = photonContainmentEnergy;
  outsideContainmentEnergy_ = outsideContainmentEnergy;
  outsideContainmentNHits_ = outsideContainmentNHits;
  outsideContainmentXStd_ = outsideContainmentXStd;
  outsideContainmentYStd_ = outsideContainmentYStd;
 
  energySeg_ = energySeg;
  xMeanSeg_ = xMeanSeg;
  yMeanSeg_ = yMeanSeg;
  xStdSeg_ = xStdSeg;
  yStdSeg_ = yStdSeg;
  layerMeanSeg_ = layerMeanSeg;
  layerStdSeg_ = layerStdSeg;
 
  eContEnergy_ = eContEnergy;
  eContXMean_ = eContXMean;
  eContYMean_ = eContYMean;
  gContEnergy_ = gContEnergy;
  gContNHits_ = gContNHits;
  gContXMean_ = gContXMean;
  gContYMean_ = gContYMean;
  oContEnergy_ = oContEnergy;
  oContNHits_ = oContNHits;
  oContXMean_ = oContXMean;
  oContYMean_ = oContYMean;
  oContXStd_ = oContXStd;
  oContYStd_ = oContYStd;
  oContLayerMean_ = oContLayerMean;
  oContLayerStd_ = oContLayerStd;
 
  // discvalue not set here
 
  if (!recoilP.empty()) {
    recoilPx_ = recoilP[0];
    recoilPy_ = recoilP[1];
    recoilPz_ = recoilP[2];
  }
  if (!recoilPos.empty()) {
    recoilX_ = recoilPos[0];
    recoilY_ = recoilPos[1];
  }
 
  ecalLayerEdepReadout_ = EcalLayerEdepReadout;
}
void EcalVetoResult::setVariables( {…}
 
void EcalVetoResult::Print() const {
  std::cout << "[ EcalVetoResult ]:\n"
            << "\t Passes veto : " << passesVeto_ << "\n"
            << std::endl;
}
void EcalVetoResult::Print() const  {…}
}  // namespace ldmx