Merge branch 'master' into pp_correl

Author: Marcellocosti

.pre-commit-config.yaml

@@ -2,15 +2,47 @@
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v6.0.0
+    rev: 3e8a8703264a2f4a69428a0aa4dcb512790b2c8c # frozen: v6.0.0
     hooks:
-      - id: trailing-whitespace
+      - id: check-added-large-files
+      - id: check-ast
+      - id: check-case-conflict
+      - id: check-executables-have-shebangs
+      - id: check-merge-conflict
+      - id: check-symlinks
+      - id: check-yaml
       - id: end-of-file-fixer
+      - id: trailing-whitespace
+  - repo: https://github.com/shellcheck-py/shellcheck-py
+    rev: a6564f5d57444e123433a5c9af733e3975c77229 # frozen: v0.11.0.1-1
+    hooks:
+      - id: shellcheck
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: f12be1ebaa5351c1fc76472de98db2c3446c8253 # frozen: v0.16.10
+    hooks:
+      - id: ruff-check # linter
+        args: ["--fix"]
+      - id: ruff-format # formatter
+  - repo: local
+    hooks:
+      - id: format-includes
+        name: format includes
+        language: python
+        entry: Scripts/format_includes.py
+        types: [c++]
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v20.1.3 # clang-format version (keep synced with https://github.com/alisw/ali-bot/blob/master/.github/workflows/c++-code-formatting.yml)
+    # clang-format version (keep synced with https://github.com/alisw/ali-bot/blob/master/.github/workflows/c++-code-formatting.yml)
+    rev: 7ec07eeb4135dc6ecf410d24ac4ead986a5d413d # frozen: v20.1.3
     hooks:
       - id: clang-format
   - repo: https://github.com/cpplint/cpplint
-    rev: 2.0.2
+    rev: 350702a4d39395571bd118c9a3cff0a573488d61 # frozen: 2.0.2
     hooks:
       - id: cpplint
+  - repo: local
+    hooks:
+      - id: O2 linter
+        name: O2 linter
+        language: python
+        entry: Scripts/o2_linter.py
+        types_or: [c++, cmake, python]

ALICE3/Core/DetLayer.h

@@ -108,25 +108,25 @@ struct DetLayer {
   TString mName;
 
   // position variables
-  float mR; // radius in centimeters
-  float mZ; // mZ dimension in centimeters
+  float mR{}; // radius in centimeters
+  float mZ{}; // mZ dimension in centimeters
 
   // material variables
-  float mX0;   // radiation length
-  float mXrho; // density
+  float mX0{};   // radiation length
+  float mXrho{}; // density
 
   // resolution variables for active layers
-  float mResRPhi; // RPhi resolution in centimeters
-  float mResZ;    // Z resolution in centimeters
+  float mResRPhi{}; // RPhi resolution in centimeters
+  float mResZ{};    // Z resolution in centimeters
 
   // efficiency
-  float mEff; // detection efficiency
+  float mEff{1.f}; // detection efficiency
 
   // dead regions in phi (in radians)
   TGraph* mDeadPhiRegions = nullptr;
 
   // layer type
-  int mType; // 0: undefined/inert, 1: silicon, 2: gas/tpc
+  int mType{0}; // 0: undefined/inert, 1: silicon, 2: gas/tpc
 };
 
 } // namespace o2::fastsim

ALICE3/Core/FastTracker.cxx

@@ -312,6 +312,8 @@ int FastTracker::fastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackPa
   nIntercepts = 0;
   nSiliconPoints = 0;
   nGasPoints = 0;
+  trackIU = -1.f;
+  trackOU = -1.f;
   std::array<float, 3> posIni{}; // provision for != PV
   inputTrack.getXYZGlo(posIni);
   const float initialRadius = std::hypot(posIni[0], posIni[1]);
@@ -416,6 +418,9 @@ int FastTracker::fastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackPa
       firstLayerReached = il;
     }
     lastLayerReached = il;
+    if (layers[il].isTOF()) {
+      continue; // TOF layers are not used for tracking, but are kept in range for the innermost/outermost update
+    }
     nIntercepts++;
   }
 
@@ -475,7 +480,7 @@ int FastTracker::fastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackPa
       continue;
     }
 
-    if (!layers[il].isInert()) { // only update covm for tracker hits
+    if (!layers[il].isInert() && !layers[il].isTOF()) { // only update covm for tracker hits
       const o2::track::TrackParametrization<float>::dim2_t hitpoint = {xyz1[1], xyz1[2]};
       const o2::track::TrackParametrization<float>::dim3_t hitpointcov = {layers[il].getResolutionRPhi() * layers[il].getResolutionRPhi(), 0.f, layers[il].getResolutionZ() * layers[il].getResolutionZ()};
 
@@ -510,7 +515,14 @@ int FastTracker::fastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackPa
     }
 
     hits.push_back(thisHit);
-    if (!layers[il].isInert()) { // good hit probability calculation
+    if (!layers[il].isInert()) {
+      trackIU = std::hypot(spacePoint[0], spacePoint[1]);
+      if (trackOU < 0.f) {
+        trackOU = trackIU;
+      }
+    }
+
+    if (!layers[il].isInert() && !layers[il].isTOF()) { // good hit probability calculation
       float sigYCmb = o2::math_utils::sqrt(inwardTrack.getSigmaY2() + layers[il].getResolutionRPhi() * layers[il].getResolutionRPhi());
       float sigZCmb = o2::math_utils::sqrt(inwardTrack.getSigmaZ2() + layers[il].getResolutionZ() * layers[il].getResolutionZ());
       goodHitProbability[il] = probGoodChiSqHit(layers[il].getRadius() * 100, sigYCmb * 100, sigZCmb * 100);

ALICE3/Core/FastTracker.h

@@ -58,7 +58,7 @@ class FastTracker
   /// \param phiEnd End angle of the dead region (in radians)
   void addDeadPhiRegionInLayer(const std::string& layerName, float phiStart, float phiEnd);
   [[nodiscard]] DetLayer getLayer(const int layer) const { return layers[layer]; }
-  [[nodiscard]] std::vector<DetLayer> getLayers() const { return layers; }
+  [[nodiscard]] const std::vector<DetLayer>& getLayers() const { return layers; }
   [[nodiscard]] int getLayerIndex(const std::string& name) const;
   [[nodiscard]] size_t getNLayers() const { return layers.size(); }
   [[nodiscard]] bool isLayerInert(const int layer) const { return layers[layer].isInert(); }
@@ -127,6 +127,8 @@ class FastTracker
   [[nodiscard]] int getNIntercepts() const { return nIntercepts; }
   [[nodiscard]] int getNSiliconPoints() const { return nSiliconPoints; }
   [[nodiscard]] int getNGasPoints() const { return nGasPoints; }
+  [[nodiscard]] float getTrackIU() const { return trackIU; }
+  [[nodiscard]] float getTrackOU() const { return trackOU; }
   [[nodiscard]] float getGoodHitProb(int layer) const
   {
     return (layer >= 0 && static_cast<size_t>(layer) < goodHitProbability.size()) ? goodHitProbability[layer] : 0.0f;
@@ -172,6 +174,8 @@ class FastTracker
   int nIntercepts = 0;    /// found in first outward propagation
   int nSiliconPoints = 0; /// silicon-based space points added to track
   int nGasPoints = 0;     /// tpc-based space points added to track
+  float trackIU = -1.f;   /// innermost update: radius of the innermost active-layer hit added to track
+  float trackOU = -1.f;   /// outermost update: radius of the outermost active-layer hit added to track
   std::vector<float> goodHitProbability;
 
   ClassDef(FastTracker, 1);

ALICE3/Core/FlatLutEntry.cxx

@@ -140,23 +140,23 @@ size_t FlatLutData::getEntryOffset(int nch_bin, int rad_bin, int eta_bin, int pt
 const lutEntry_t* FlatLutData::getEntryRef(int nch_bin, int rad_bin, int eta_bin, int pt_bin) const
 {
   size_t offset = getEntryOffset(nch_bin, rad_bin, eta_bin, pt_bin);
-  return reinterpret_cast<const lutEntry_t*>(mDataRef.data() + offset);
+  return reinterpret_cast<const lutEntry_t*>(mDataRef.data() + offset); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
 }
 
 lutEntry_t* FlatLutData::getEntry(int nch_bin, int rad_bin, int eta_bin, int pt_bin)
 {
   size_t offset = getEntryOffset(nch_bin, rad_bin, eta_bin, pt_bin);
-  return reinterpret_cast<lutEntry_t*>(mData.data() + offset);
+  return reinterpret_cast<lutEntry_t*>(mData.data() + offset); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
 }
 
 const lutHeader_t& FlatLutData::getHeaderRef() const
 {
-  return *static_cast<const lutHeader_t*>(static_cast<const void*>(mDataRef.data()));
+  return *reinterpret_cast<const lutHeader_t*>(mDataRef.data()); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
 }
 
 lutHeader_t& FlatLutData::getHeader()
 {
-  return *static_cast<lutHeader_t*>(static_cast<void*>(mData.data()));
+  return *reinterpret_cast<lutHeader_t*>(mData.data()); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
 }
 
 void FlatLutData::updateRef()
@@ -216,7 +216,7 @@ lutHeader_t FlatLutData::previewHeader(const uint8_t* buffer, size_t size)
   if (size < sizeof(lutHeader_t)) {
     throw framework::runtime_error_f("Buffer too small for LUT header: expected at least %zu, got %zu", sizeof(lutHeader_t), size);
   }
-  const auto* header = static_cast<const lutHeader_t*>(static_cast<const void*>(buffer));
+  const auto* header = reinterpret_cast<const lutHeader_t*>(buffer); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
   if (!header->checkVersion()) {
     throw framework::runtime_error_f("LUT header version mismatch: expected %d, got %d", LUTCOVM_VERSION, header->version);
   }
@@ -246,7 +246,7 @@ FlatLutData FlatLutData::ViewFromBuffer(const uint8_t* buffer, size_t size)
 
 FlatLutData FlatLutData::ViewFromBuffer(std::span<std::byte> const& span)
 {
-  return ViewFromBuffer(reinterpret_cast<const uint8_t*>(span.data()), span.size_bytes());
+  return ViewFromBuffer(reinterpret_cast<const uint8_t*>(span.data()), span.size_bytes()); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
 }
 
 bool FlatLutData::isLoaded() const
@@ -257,7 +257,7 @@ bool FlatLutData::isLoaded() const
 lutHeader_t FlatLutData::previewHeader(std::ifstream& file, const char* filename)
 {
   lutHeader_t tempHeader;
-  file.read(reinterpret_cast<char*>(&tempHeader), sizeof(lutHeader_t));
+  file.read(reinterpret_cast<char*>(&tempHeader), sizeof(lutHeader_t)); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
   if (file.gcount() != static_cast<std::streamsize>(sizeof(lutHeader_t))) {
     throw framework::runtime_error_f("Failed to read LUT header from %s", filename);
   }
@@ -282,7 +282,7 @@ FlatLutData FlatLutData::loadFromFile(std::ifstream& file, const char* filename)
   size_t numEntries = static_cast<size_t>(data.mNchBins) * data.mRadBins * data.mEtaBins * data.mPtBins;
   size_t entriesSize = numEntries * sizeof(lutEntry_t);
 
-  file.read(reinterpret_cast<char*>(data.data() + headerSize), entriesSize);
+  file.read(reinterpret_cast<char*>(data.data() + headerSize), entriesSize); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
   if (file.gcount() != static_cast<std::streamsize>(entriesSize)) {
     throw framework::runtime_error_f("Failed to read LUT entries from %s: expected %zu bytes, got %zu", filename, entriesSize, static_cast<size_t>(file.gcount()));
   }

ALICE3/Core/FlatLutWriter.cxx

@@ -266,7 +266,7 @@ void FlatLutWriter::lutWrite(const char* filename, int pdg, float field, size_t
   setMap(lutHeader.ptmap, mPtBinning);
 
   // Write header to file
-  lutFile.write(reinterpret_cast<char*>(&lutHeader), sizeof(lutHeader_t));
+  lutFile.write(reinterpret_cast<char*>(&lutHeader), sizeof(lutHeader_t)); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
   if (!lutFile.good()) {
     LOGF(error, "Failed to write LUT header to %s", filename);
     lutFile.close();
@@ -361,7 +361,7 @@ void FlatLutWriter::lutWrite(const char* filename, int pdg, float field, size_t
           diagonalise(lutEntry);
 
           // Write entry to file
-          lutFile.write(reinterpret_cast<char*>(&lutEntry), sizeof(lutEntry_t));
+          lutFile.write(reinterpret_cast<char*>(&lutEntry), sizeof(lutEntry_t)); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
           if (!lutFile.good()) {
             LOGF(error, "Failed to write LUT entry at index [%d,%d,%d,%d]", inch, irad, ieta, ipt);
             lutFile.close();

ALICE3/Core/FlatTrackSmearer.cxx

@@ -171,7 +171,7 @@ bool TrackSmearer::viewTable(int pdg, const uint8_t* buffer, size_t size, bool f
 
 bool TrackSmearer::viewTable(int pdg, std::span<std::byte> const& span, bool forceReload)
 {
-  return viewTable(pdg, reinterpret_cast<const uint8_t*>(span.data()), span.size_bytes(), forceReload);
+  return viewTable(pdg, reinterpret_cast<const uint8_t*>(span.data()), span.size_bytes(), forceReload); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
 }
 
 bool TrackSmearer::hasTable(int pdg) const

ALICE3/Core/GeometryContainer.cxx

@@ -19,7 +19,6 @@
 
 #include "Common/Core/TableHelper.h"
 
-#include <CCDB/BasicCCDBManager.h>
 #include <Framework/InitContext.h>
 #include <Framework/Logger.h>
 
@@ -41,15 +40,15 @@ void GeometryContainer::init(o2::framework::InitContext& initContext)
   }
   LOG(info) << "Size of detector configuration: " << detectorConfiguration.size();
 
-  bool cleanLutWhenLoaded;
-  const bool foundCleanLutWhenLoaded = common::core::getTaskOptionValue(initContext, "on-the-fly-detector-geometry-provider", "cleanLutWhenLoaded", cleanLutWhenLoaded, false);
+  bool cleanLut;
+  const bool foundCleanLutWhenLoaded = common::core::getTaskOptionValue(initContext, "on-the-fly-detector-geometry-provider", "cleanLutWhenLoaded", cleanLut, false);
   if (!foundCleanLutWhenLoaded) {
     LOG(fatal) << "Could not retrieve foundCleanLutWhenLoaded option from OnTheFlyDetectorGeometryProvider task.";
     return;
   }
-  setLutCleanupSetting(cleanLutWhenLoaded);
+  setLutCleanupSetting(cleanLut);
 
-  for (std::string& configFile : detectorConfiguration) {
+  for (const std::string& configFile : detectorConfiguration) {
     LOG(info) << "Detector geometry configuration file used: " << configFile;
     addEntry(configFile);
   }

ALICE3/Core/GeometryContainer.h

@@ -36,18 +36,18 @@ struct GeometryEntry {
   // Default constructor
   GeometryEntry() = default;
   explicit GeometryEntry(const std::string& filename, o2::ccdb::BasicCCDBManager* ccdb = nullptr)
+    : mFileName(ConfigurationParser::accessFile(filename, "./.ALICE3/Configuration/", ccdb))
   {
-    mFileName = ConfigurationParser::accessFile(filename, "./.ALICE3/Configuration/", ccdb);
     mConfigurations = ConfigurationParser::parseTEnvConfiguration(mFileName, mLayerNames);
     LOG(info) << "Loaded geometry configuration from file: " << mFileName << " with " << mLayerNames.size() << " layers.";
     if (mLayerNames.empty()) {
       LOG(warning) << "No layers found in geometry configuration file: " << filename;
     }
   }
 
-  std::map<std::string, std::map<std::string, std::string>> getConfigurations() const { return mConfigurations; }
+  const std::map<std::string, std::map<std::string, std::string>>& getConfigurations() const { return mConfigurations; }
   std::map<std::string, std::string> getConfiguration(const std::string& layerName) const;
-  std::vector<std::string> getLayerNames() const { return mLayerNames; }
+  const std::vector<std::string>& getLayerNames() const { return mLayerNames; }
   bool hasValue(const std::string& layerName, const std::string& key) const;
   std::string getValue(const std::string& layerName, const std::string& key, bool require = true) const;
   void setValue(const std::string& layerName, const std::string& key, const std::string& value) { mConfigurations[layerName][key] = value; }

ALICE3/DataModel/OTFMID.h

@@ -0,0 +1,68 @@
+// 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   OTFMID.h
+/// \author David Dobrigkeit Chinellato
+/// \author Antonio Ortiz, UNAM
+/// \since  11/05/2023
+/// \brief  Set of tables for the ALICE3 OTFMID information
+/// TODO: remove the columns that are not usefulf for me
+
+#ifndef ALICE3_DATAMODEL_OTFMID_H_
+#define ALICE3_DATAMODEL_OTFMID_H_
+
+#include <Framework/AnalysisDataModel.h>
+
+#include <cstdlib>
+#include <vector>
+
+namespace o2::aod
+{
+namespace upgrade_mid
+{
+DECLARE_SOA_COLUMN(MIDTrackTime, midTrackTime, float);     //! Track time generated at the MID
+DECLARE_SOA_COLUMN(MIDTrackLength, midTrackLength, float); //! track length for calculation of MID (generated)
+
+DECLARE_SOA_COLUMN(MIDEventTime, midEventTime, float);                    //! Event time reconstructed with the MID
+DECLARE_SOA_COLUMN(MIDEventTimeErr, midEventTimeErr, float);              //! Uncertainty on the event time reconstructed with the MID
+DECLARE_SOA_COLUMN(MIDTrackPosReco, midTrackPosReco, std::vector<float>); //! Measured position in MID
+DECLARE_SOA_COLUMN(MIDTrackPos, midTrackPos, std::vector<float>);         //! Expected position in MID
+DECLARE_SOA_COLUMN(MIDCandidate, midCandidate, bool);                     //! Muon candidate
+DECLARE_SOA_COLUMN(MIDTrackTimeReco, midTrackTimeReco, float);            //! Track time measured at MID
+DECLARE_SOA_COLUMN(MIDTrackLengthReco, midTrackLengthReco, float);        //! track length for calculation of MID (reconstructed)
+
+} // namespace upgrade_mid
+
+DECLARE_SOA_TABLE(UpgradeMidMCs, "AOD", "UPGRADEMIDMC",
+                  upgrade_mid::MIDTrackTime,
+                  upgrade_mid::MIDTrackLength);
+
+DECLARE_SOA_TABLE(UpgradeMids, "AOD", "UPGRADEMID",
+                  upgrade_mid::MIDEventTime,
+                  upgrade_mid::MIDEventTimeErr,
+                  upgrade_mid::MIDTrackPosReco,
+                  upgrade_mid::MIDTrackTimeReco,
+                  upgrade_mid::MIDTrackLengthReco,
+                  upgrade_mid::MIDCandidate);
+
+DECLARE_SOA_TABLE(UpgradeMidExpecteds, "AOD", "UPGRADEMIDEXPT",
+                  upgrade_mid::MIDTrackPos,
+                  upgrade_mid::MIDTrackTime,
+                  upgrade_mid::MIDTrackLength);
+
+using UpgradeMidMC = UpgradeMidMCs::iterator;
+using UpgradeMid = UpgradeMids::iterator;
+using UpgradeMidExpected = UpgradeMidExpecteds::iterator;
+
+} // namespace o2::aod
+
+#endif // ALICE3_DATAMODEL_OTFMID_H_