[ALICE3] A3 OTF: Check available LUT before smearing (#13420)

Author: njacazio

ALICE3/Core/DelphesO2TrackSmearer.cxx

@@ -153,12 +153,13 @@ bool TrackSmearer::loadTable(int pdg, const char* filename, bool forceReload)
 
 /*****************************************************************/
 
-lutEntry_t*
-  TrackSmearer::getLUTEntry(int pdg, float nch, float radius, float eta, float pt, float& interpolatedEff)
+lutEntry_t* TrackSmearer::getLUTEntry(const int pdg, const float nch, const float radius, const float eta, const float pt, float& interpolatedEff)
 {
-  auto ipdg = getIndexPDG(pdg);
-  if (!mLUTHeader[ipdg])
+  const int ipdg = getIndexPDG(pdg);
+  if (!mLUTHeader[ipdg]) {
+    LOG(error) << " --- getLUTEntry: LUT header not loaded for pdg=" << pdg << ". Returning nullptr.";
     return nullptr;
+  }
   auto inch = mLUTHeader[ipdg]->nchmap.find(nch);
   auto irad = mLUTHeader[ipdg]->radmap.find(radius);
   auto ieta = mLUTHeader[ipdg]->etamap.find(eta);
@@ -290,56 +291,56 @@ bool TrackSmearer::smearTrack(O2Track& o2track, int pdg, float nch)
   }
   auto eta = o2track.getEta();
   float interpolatedEff = 0.0f;
-  auto lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, interpolatedEff);
+  lutEntry_t* lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, interpolatedEff);
   if (!lutEntry || !lutEntry->valid)
     return false;
   return smearTrack(o2track, lutEntry, interpolatedEff);
 }
 
 /*****************************************************************/
 // relative uncertainty on pt
-double TrackSmearer::getPtRes(int pdg, float nch, float eta, float pt)
+double TrackSmearer::getPtRes(const int pdg, const float nch, const float eta, const float pt)
 {
   float dummy = 0.0f;
-  auto lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, dummy);
+  lutEntry_t* lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, dummy);
   auto val = std::sqrt(lutEntry->covm[14]) * lutEntry->pt;
   return val;
 }
 
 /*****************************************************************/
 // relative uncertainty on eta
-double TrackSmearer::getEtaRes(int pdg, float nch, float eta, float pt)
+double TrackSmearer::getEtaRes(const int pdg, const float nch, const float eta, const float pt)
 {
   float dummy = 0.0f;
-  auto lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, dummy);
+  lutEntry_t* lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, dummy);
   auto sigmatgl = std::sqrt(lutEntry->covm[9]);                                  // sigmatgl2
   auto etaRes = std::fabs(std::sin(2.0 * std::atan(std::exp(-eta)))) * sigmatgl; // propagate tgl to eta uncertainty
   etaRes /= lutEntry->eta;                                                       // relative uncertainty
   return etaRes;
 }
 /*****************************************************************/
 // absolute uncertainty on pt
-double TrackSmearer::getAbsPtRes(int pdg, float nch, float eta, float pt)
+double TrackSmearer::getAbsPtRes(const int pdg, const float nch, const float eta, const float pt)
 {
   float dummy = 0.0f;
-  auto lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, dummy);
+  lutEntry_t* lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, dummy);
   auto val = std::sqrt(lutEntry->covm[14]) * lutEntry->pt * lutEntry->pt;
   return val;
 }
 
 /*****************************************************************/
 // absolute uncertainty on eta
-double TrackSmearer::getAbsEtaRes(int pdg, float nch, float eta, float pt)
+double TrackSmearer::getAbsEtaRes(const int pdg, const float nch, const float eta, const float pt)
 {
   float dummy = 0.0f;
-  auto lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, dummy);
+  lutEntry_t* lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, dummy);
   auto sigmatgl = std::sqrt(lutEntry->covm[9]);                                  // sigmatgl2
   auto etaRes = std::fabs(std::sin(2.0 * std::atan(std::exp(-eta)))) * sigmatgl; // propagate tgl to eta uncertainty
   return etaRes;
 }
 /*****************************************************************/
 // efficiency
-double TrackSmearer::getEfficiency(int pdg, float nch, float eta, float pt)
+double TrackSmearer::getEfficiency(const int pdg, const float nch, const float eta, const float pt)
 {
   float efficiency = 0.0f;
   getLUTEntry(pdg, nch, 0., eta, pt, efficiency);
@@ -360,7 +361,7 @@ double TrackSmearer::getEfficiency(int pdg, float nch, float eta, float pt)
 //   return true;
 
 // #if 0
-//   auto lutEntry = getLUTEntry(track.PID, 0., 0., track.Eta, track.PT);
+//   lutEntry_t* lutEntry = getLUTEntry(track.PID, 0., 0., track.Eta, track.PT);
 //   if (!lutEntry)
 //     return;
 

ALICE3/Core/DelphesO2TrackSmearer.h

@@ -180,23 +180,24 @@ class TrackSmearer
 
   /** LUT methods **/
   bool loadTable(int pdg, const char* filename, bool forceReload = false);
-  void useEfficiency(bool val) { mUseEfficiency = val; }                      //;
-  void interpolateEfficiency(bool val) { mInterpolateEfficiency = val; }      //;
-  void skipUnreconstructed(bool val) { mSkipUnreconstructed = val; }          //;
-  void setWhatEfficiency(int val) { mWhatEfficiency = val; }                  //;
-  lutHeader_t* getLUTHeader(int pdg) { return mLUTHeader[getIndexPDG(pdg)]; } //;
-  lutEntry_t* getLUTEntry(int pdg, float nch, float radius, float eta, float pt, float& interpolatedEff);
+  bool hasTable(int pdg) { return (mLUTHeader[getIndexPDG(pdg)] != nullptr); } //;
+  void useEfficiency(bool val) { mUseEfficiency = val; }                       //;
+  void interpolateEfficiency(bool val) { mInterpolateEfficiency = val; }       //;
+  void skipUnreconstructed(bool val) { mSkipUnreconstructed = val; }           //;
+  void setWhatEfficiency(int val) { mWhatEfficiency = val; }                   //;
+  lutHeader_t* getLUTHeader(int pdg) { return mLUTHeader[getIndexPDG(pdg)]; }  //;
+  lutEntry_t* getLUTEntry(const int pdg, const float nch, const float radius, const float eta, const float pt, float& interpolatedEff);
 
   bool smearTrack(O2Track& o2track, lutEntry_t* lutEntry, float interpolatedEff);
   bool smearTrack(O2Track& o2track, int pdg, float nch);
   // bool smearTrack(Track& track, bool atDCA = true); // Only in DelphesO2
-  double getPtRes(int pdg, float nch, float eta, float pt);
-  double getEtaRes(int pdg, float nch, float eta, float pt);
-  double getAbsPtRes(int pdg, float nch, float eta, float pt);
-  double getAbsEtaRes(int pdg, float nch, float eta, float pt);
-  double getEfficiency(int pdg, float nch, float eta, float pt);
+  double getPtRes(const int pdg, const float nch, const float eta, const float pt);
+  double getEtaRes(const int pdg, const float nch, const float eta, const float pt);
+  double getAbsPtRes(const int pdg, const float nch, const float eta, const float pt);
+  double getAbsEtaRes(const int pdg, const float nch, const float eta, const float pt);
+  double getEfficiency(const int pdg, const float nch, const float eta, const float pt);
 
-  int getIndexPDG(int pdg)
+  int getIndexPDG(const int pdg)
   {
     switch (abs(pdg)) {
       case 11: