Merge branch 'AliceO2Group:master' into master

Author: Shunsuke-Kurita

.github/workflows/labeler.yml

@@ -41,73 +41,73 @@ jobs:
           labels = os.environ['labels']
           tags = {
               "infrastructure": "Infrastructure",
+              "scripts": "Scripts",
+              "tools": "Tools",
               "common": "Common",
+              "trigger": "Trigger",
+              "dpg": "DPG",
+              "tutorial": "Tutorial",
               "alice3": "ALICE3",
               "pwgcf": "PWGCF",
               "pwgdq": "PWGDQ",
               "pwgem": "PWGEM",
               "pwghf": "PWGHF",
               "pwgje": "PWGJE",
               "pwglf": "PWGLF",
+              "pwgmm": "PWGMM",
               "pwgud": "PWGUD",
-              "dpg": "DPG",
-              "trigger": "Trigger",
-              "tutorial": "Tutorial",
           }
           print(f'PR title: "{title}"')
           print(f'PR labels: "{labels}"')
           tags_relevant = [tags[label] for label in tags if label in labels.split(",")]
           print("Relevant title tags:", ",".join(tags_relevant))
-          passed = True
-          prefix_good = ",".join(tags_relevant)
-          prefix_good = f"[{prefix_good}] "
-          print(f"Generated prefix: {prefix_good}")
-          replace_title = 0
-          title_new = title
+          prefix_generated = ",".join(tags_relevant)
+          prefix_generated = f"[{prefix_generated}] "
+          print(f"Generated prefix: {prefix_generated}")
+          found_tags = False
+          title_new = title.strip()
           # If there is a prefix which contains a known tag, check it for correct tags, and reformat it if needed.
           # If there is a prefix which does not contain any known tag, add the tag prefix.
           # If there is no prefix, add the tag prefix.
-          if match := re.match(r"\[?(\w[\w, /\+-]+)[\]:]+ ", title):
+          if match := re.match(r" *\[?(\w[\w,/\+\- ]+)[\]: ]+ ", title):
               prefix_title = match.group(1)
               words_prefix_title = prefix_title.replace(",", " ").replace("/", " ").split()
-              title_stripped = title[len(match.group()) :]
+              title_stripped = title[len(match.group()) :].strip()
               print(f'PR title prefix: "{prefix_title}" -> tags: {words_prefix_title}')
               print(f'Stripped PR title: "{title_stripped}"')
               if any(tag in words_prefix_title for tag in tags.values()):
+                  found_tags = True
+                  passed = True
                   for tag in tags.values():
                       if tag in tags_relevant and tag not in words_prefix_title:
                           print(f'::error::Relevant tag "{tag}" not found in the prefix of the PR title.')
                           passed = False
                       if tag not in tags_relevant and tag in words_prefix_title:
                           print(f'::error::Irrelevant tag "{tag}" found in the prefix of the PR title.')
                           passed = False
-                  # Format a valid prefix.
-                  if passed:
-                      prefix_good = ",".join(w for w in prefix_title.replace(",", " ").split() if w)
-                      prefix_good = f"[{prefix_good}] "
-                      print(f"::notice::Reformatted prefix: {prefix_good}")
-                      if match.group() != prefix_good:
-                          replace_title = 1
-                          title_new = prefix_good + title_stripped
+                  if not passed:
+                      print("::error::Problems were found in the PR title prefix.")
+                      print('::notice::Use the form "tags: title" or "[tags] title".')
+                      sys.exit(1)
+                  # Form a valid title with the existing prefix.
+                  prefix_good = ",".join(w for w in prefix_title.replace(",", " ").split() if w)
+                  prefix_good = f"[{prefix_good}] "
+                  print(f'::notice::Reformatted prefix: "{prefix_good}"')
+                  title_new = prefix_good + title_stripped
               else:
                   print("::warning::No known tags found in the prefix.")
-                  if tags_relevant:
-                      replace_title = 1
-                      title_new = prefix_good + title
+                  title_new = " ".join((*match.group().split(), title_stripped))
           else:
               print("::warning::No valid prefix found in the PR title.")
-              if tags_relevant:
-                  replace_title = 1
-                  title_new = prefix_good + title
-          if not passed:
-              print("::error::Problems were found in the PR title prefix.")
-              print('::notice::Use the form "tags: title" or "[tags] title".')
-              sys.exit(1)
-          if replace_title:
-              print("::warning::The PR title prefix with tags needs to be added or adjusted.")
-              print(f'::warning::New title: "{title_new}".')
+          if not found_tags and tags_relevant:
+              title_new = prefix_generated + title_new.strip()
+          replace_title = 0
+          if title_new == title:
+              print("::notice::The PR title is fine.")
           else:
-              print("::notice::The PR title prefix is fine.")
+              replace_title = 1
+              print("::warning::The PR title needs to be adjusted.")
+              print(f'::warning::New title: "{title_new}".')
           with open(os.environ["GITHUB_OUTPUT"], "a", encoding="utf-8") as fh:
               print(f"replace={replace_title}", file=fh)
               print(f"title={title_new}", file=fh)

.github/workflows/mega-linter.yml

@@ -38,7 +38,7 @@ jobs:
         id: ml
         # You can override MegaLinter flavor used to have faster performances
         # More info at https://megalinter.io/flavors/
-        uses: oxsecurity/megalinter@v9.2.0
+        uses: oxsecurity/megalinter@v9.3.0
         env:
           # All available variables are described in documentation:
           # https://megalinter.io/configuration/

ALICE3/Core/Decayer.h

@@ -0,0 +1,145 @@
+// 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   Decayer.h
+/// \author Jesper Karlsson Gumprecht
+/// \since  15/12/2025
+/// \brief  Basic class to handle short-lived particle decays in the fast simulation
+///
+
+#ifndef ALICE3_CORE_DECAYER_H_
+#define ALICE3_CORE_DECAYER_H_
+
+#include "ALICE3/Core/TrackUtilities.h"
+
+#include "ReconstructionDataFormats/Track.h"
+
+#include <TDatabasePDG.h>
+#include <TDecayChannel.h>
+#include <TGenPhaseSpace.h>
+#include <TLorentzVector.h>
+#include <TParticlePDG.h>
+#include <TRandom3.h>
+
+#include <array>
+#include <cmath>
+#include <string>
+#include <vector>
+
+namespace o2
+{
+namespace upgrade
+{
+
+class Decayer
+{
+ public:
+  // Default constructor
+  Decayer() = default;
+
+  template <typename TDatabase>
+  std::vector<o2::upgrade::OTFParticle> decayParticle(const TDatabase& pdgDB, const o2::track::TrackParCov& track, const int pdgCode)
+  {
+    const auto& particleInfo = pdgDB->GetParticle(pdgCode);
+    const int charge = particleInfo->Charge() / 3;
+    const double mass = particleInfo->Mass();
+    std::array<float, 3> mom;
+    std::array<float, 3> pos;
+    track.getPxPyPzGlo(mom);
+    track.getXYZGlo(pos);
+
+    const double u = mRand3.Uniform(0, 1);
+    const double ctau = o2::constants::physics::LightSpeedCm2S * particleInfo->Lifetime(); // cm
+    const double betaGamma = track.getP() / mass;
+    const double rxyz = -betaGamma * ctau * std::log(1 - u);
+    double vx, vy, vz;
+    double px, py, e;
+
+    if (!charge) {
+      vx = pos[0] + rxyz * (mom[0] / track.getP());
+      vy = pos[1] + rxyz * (mom[1] / track.getP());
+      vz = pos[2] + rxyz * (mom[2] / track.getP());
+      px = mom[0];
+      py = mom[1];
+    } else {
+      float sna, csa;
+      o2::math_utils::CircleXYf_t circle;
+      track.getCircleParams(mBz, circle, sna, csa);
+      const double rxy = rxyz / std::sqrt(1. + track.getTgl() * track.getTgl());
+      const double theta = rxy / circle.rC;
+
+      vx = ((pos[0] - circle.xC) * std::cos(theta) - (pos[1] - circle.yC) * std::sin(theta)) + circle.xC;
+      vy = ((pos[1] - circle.yC) * std::cos(theta) + (pos[0] - circle.xC) * std::sin(theta)) + circle.yC;
+      vz = mom[2] + rxyz * (mom[2] / track.getP());
+
+      px = mom[0] * std::cos(theta) - mom[1] * std::sin(theta);
+      py = mom[1] * std::cos(theta) + mom[0] * std::sin(theta);
+    }
+
+    double brTotal = 0.;
+    e = std::sqrt(mass * mass + px * px + py * py + mom[2] * mom[2]);
+    for (int ch = 0; ch < particleInfo->NDecayChannels(); ++ch) {
+      brTotal += particleInfo->DecayChannel(ch)->BranchingRatio();
+    }
+
+    double brSum = 0.;
+    std::vector<double> dauMasses;
+    std::vector<int> pdgCodesDaughters;
+    const double randomChannel = mRand3.Uniform(0., brTotal);
+    for (int ch = 0; ch < particleInfo->NDecayChannels(); ++ch) {
+      brSum += particleInfo->DecayChannel(ch)->BranchingRatio();
+      if (randomChannel < brSum) {
+        for (int dau = 0; dau < particleInfo->DecayChannel(ch)->NDaughters(); ++dau) {
+          const int pdgDau = particleInfo->DecayChannel(ch)->DaughterPdgCode(dau);
+          pdgCodesDaughters.push_back(pdgDau);
+          const auto& dauInfo = pdgDB->GetParticle(pdgDau);
+          dauMasses.push_back(dauInfo->Mass());
+        }
+        break;
+      }
+    }
+
+    TLorentzVector tlv(px, py, mom[2], e);
+    TGenPhaseSpace decay;
+    decay.SetDecay(tlv, dauMasses.size(), dauMasses.data());
+    decay.Generate();
+
+    std::vector<o2::upgrade::OTFParticle> decayProducts;
+    for (size_t i = 0; i < dauMasses.size(); ++i) {
+      o2::upgrade::OTFParticle particle;
+      TLorentzVector dau = *decay.GetDecay(i);
+      particle.setPDG(pdgCodesDaughters[i]);
+      particle.setVxVyVz(vx, vy, vz);
+      particle.setPxPyPzE(dau.Px(), dau.Py(), dau.Pz(), dau.E());
+      decayProducts.push_back(particle);
+    }
+
+    return decayProducts;
+  }
+
+  void setSeed(const int seed)
+  {
+    mRand3.SetSeed(seed);   // For decay length sampling
+    gRandom->SetSeed(seed); // For TGenPhaseSpace
+  }
+
+  void setBField(const double b) { mBz = b; }
+
+ private:
+  TRandom3 mRand3;
+  double mBz;
+};
+
+} // namespace upgrade
+} // namespace o2
+
+#endif // ALICE3_CORE_DECAYER_H_

ALICE3/Core/FastTracker.cxx

@@ -314,88 +314,31 @@ void FastTracker::AddTPC(float phiResMean, float zResMean)
   }
 }
 
-std::map<std::string, std::map<std::string, std::string>> FastTracker::parseTEnvConfiguration(std::string filename)
+void FastTracker::AddGenericDetector(GeometryContainer::GeometryEntry configMap, o2::ccdb::BasicCCDBManager* ccdbManager)
 {
-  std::map<std::string, std::map<std::string, std::string>> configMap;
-
-  TEnv env(filename.c_str());
-  THashList* table = env.GetTable();
-  std::vector<std::string> layers;
-  for (int i = 0; i < table->GetEntries(); ++i) {
-    const std::string key = table->At(i)->GetName();
-    // key should contain exactly one dot
-    if (key.find('.') == std::string::npos || key.find('.') != key.rfind('.')) {
-      LOG(fatal) << "Key " << key << " does not contain exactly one dot";
+  // Layers
+  for (const auto& layer : configMap.getLayerNames()) {
+    if (layer.find("global") != std::string::npos) { // Layers with global tag are skipped
+      LOG(info) << " Skipping global configuration entry " << layer;
       continue;
     }
-    const std::string firstPart = key.substr(0, key.find('.'));
-    if (std::find(layers.begin(), layers.end(), firstPart) == layers.end()) {
-      layers.push_back(firstPart);
-    }
-  }
-  env.Print();
 
-  // Layers
-  for (const auto& layer : layers) {
     LOG(info) << " Reading layer " << layer;
-    for (int i = 0; i < table->GetEntries(); ++i) {
-      const std::string key = table->At(i)->GetName();
-      if (key.find(layer + ".") == 0) {
-        const std::string paramName = key.substr(key.find('.') + 1);
-        const std::string value = env.GetValue(key.c_str(), "");
-        configMap[layer][paramName] = value;
-      }
-    }
-  }
-  return configMap;
-}
-
-void FastTracker::AddGenericDetector(std::string filename, o2::ccdb::BasicCCDBManager* ccdbManager)
-{
-  LOG(info) << " Adding generic detector from file " << filename;
-  // If the filename starts with ccdb: then take the file from the ccdb
-  if (filename.rfind("ccdb:", 0) == 0) {
-    std::string ccdbPath = filename.substr(5); // remove "ccdb:" prefix
-    if (ccdbManager == nullptr) {
-      LOG(fatal) << "CCDB manager is null, cannot retrieve file " << ccdbPath;
-      return;
-    }
-    const std::string outPath = "/tmp/DetGeo/";
-    filename = Form("%s/%s/snapshot.root", outPath.c_str(), ccdbPath.c_str());
-    std::ifstream checkFile(filename); // Check if file already exists
-    if (!checkFile.is_open()) {        // File does not exist, retrieve from CCDB
-      LOG(info) << " --- CCDB source detected for detector geometry " << filename;
-      std::map<std::string, std::string> metadata;
-      ccdbManager->getCCDBAccessor().retrieveBlob(ccdbPath, outPath, metadata, 1);
-      // Add CCDB handling logic here if needed
-      LOG(info) << " --- Now retrieving geometry configuration from CCDB to: " << filename;
-    } else { // File exists, proceed to load
-      LOG(info) << " --- Geometry configuration file already exists: " << filename << ". Skipping download.";
-      checkFile.close();
-    }
-    AddGenericDetector(filename, nullptr);
-    return;
-  }
-
-  std::map<std::string, std::map<std::string, std::string>> configMap = parseTEnvConfiguration(filename);
-  // Layers
-  for (const auto& layer : configMap) {
-    LOG(info) << " Reading layer " << layer.first;
-    const float r = std::stof(layer.second.at("r"));
-    LOG(info) << " Layer " << layer.first << " has radius " << r;
-    const float z = std::stof(layer.second.at("z"));
-    const float x0 = std::stof(layer.second.at("x0"));
-    const float xrho = std::stof(layer.second.at("xrho"));
-    const float resRPhi = std::stof(layer.second.at("resRPhi"));
-    const float resZ = std::stof(layer.second.at("resZ"));
-    const float eff = std::stof(layer.second.at("eff"));
-    const int type = std::stoi(layer.second.at("type"));
-    const std::string deadPhiRegions = layer.second.at("deadPhiRegions");
+    const float r = configMap.getFloatValue(layer, "r");
+    LOG(info) << " Layer " << layer << " has radius " << r;
+    const float z = configMap.getFloatValue(layer, "z");
+    const float x0 = configMap.getFloatValue(layer, "x0");
+    const float xrho = configMap.getFloatValue(layer, "xrho");
+    const float resRPhi = configMap.getFloatValue(layer, "resRPhi");
+    const float resZ = configMap.getFloatValue(layer, "resZ");
+    const float eff = configMap.getFloatValue(layer, "eff");
+    const int type = configMap.getIntValue(layer, "type");
+    const std::string deadPhiRegions = configMap.getValue(layer, "deadPhiRegions", false);
 
     // void AddLayer(TString name, float r, float z, float x0, float xrho, float resRPhi = 0.0f, float resZ = 0.0f, float eff = 0.0f, int type = 0);
-    LOG(info) << " Adding layer " << layer.first << " r=" << r << " z=" << z << " x0=" << x0 << " xrho=" << xrho << " resRPhi=" << resRPhi << " resZ=" << resZ << " eff=" << eff << " type=" << type << " deadPhiRegions=" << deadPhiRegions;
+    LOG(info) << " Adding layer " << layer << " r=" << r << " z=" << z << " x0=" << x0 << " xrho=" << xrho << " resRPhi=" << resRPhi << " resZ=" << resZ << " eff=" << eff << " type=" << type << " deadPhiRegions=" << deadPhiRegions;
 
-    DetLayer* addedLayer = AddLayer(layer.first.c_str(), r, z, x0, xrho, resRPhi, resZ, eff, type);
+    DetLayer* addedLayer = AddLayer(layer.c_str(), r, z, x0, xrho, resRPhi, resZ, eff, type);
     if (!deadPhiRegions.empty()) { // Taking it as ccdb path or local file
                                    // Check if it begins with ccdb:
       if (std::string(deadPhiRegions).rfind("ccdb:", 0) == 0) {
@@ -418,7 +361,7 @@ void FastTracker::AddGenericDetector(std::string filename, o2::ccdb::BasicCCDBMa
         addedLayer->setDeadPhiRegions(g);
       }
     } else {
-      LOG(debug) << " No dead phi regions for layer " << layer.first;
+      LOG(debug) << " No dead phi regions for layer " << layer;
     }
   }
 }