Please consider the following formatting changes to #3703

.github/workflows/mega-linter.yml

@@ -1,6 +1,6 @@
 ---
 # MegaLinter GitHub Action configuration file
-# More info at https://oxsecurity.github.io/megalinter
+# More info at https://megalinter.io
 name: MegaLinter
 
 'on': [pull_request_target]
@@ -17,7 +17,7 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  build:
+  megalinter:
     name: MegaLinter
     runs-on: ubuntu-latest
     steps:
@@ -38,11 +38,11 @@ jobs:
       - name: MegaLinter
         id: ml
         # You can override MegaLinter flavor used to have faster performances
-        # More info at https://oxsecurity.github.io/megalinter/flavors/
-        uses: oxsecurity/megalinter@v6
+        # More info at https://megalinter.io/flavors/
+        uses: oxsecurity/megalinter@v7
         env:
           # All available variables are described in documentation:
-          # https://oxsecurity.github.io/megalinter/configuration/
+          # https://megalinter.io/configuration/
           # Validates all source when push on master, else just the diff with
           # master. Override with true if you always want to lint all sources.
           VALIDATE_ALL_CODEBASE: false
@@ -83,7 +83,7 @@ jobs:
             yourself and update the pull request, or merge this PR in yours.
 
             You can find how to run MegaLinter locally at
-            <https://oxsecurity.github.io/megalinter/latest/mega-linter-runner/>.
+            <https://megalinter.io/latest/mega-linter-runner/>.
         # We do not create PRs if the branch is not there.
         continue-on-error: true
 

.gitignore

@@ -7,3 +7,4 @@ compile_commands.json
 megalinter-reports/
 .mypy_cache/
 github_conf/
+.cache

.mega-linter.yml

@@ -17,14 +17,18 @@ DISABLE_LINTERS:
   - YAML_V8R
   - YAML_PRETTIER
   - REPOSITORY_DEVSKIM
+  - REPOSITORY_KICS
   - REPOSITORY_SECRETLINT
   - REPOSITORY_TRIVY
 DISABLE_ERRORS_LINTERS: # If errors are found by these linters, they will be considered as non blocking.
-  - PYTHON_BANDIT # The bandit check is overly broad and complains about subprocess usage in Scripts/update_ccdb.py.
+  - PYTHON_BANDIT # The bandit check is overly broad and complains about subprocess usage.
 SHOW_ELAPSED_TIME: true
 FILEIO_REPORTER: false
 GITHUB_COMMENT_REPORTER: false
 UPDATED_SOURCES_REPORTER: false
 PRINT_ALPACA: false # Don't print ASCII alpaca in the log
 PRINT_ALL_FILES: true # Print all processed files
 FLAVOR_SUGGESTIONS: false # Don't show suggestions about different MegaLinter flavors
+PYTHON_ISORT_CONFIG_FILE: pyproject.toml
+PYTHON_PYRIGHT_CONFIG_FILE: pyproject.toml
+PYTHON_RUFF_CONFIG_FILE: pyproject.toml

ALICE3/Core/DelphesO2TrackSmearer.cxx

@@ -110,7 +110,7 @@ bool TrackSmearer::loadTable(int pdg, const char* filename, bool forceReload)
 /*****************************************************************/
 
 lutEntry_t*
-  TrackSmearer::getLUTEntry(int pdg, float nch, float radius, float eta, float pt)
+  TrackSmearer::getLUTEntry(int pdg, float nch, float radius, float eta, float pt, float& interpolatedEff)
 {
   auto ipdg = getIndexPDG(pdg);
   if (!mLUTHeader[ipdg])
@@ -119,23 +119,73 @@ lutEntry_t*
   auto irad = mLUTHeader[ipdg]->radmap.find(radius);
   auto ieta = mLUTHeader[ipdg]->etamap.find(eta);
   auto ipt = mLUTHeader[ipdg]->ptmap.find(pt);
+
+  // Interpolate if requested
+  auto fraction = mLUTHeader[ipdg]->nchmap.fracPositionWithinBin(nch);
+  if (mInterpolateEfficiency) {
+    if (fraction > 0.5) {
+      if (mWhatEfficiency == 1) {
+        if (inch < mLUTHeader[ipdg]->nchmap.nbins - 1) {
+          interpolatedEff = (1.5f - fraction) * mLUTEntry[ipdg][inch][irad][ieta][ipt]->eff + (-0.5f + fraction) * mLUTEntry[ipdg][inch + 1][irad][ieta][ipt]->eff;
+        } else {
+          interpolatedEff = mLUTEntry[ipdg][inch][irad][ieta][ipt]->eff;
+        }
+      }
+      if (mWhatEfficiency == 2) {
+        if (inch < mLUTHeader[ipdg]->nchmap.nbins - 1) {
+          interpolatedEff = (1.5f - fraction) * mLUTEntry[ipdg][inch][irad][ieta][ipt]->eff2 + (-0.5f + fraction) * mLUTEntry[ipdg][inch + 1][irad][ieta][ipt]->eff2;
+        } else {
+          interpolatedEff = mLUTEntry[ipdg][inch][irad][ieta][ipt]->eff2;
+        }
+      }
+    } else {
+      float comparisonValue = mLUTHeader[ipdg]->nchmap.log ? log10(nch) : nch;
+      if (mWhatEfficiency == 1) {
+        if (inch > 0 && comparisonValue < mLUTHeader[ipdg]->nchmap.max) {
+          interpolatedEff = (0.5f + fraction) * mLUTEntry[ipdg][inch][irad][ieta][ipt]->eff + (0.5f - fraction) * mLUTEntry[ipdg][inch - 1][irad][ieta][ipt]->eff;
+        } else {
+          interpolatedEff = mLUTEntry[ipdg][inch][irad][ieta][ipt]->eff;
+        }
+      }
+      if (mWhatEfficiency == 2) {
+        if (inch > 0 && comparisonValue < mLUTHeader[ipdg]->nchmap.max) {
+          interpolatedEff = (0.5f + fraction) * mLUTEntry[ipdg][inch][irad][ieta][ipt]->eff2 + (0.5f - fraction) * mLUTEntry[ipdg][inch - 1][irad][ieta][ipt]->eff2;
+        } else {
+          interpolatedEff = mLUTEntry[ipdg][inch][irad][ieta][ipt]->eff2;
+        }
+      }
+    }
+  } else {
+    if (mWhatEfficiency == 1)
+      interpolatedEff = mLUTEntry[ipdg][inch][irad][ieta][ipt]->eff;
+    if (mWhatEfficiency == 2)
+      interpolatedEff = mLUTEntry[ipdg][inch][irad][ieta][ipt]->eff2;
+  }
   return mLUTEntry[ipdg][inch][irad][ieta][ipt];
 } //;
 
 /*****************************************************************/
 
-bool TrackSmearer::smearTrack(O2Track& o2track, lutEntry_t* lutEntry)
+bool TrackSmearer::smearTrack(O2Track& o2track, lutEntry_t* lutEntry, float interpolatedEff)
 {
+  bool isReconstructed = true;
   // generate efficiency
   if (mUseEfficiency) {
     auto eff = 0.;
     if (mWhatEfficiency == 1)
       eff = lutEntry->eff;
     if (mWhatEfficiency == 2)
       eff = lutEntry->eff2;
+    if (mInterpolateEfficiency)
+      eff = interpolatedEff;
     if (gRandom->Uniform() > eff)
-      return false;
+      isReconstructed = false;
   }
+
+  // return false already now in case not reco'ed
+  if (!isReconstructed && mSkipUnreconstructed)
+    return false;
+
   // transform params vector and smear
   double params_[5];
   for (int i = 0; i < 5; ++i) {
@@ -158,7 +208,7 @@ bool TrackSmearer::smearTrack(O2Track& o2track, lutEntry_t* lutEntry)
   // set covariance matrix
   for (int i = 0; i < 15; ++i)
     o2track.setCov(lutEntry->covm[i], i);
-  return true;
+  return isReconstructed;
 }
 
 /*****************************************************************/
@@ -171,31 +221,62 @@ bool TrackSmearer::smearTrack(O2Track& o2track, int pdg, float nch)
     pt *= 2.f;
   }
   auto eta = o2track.getEta();
-  auto lutEntry = getLUTEntry(pdg, nch, 0., eta, pt);
+  float interpolatedEff = 0.0f;
+  auto lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, interpolatedEff);
   if (!lutEntry || !lutEntry->valid)
     return false;
-  return smearTrack(o2track, lutEntry);
+  return smearTrack(o2track, lutEntry, interpolatedEff);
 }
 
 /*****************************************************************/
 // relative uncertainty on pt
 double TrackSmearer::getPtRes(int pdg, float nch, float eta, float pt)
 {
-  auto lutEntry = getLUTEntry(pdg, nch, 0., eta, pt);
+  float dummy = 0.0f;
+  auto lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, dummy);
   auto val = sqrt(lutEntry->covm[14]) * lutEntry->pt;
   return val;
 }
+
 /*****************************************************************/
 // relative uncertainty on eta
 double TrackSmearer::getEtaRes(int pdg, float nch, float eta, float pt)
 {
-  auto lutEntry = getLUTEntry(pdg, nch, 0., eta, pt);
-  auto sigmatgl = sqrt(lutEntry->covm[9]);           // sigmatgl2
-  auto etaRes = 1 / (sqrt(1 + sigmatgl * sigmatgl)); // propagate tgl to eta uncertainty
-  etaRes /= lutEntry->eta;                           // relative uncertainty
+  float dummy = 0.0f;
+  auto lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, dummy);
+  auto sigmatgl = sqrt(lutEntry->covm[9]);                   // sigmatgl2
+  auto etaRes = fabs(sin(2.0 * atan(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)
+{
+  float dummy = 0.0f;
+  auto lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, dummy);
+  auto val = sqrt(lutEntry->covm[14]) * pow(lutEntry->pt, 2);
+  return val;
+}
 
+/*****************************************************************/
+// absolute uncertainty on eta
+double TrackSmearer::getAbsEtaRes(int pdg, float nch, float eta, float pt)
+{
+  float dummy = 0.0f;
+  auto lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, dummy);
+  auto sigmatgl = sqrt(lutEntry->covm[9]);                   // sigmatgl2
+  auto etaRes = fabs(sin(2.0 * atan(exp(-eta)))) * sigmatgl; // propagate tgl to eta uncertainty
+  return etaRes;
+}
+/*****************************************************************/
+// efficiency
+double TrackSmearer::getEfficiency(int pdg, float nch, float eta, float pt)
+{
+  float efficiency = 0.0f;
+  getLUTEntry(pdg, nch, 0., eta, pt, efficiency);
+  return efficiency;
+}
 /*****************************************************************/
 // Only in DelphesO2
 // bool TrackSmearer::smearTrack(Track& track, bool atDCA)

ALICE3/Core/DelphesO2TrackSmearer.h

@@ -53,7 +53,23 @@ struct map_t {
     if (log)
       return pow(10., val);
     return val;
-  } //;
+  }
+  // function needed to interpolate some dimensions
+  float fracPositionWithinBin(float val)
+  {
+    float width = (max - min) / nbins;
+    int bin;
+    float returnVal = 0.5f;
+    if (log) {
+      bin = static_cast<int>((log10(val) - min) / width);
+      returnVal = ((log10(val) - min) / width) - bin;
+    } else {
+      bin = static_cast<int>((val - min) / width);
+      returnVal = val / width - bin;
+    }
+    return returnVal;
+  }
+
   int find(float val)
   {
     float width = (max - min) / nbins;
@@ -162,15 +178,20 @@ 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);
+  lutEntry_t* getLUTEntry(int pdg, float nch, float radius, float eta, float pt, float& interpolatedEff);
 
-  bool smearTrack(O2Track& o2track, lutEntry_t* lutEntry);
+  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);
 
   int getIndexPDG(int pdg)
   {
@@ -203,6 +224,8 @@ class TrackSmearer
   lutHeader_t* mLUTHeader[nLUTs] = {nullptr};
   lutEntry_t***** mLUTEntry[nLUTs] = {nullptr};
   bool mUseEfficiency = true;
+  bool mInterpolateEfficiency = false;
+  bool mSkipUnreconstructed = true; // don't smear tracks that are not reco'ed
   int mWhatEfficiency = 1;
   float mdNdEta = 1600.;
 };

ALICE3/DataModel/A3DecayFinderTables.h

@@ -0,0 +1,61 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+///
+/// \file   A3DecayFinderTables.h
+/// \since  04/07/2023
+/// \brief  Set of tables for ALICE 3 decay finder
+///
+
+#ifndef ALICE3_DATAMODEL_A3DECAYFINDERTABLES_H_
+#define ALICE3_DATAMODEL_A3DECAYFINDERTABLES_H_
+
+// O2 includes
+#include "Framework/AnalysisDataModel.h"
+
+enum a3selectionBit : uint32_t { kDCAxy = 0,
+                                 kInnerTOFPion,
+                                 kInnerTOFKaon,
+                                 kInnerTOFProton,
+                                 kOuterTOFPion,
+                                 kOuterTOFKaon,
+                                 kOuterTOFProton,
+                                 kRICHPion,
+                                 kRICHKaon,
+                                 kRICHProton,
+                                 kTruePion,
+                                 kTrueKaon,
+                                 kTrueProton,
+                                 kTruePiPlusFromD,
+                                 kTrueKaPlusFromD,
+                                 kTruePiMinusFromD,
+                                 kTrueKaMinusFromD,
+                                 kTruePiPlusFromLc,
+                                 kTrueKaPlusFromLc,
+                                 kTruePrPlusFromLc,
+                                 kTruePiMinusFromLc,
+                                 kTrueKaMinusFromLc,
+                                 kTruePrMinusFromLc };
+
+namespace o2::aod
+{
+namespace a3DecayMap
+{
+DECLARE_SOA_COLUMN(DecayMap, decayMap, uint32_t); //! simple map to process passing / not passing criteria
+} // namespace a3DecayMap
+DECLARE_SOA_TABLE(Alice3DecayMaps, "AOD", "ALICE3DECAYMAP",
+                  a3DecayMap::DecayMap);
+
+using Alice3DecayMap = Alice3DecayMaps::iterator;
+
+} // namespace o2::aod
+
+#endif // ALICE3_DATAMODEL_A3DECAYFINDERTABLES_H_

ALICE3/DataModel/OTFRICH.h

@@ -0,0 +1,46 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+///
+/// \file   OTFRICH.h
+/// \author Nicola Nicassio, University and INFN Bari
+/// \since  15/05/2023
+/// \brief  Set of tables for the ALICE 3 OTFRICH information
+///
+
+#ifndef ALICE3_DATAMODEL_OTFRICH_H_
+#define ALICE3_DATAMODEL_OTFRICH_H_
+
+// O2 includes
+#include "Framework/AnalysisDataModel.h"
+
+namespace o2::aod
+{
+namespace upgrade_rich
+{
+DECLARE_SOA_COLUMN(NSigmaElectronRich, nSigmaElectronRich, float); //! NSigma electron BarrelRich
+DECLARE_SOA_COLUMN(NSigmaMuonRich, nSigmaMuonRich, float);         //! NSigma muon BarrelRich
+DECLARE_SOA_COLUMN(NSigmaPionRich, nSigmaPionRich, float);         //! NSigma pion BarrelRich
+DECLARE_SOA_COLUMN(NSigmaKaonRich, nSigmaKaonRich, float);         //! NSigma kaon BarrelRich
+DECLARE_SOA_COLUMN(NSigmaProtonRich, nSigmaProtonRich, float);     //! NSigma proton BarrelRich
+} // namespace upgrade_rich
+DECLARE_SOA_TABLE(UpgradeRichs, "AOD", "UPGRADERICH",
+                  upgrade_rich::NSigmaElectronRich,
+                  upgrade_rich::NSigmaMuonRich,
+                  upgrade_rich::NSigmaPionRich,
+                  upgrade_rich::NSigmaKaonRich,
+                  upgrade_rich::NSigmaProtonRich);
+
+using UpgradeRich = UpgradeRichs::iterator;
+
+} // namespace o2::aod
+
+#endif // ALICE3_DATAMODEL_OTFRICH_H_