Merge branch 'dev' into onnx_gpu_implementation

Author: ChSonnabend

.github/workflows/clean-test.yml

@@ -19,10 +19,6 @@ name: Clean PR checks
       # Warning: the check_* keys are magic and must consist of the string
       # "check_" followed by the applicable check name exactly. The
       # "description" field is only the human-readable label for the input.
-      'check_build/O2/o2':
-        description: build/O2/o2
-        type: boolean
-        default: true
       'check_build/AliceO2/O2/o2/macOS':
         description: build/AliceO2/O2/o2/macOS
         type: boolean
@@ -31,14 +27,10 @@ name: Clean PR checks
         description: build/AliceO2/O2/o2/macOS-arm
         type: boolean
         default: true
-      'check_build/O2/fullCI':
+      'check_build/O2/fullCI_slc9':
         description: build/O2/fullCI
         type: boolean
         default: true
-      'check_build/O2/o2-cs8':
-        description: build/O2/o2-cs8
-        type: boolean
-        default: true
       'check_build/O2/o2-dataflow-cs8':
         description: build/O2/o2-dataflow-cs8
         type: boolean

DataFormats/Detectors/FIT/FT0/include/DataFormatsFT0/RecPoints.h

@@ -24,18 +24,20 @@
 #include "Rtypes.h"
 #include <TObject.h>
 #include <gsl/span>
-
+#include <string>
+#include <utility>
+#include <map>
 namespace o2
 {
 namespace ft0
 {
 
 struct ChannelDataFloat {
 
-  int ChId = -1;           //channel Id
-  int ChainQTC = -1;       //QTC chain
-  float CFDTime = -20000;  //time in ps, 0 at the LHC clk center
-  float QTCAmpl = -20000;  // Amplitude mV
+  int ChId = -1;          // channel Id
+  int ChainQTC = -1;      // QTC chain
+  float CFDTime = -20000; // time in ps, 0 at the LHC clk center
+  float QTCAmpl = -20000; // Amplitude mV
 
   ChannelDataFloat() = default;
   ChannelDataFloat(int iPmt, float time, float charge, int chainQTC)
@@ -56,10 +58,39 @@ class RecPoints
 {
 
  public:
-  enum : int { TimeMean,
-               TimeA,
-               TimeC,
-               Vertex };
+  enum ETimeType { kTimeMean,
+                   kTimeA,
+                   kTimeC,
+                   kTimeVertex };
+
+  // Enum for trigger nits specified in rec-points and AOD data
+  enum ETriggerBits { kOrA = 0,           // OrA time-trigger signal
+                      kOrC = 1,           // OrC time-trigger signal
+                      kSemiCentral = 2,   // Semi-central amplitude-trigger signal
+                      kCentral = 3,       // Central amplitude-trigger signal
+                      kVertex = 4,        // Vertex time-trigger signal
+                      kIsActiveSideA = 5, // Side-A has at least one channel active
+                      kIsActiveSideC = 6, // Side-C has at least one channel active
+                      kIsFlangeEvent = 7  // Flange event at Side-C, at least one channel has time which corresponds to -82 cm area
+  };
+  static const inline std::map<unsigned int, std::string> sMapTriggerBits = {
+    {ETriggerBits::kOrA, "OrA"},
+    {ETriggerBits::kOrC, "OrC"},
+    {ETriggerBits::kSemiCentral, "Semicentral"},
+    {ETriggerBits::kCentral, "Central"},
+    {ETriggerBits::kVertex, "Vertex"},
+    {ETriggerBits::kIsActiveSideA, "IsActiveSideA"},
+    {ETriggerBits::kIsActiveSideC, "IsActiveSideC"},
+    {ETriggerBits::kIsFlangeEvent, "IsFlangeEvent"}};
+
+  enum ETechnicalBits { kLaser = 0,             // indicates the laser was triggered in this BC
+                        kOutputsAreBlocked = 1, // indicates that laser-induced pulses should arrive from detector to FEE in this BC (and trigger outputs are blocked)
+                        kDataIsValid = 2,       // data is valid for processing
+  };
+  static const inline std::map<unsigned int, std::string> sMapTechnicalBits = {
+    {ETechnicalBits::kLaser, "Laser"},
+    {ETechnicalBits::kOutputsAreBlocked, "OutputsAreBlocked"},
+    {ETechnicalBits::kDataIsValid, "DataIsValid"}};
 
   o2::dataformats::RangeReference<int, int> ref;
   o2::InteractionRecord mIntRecord; // Interaction record (orbit, bc)
@@ -73,39 +104,63 @@ class RecPoints
     mIntRecord = iRec;
     mTriggers = chTrig;
   }
+  RecPoints(int chDataFirstEntryPos,
+            int chDataNEntries,
+            const o2::InteractionRecord& ir,
+            const std::array<short, 4>& arrTimes,
+            const o2::fit::Triggers& digitTriggers,
+            uint8_t extraTriggerWord) : mIntRecord(ir), mCollisionTime(arrTimes), mTriggers(digitTriggers)
+  {
+    ref.setFirstEntry(chDataFirstEntryPos);
+    ref.setEntries(chDataNEntries);
+    initRecPointTriggers(digitTriggers, extraTriggerWord);
+  }
+
   ~RecPoints() = default;
 
   short getCollisionTime(int side) const { return mCollisionTime[side]; }
-  short getCollisionTimeMean() const { return getCollisionTime(TimeMean); }
-  short getCollisionTimeA() const { return getCollisionTime(TimeA); }
-  short getCollisionTimeC() const { return getCollisionTime(TimeC); }
+  short getCollisionTimeMean() const { return getCollisionTime(kTimeMean); }
+  short getCollisionTimeA() const { return getCollisionTime(kTimeA); }
+  short getCollisionTimeC() const { return getCollisionTime(kTimeC); }
   bool isValidTime(int side) const { return getCollisionTime(side) < o2::InteractionRecord::DummyTime; }
   void setCollisionTime(short time, int side) { mCollisionTime[side] = time; }
 
-  short getVertex() const { return getCollisionTime(Vertex); }
-  void setVertex(short vertex) { mCollisionTime[Vertex] = vertex; }
+  short getVertex() const { return getCollisionTime(kTimeVertex); }
+  void setVertex(short vertex) { mCollisionTime[kTimeVertex] = vertex; }
 
   o2::fit::Triggers getTrigger() const { return mTriggers; }
   void setTriggers(o2::fit::Triggers trig) { mTriggers = trig; }
+  uint8_t getTechnicalWord() const { return mTechnicalWord; }
+  static constexpr uint8_t makeExtraTrgWord(bool isActiveA = true, bool isActiveC = true, bool isFlangeEvent = true)
+  {
+    return (static_cast<uint8_t>(isActiveA) << kIsActiveSideA) |
+           (static_cast<uint8_t>(isActiveC) << kIsActiveSideC) |
+           (static_cast<uint8_t>(isFlangeEvent) << kIsFlangeEvent);
+  }
 
   o2::InteractionRecord getInteractionRecord() const { return mIntRecord; };
-
-  // void SetMgrEventTime(Double_t time) { mTimeStamp = time; }
-
   gsl::span<const ChannelDataFloat> getBunchChannelData(const gsl::span<const ChannelDataFloat> tfdata) const;
   short static constexpr sDummyCollissionTime = 32767;
 
   void print() const;
   bool operator==(const RecPoints&) const = default;
 
  private:
+  void initRecPointTriggers(const o2::fit::Triggers& digitTriggers, uint8_t extraTrgWord = 0)
+  {
+    const auto digitTriggerWord = digitTriggers.getTriggersignals();
+    const auto trgAndTechWordPair = o2::fit::Triggers::parseDigitTriggerWord(digitTriggerWord, true);
+    mTriggers.setTriggers(trgAndTechWordPair.first | extraTrgWord);
+    mTechnicalWord = trgAndTechWordPair.second;
+  }
+
   std::array<short, 4> mCollisionTime = {sDummyCollissionTime,
                                          sDummyCollissionTime,
                                          sDummyCollissionTime,
                                          sDummyCollissionTime};
   o2::fit::Triggers mTriggers; // pattern of triggers  in this BC
-
-  ClassDefNV(RecPoints, 3);
+  uint8_t mTechnicalWord{0};   // field for keeping ETechnicalBits
+  ClassDefNV(RecPoints, 4);
 };
 } // namespace ft0
 } // namespace o2

DataFormats/Detectors/FIT/common/include/DataFormatsFIT/Triggers.h

@@ -70,6 +70,12 @@ class Triggers
   {
     return trgWord | (static_cast<uint64_t>(checkMinBiasFT0(trgWord)) << bitMinBias);
   }
+  static constexpr std::pair<uint8_t, uint8_t> parseDigitTriggerWord(uint8_t digitWord, bool shiftTechBitsToBegin = false)
+  {
+    const uint8_t techWordMask = word(bitLaser, bitOutputsAreBlocked, bitDataIsValid);
+    const uint8_t shiftTechWordPos = shiftTechBitsToBegin ? bitLaser : 0;
+    return {(digitWord & (~techWordMask)), (digitWord & techWordMask) >> shiftTechWordPos};
+  }
 
   bool getOrA() const { return (triggersignals & (1 << bitA)) != 0; }
   bool getOrC() const { return (triggersignals & (1 << bitC)) != 0; }               // only used by FT0/FDD (same bit as OrAOut in FV0)
@@ -104,6 +110,10 @@ class Triggers
     timeA = atimeA;
     timeC = atimeC;
   }
+  void setTriggers(uint8_t trgsig)
+  {
+    triggersignals = trgsig;
+  }
 
   void setTriggers(Bool_t isA, Bool_t isC, Bool_t isVrtx, Bool_t isCnt, Bool_t isSCnt, uint8_t chanA, uint8_t chanC, int32_t aamplA,
                    int32_t aamplC, int16_t atimeA, int16_t atimeC, Bool_t isLaser, Bool_t isOutputsAreBlocked, Bool_t isDataValid)

Detectors/FIT/FT0/macros/FT0Misaligner.C

@@ -1,15 +1,30 @@
+// Copyright 2021-2025 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  FT0Misaligner.C
+/// \brief ROOT macro for creating an FT0 geometry alignment object. Based on ITSMisaligner.C
+///
+/// \author Andreas Molander andreas.molander@cern.ch, Alla Maevskaya
+
 #if !defined(__CLING__) || defined(__ROOTCLING__)
-//#define ENABLE_UPGRADES
+
+#include "CCDB/CcdbApi.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "DetectorsCommonDataFormats/DetectorNameConf.h"
 #include "DetectorsCommonDataFormats/AlignParam.h"
-#include "DetectorsBase/GeometryManager.h"
-#include "CCDB/CcdbApi.h"
-#include "FT0Base/Geometry.h"
-#include <TRandom.h>
+
 #include <TFile.h>
 #include <vector>
 #include <fmt/format.h>
+
 #endif
 
 using AlgPar = std::array<double, 6>;
@@ -23,19 +38,15 @@ void FT0Misaligner(const std::string& ccdbHost = "http://ccdb-test.cern.ch:8080"
                    const std::string& fileName = "FT0Alignment.root")
 {
   std::vector<o2::detectors::AlignParam> params;
-  o2::base::GeometryManager::loadGeometry("", false);
-  //  auto geom = o2::ft0::Geometry::Instance();
   AlgPar pars;
   bool glo = true;
 
   o2::detectors::DetID detFT0("FT0");
 
-  // FT0 detector
-  //set A side
   std::string symNameA = "FT0A";
   pars = generateMisalignment(xA, yA, zA, psiA, thetaA, phiA);
   params.emplace_back(symNameA.c_str(), -1, pars[0], pars[1], pars[2], pars[3], pars[4], pars[5], glo);
-  //set C side
+
   std::string symNameC = "FT0C";
   pars = generateMisalignment(xC, yC, zC, psiC, thetaC, phiC);
   params.emplace_back(symNameC.c_str(), -1, pars[0], pars[1], pars[2], pars[3], pars[4], pars[5], glo);
@@ -57,14 +68,15 @@ void FT0Misaligner(const std::string& ccdbHost = "http://ccdb-test.cern.ch:8080"
     algFile.Close();
   }
 }
+
 AlgPar generateMisalignment(double x, double y, double z, double psi, double theta, double phi)
 {
   AlgPar pars;
-  pars[0] = gRandom->Gaus(0, x);
-  pars[1] = gRandom->Gaus(0, y);
-  pars[2] = gRandom->Gaus(0, z);
-  pars[3] = gRandom->Gaus(0, psi);
-  pars[4] = gRandom->Gaus(0, theta);
-  pars[5] = gRandom->Gaus(0, phi);
+  pars[0] = x;
+  pars[1] = y;
+  pars[2] = z;
+  pars[3] = psi;
+  pars[4] = theta;
+  pars[5] = phi;
   return std::move(pars);
 }

Detectors/FIT/FT0/reconstruction/src/CollisionTimeRecoTask.cxx

@@ -58,6 +58,10 @@ RP CollisionTimeRecoTask::processDigit(const o2::ft0::Digit& digit,
   constexpr int nMCPsA = 4 * Geometry::NCellsA;
 
   int nch{0};
+  bool isActiveA = false;
+  bool isActiveC = false;
+  bool isFlangeEvent = false;
+
   for (const auto& channelData : inChData) {
     if (channelData.ChId >= NCHANNELS) {
       // Reference channels shouldn't participate in reco at all!
@@ -68,15 +72,23 @@ RP CollisionTimeRecoTask::processDigit(const o2::ft0::Digit& digit,
       outChData.emplace_back(channelData.ChId, timeInPS, (float)channelData.QTCAmpl, channelData.ChainQTC);
       nch++;
     }
+    const bool isOkForTimeCalc = TimeFilterParam::Instance().checkAll(channelData);
     //  only signals which satisfy conditions may participate in time calculation
-    if (TimeFilterParam::Instance().checkAll(channelData)) {
-      if (channelData.ChId < nMCPsA) {
+    if (channelData.ChId < nMCPsA) {
+      // A-side
+      if (isOkForTimeCalc) {
         sideAtime += timeInPS;
         ndigitsA++;
-      } else {
+      }
+      isActiveA = true;
+    } else {
+      // C-side
+      if (isOkForTimeCalc) {
         sideCtime += timeInPS;
         ndigitsC++;
       }
+      isActiveC = true;
+      isFlangeEvent |= channelData.CFDTime < -350 && channelData.CFDTime > -450;
     }
   }
   std::array<short, 4> mCollisionTime = {RP::sDummyCollissionTime, RP::sDummyCollissionTime, RP::sDummyCollissionTime, RP::sDummyCollissionTime};
@@ -90,7 +102,8 @@ RP CollisionTimeRecoTask::processDigit(const o2::ft0::Digit& digit,
   } else {
     mCollisionTime[TimeMean] = std::min(mCollisionTime[TimeA], mCollisionTime[TimeC]);
   }
-  return RecPoints{mCollisionTime, firstEntry, nch, digit.mIntRecord, digit.mTriggers};
+  const uint8_t extraTrgWord = RecPoints::makeExtraTrgWord(isActiveA, isActiveC, isFlangeEvent);
+  return RecPoints(firstEntry, nch, digit.mIntRecord, mCollisionTime, digit.mTriggers, extraTrgWord);
 }
 //______________________________________________________
 void CollisionTimeRecoTask::FinishTask()

Detectors/FIT/FV0/base/include/FV0Base/Geometry.h

@@ -133,6 +133,16 @@ class Geometry
     return o2::base::GeometryManager::getPNEntry(getDetID(), index);
   }
 
+  static std::string getDetectorRightSymName()
+  {
+    return sDetectorRightName + "_0";
+  }
+
+  static std::string getDetectorLeftSymName()
+  {
+    return sDetectorLeftName + "_1";
+  }
+
   /// Get the density of the PMTs.
   static constexpr float getPmtDensity()
   {
@@ -143,6 +153,8 @@ class Geometry
   explicit Geometry(EGeoType initType);
 
   inline static const std::string sDetectorName = "FV0";
+  inline static const std::string sDetectorRightName = sDetectorName + "RIGHT";
+  inline static const std::string sDetectorLeftName = sDetectorName + "LEFT";
 
   // General geometry constants
   static constexpr float sEpsilon = 0.01;     ///< Used to make one spatial dimension infinitesimally larger than other