Merge branch 'AliceO2Group:master' into master

Author: Shunsuke-Kurita

.checkov.yml

@@ -0,0 +1,6 @@
+---
+# You can see all available properties here: https://github.com/bridgecrewio/checkov#configuration-using-a-config-file
+quiet: true
+skip-check:
+  - CKV_DOCKER_2
+  - CKV_GHA_7

.github/workflows/labeler.yml

@@ -1,7 +1,8 @@
 ---
 name: "Pull Request Labeler"
-on:
-  - pull_request_target
+'on':
+  pull_request_target:
+    types: [opened, synchronize, reopened, edited]
 permissions: read-all
 
 jobs:
@@ -10,8 +11,112 @@ jobs:
     permissions:
       contents: read
       pull-requests: write
+    outputs:
+      labels: ${{ steps.labeler.outputs.all-labels }}
     steps:
-      - uses: actions/labeler@v5
+      - name: Label the PR
+        id: labeler
+        uses: actions/labeler@v5
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           sync-labels: true
+  title-prefix-checker:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+    needs: labeler
+    steps:
+      - name: Check the PR title prefix
+        id: check-prefix
+        env:
+          title: ${{ github.event.pull_request.title }}
+          labels: ${{ needs.labeler.outputs.labels }}
+        shell: python
+        run: |
+          import os
+          import re
+          import sys
+          title = os.environ['title']
+          labels = os.environ['labels']
+          tags = {
+              "infrastructure": "Infrastructure",
+              "common": "Common",
+              "alice3": "ALICE3",
+              "pwgcf": "PWGCF",
+              "pwgdq": "PWGDQ",
+              "pwgem": "PWGEM",
+              "pwghf": "PWGHF",
+              "pwgje": "PWGJE",
+              "pwglf": "PWGLF",
+              "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
+          # 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):
+              prefix_title = match.group(1)
+              words_prefix_title = prefix_title.replace(",", " ").replace("/", " ").split()
+              title_stripped = title[len(match.group()) :]
+              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()):
+                  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
+              else:
+                  print("::warning::No known tags found in the prefix.")
+                  if tags_relevant:
+                      replace_title = 1
+                      title_new = prefix_good + title
+          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}".')
+          else:
+              print("::notice::The PR title prefix is fine.")
+          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)
+      - name: Fix the PR title prefix
+        if: ${{ steps.check-prefix.outputs.replace == 1 }}
+        uses: the-wright-jamie/Update-PR-Info-Action@v1.1.0
+        with:
+          repo-token: "${{ secrets.GITHUB_TOKEN }}"
+          base-branch-regex: master
+          error-on-fail: false
+          title-template: "${{ steps.check-prefix.outputs.title }}"
+          title-update-action: replace

.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@v8
+        uses: oxsecurity/megalinter@v8.1.0
         env:
           # All available variables are described in documentation:
           # https://megalinter.io/configuration/

CPPLINT.cfg

@@ -1 +1 @@
-filter=-build/c++11,-build/namespaces,-readability/fn_size,-readability/todo,-runtime/references,-whitespace/blank_line,-whitespace/braces,-whitespace/comments,-whitespace/line_length,-whitespace/semicolon,-whitespace/todo
+filter=-build/c++11,-build/namespaces,-readability/fn_size,-readability/todo,-runtime/references,-whitespace/blank_line,-whitespace/braces,-whitespace/comments,-whitespace/indent_namespace,-whitespace/line_length,-whitespace/semicolon,-whitespace/todo

Common/TableProducer/ft0CorrectedTable.cxx

@@ -10,38 +10,89 @@
 // or submit itself to any jurisdiction.
 
 #include <bitset>
-#include "Common/DataModel/FT0Corrected.h"
 #include "Framework/ConfigParamSpec.h"
 #include "Framework/runDataProcessing.h"
 #include "Framework/AnalysisTask.h"
-#include "Common/DataModel/EventSelection.h"
 #include "Framework/AnalysisDataModel.h"
+#include "Framework/HistogramRegistry.h"
+#include "Common/DataModel/FT0Corrected.h"
+#include "Common/DataModel/EventSelection.h"
 #include "CommonConstants/LHCConstants.h"
 #include "CommonConstants/PhysicsConstants.h"
 #include "DataFormatsFT0/Digit.h"
+#include "CCDB/BasicCCDBManager.h"
+#include "CollisionTypeHelper.h"
+#include "TRandom3.h"
 
 using namespace o2;
 using namespace o2::framework;
-
 using namespace o2::aod;
-struct FT0CorrectedTable {
+
+struct ft0CorrectedTable {
+  // Configurables
+  Configurable<float> resoFT0A{"resoFT0A", 20.f, "FT0A resolution"};
+  Configurable<float> resoFT0C{"resoFT0C", 20.f, "FT0C resolution"};
+  Configurable<bool> addHistograms{"addHistograms", false, "Add QA histograms"};
+  Configurable<int> cfgCollisionSystem{"collisionSystem", -2, "Collision system: -2 (use cfg values), -1 (autoset), 0 (pp), 1 (PbPb), 2 (XeXe), 3 (pPb)"};
+  Configurable<std::string> cfgUrl{"ccdb-url", "http://alice-ccdb.cern.ch", "url of the ccdb repository"};
+  Configurable<std::string> cfgPathGrpLhcIf{"ccdb-path-grplhcif", "GLO/Config/GRPLHCIF", "Path on the CCDB for the GRPLHCIF object"};
+  Configurable<int64_t> cfgTimestamp{"ccdb-timestamp", -1, "timestamp of the object"};
+  Service<o2::ccdb::BasicCCDBManager> ccdb;
+
+  // Producer
   Produces<o2::aod::FT0sCorrected> table;
   using BCsWithMatchings = soa::Join<aod::BCs, aod::Run3MatchedToBCSparse>;
   using CollisionEvSel = soa::Join<aod::Collisions, aod::EvSels>::iterator;
+  static constexpr float invLightSpeedCm2NS = 1.f / o2::constants::physics::LightSpeedCm2NS;
 
-  void process(BCsWithMatchings const&, soa::Join<aod::Collisions, aod::EvSels> const& collisions, aod::FT0s const&)
+  HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject};
+  void init(o2::framework::InitContext&)
   {
+    if (doprocessStandard && doprocessWithBypassFT0timeInMC) {
+      LOG(fatal) << "Both processStandard and processWithBypassFT0timeInMC are enabled. Pick one of the two";
+    }
+    if (!doprocessStandard && !doprocessWithBypassFT0timeInMC) {
+      LOG(fatal) << "No process is enabled. Pick one";
+    }
+    ccdb->setURL(cfgUrl);
+    ccdb->setTimestamp(cfgTimestamp);
+    ccdb->setCaching(true);
+    ccdb->setLocalObjectValidityChecking();
+    // Not later than now objects
+    ccdb->setCreatedNotAfter(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count());
+
+    if (!addHistograms) {
+      return;
+    }
+    histos.add("t0A", "t0A", kTH1D, {{1000, -1, 1, "t0A (ns)"}});
+    histos.add("t0C", "t0C", kTH1D, {{1000, -1, 1, "t0C (ns)"}});
+    histos.add("t0AC", "t0AC", kTH1D, {{1000, -1000, 1000, "t0AC (ns)"}});
+    histos.add("deltat0AC", "deltat0AC", kTH1D, {{1000, -10, 10, "#Deltat0AC (ns)"}});
+    if (doprocessWithBypassFT0timeInMC) {
+      histos.add("MC/deltat0A", "t0A", kTH1D, {{1000, -50, 50, "t0A (ps)"}});
+      histos.add("MC/deltat0C", "t0C", kTH1D, {{1000, -50, 50, "t0C (ps)"}});
+      histos.add("MC/deltat0AC", "t0AC", kTH1D, {{1000, -50, 50, "t0AC (ps)"}});
+    }
+  }
+
+  void processStandard(soa::Join<aod::Collisions, aod::EvSels> const& collisions,
+                       BCsWithMatchings const&,
+                       aod::FT0s const&)
+  {
+    table.reserve(collisions.size());
+    float t0A = 1e10f;
+    float t0C = 1e10f;
     for (auto& collision : collisions) {
-      float vertexPV = collision.posZ();
-      float vertex_corr = vertexPV / o2::constants::physics::LightSpeedCm2NS;
-      float t0A = 1e10;
-      float t0C = 1e10;
+      t0A = 1e10f;
+      t0C = 1e10f;
+      const float vertexPV = collision.posZ();
+      const float vertex_corr = vertexPV * invLightSpeedCm2NS;
       constexpr float dummyTime = 30.; // Due to HW limitations time can be only within range (-25,25) ns, dummy time is around 32 ns
       if (collision.has_foundFT0()) {
-        auto ft0 = collision.foundFT0();
-        std::bitset<8> triggers = ft0.triggerMask();
-        bool ora = triggers[o2::ft0::Triggers::bitA];
-        bool orc = triggers[o2::ft0::Triggers::bitC];
+        const auto& ft0 = collision.foundFT0();
+        const std::bitset<8>& triggers = ft0.triggerMask();
+        const bool ora = triggers[o2::ft0::Triggers::bitA];
+        const bool orc = triggers[o2::ft0::Triggers::bitC];
         LOGF(debug, "triggers OrA %i OrC %i ", ora, orc);
         LOGF(debug, " T0A = %f, T0C %f, vertex_corr %f", ft0.timeA(), ft0.timeC(), vertex_corr);
         if (ora && ft0.timeA() < dummyTime) {
@@ -52,11 +103,100 @@ struct FT0CorrectedTable {
         }
       }
       LOGF(debug, " T0 collision time T0A = %f, T0C = %f", t0A, t0C);
+      if (addHistograms) {
+        histos.fill(HIST("t0A"), t0A);
+        histos.fill(HIST("t0C"), t0C);
+        histos.fill(HIST("t0AC"), (t0A + t0C) * 0.5f);
+        histos.fill(HIST("deltat0AC"), t0A - t0C);
+      }
+      table(t0A, t0C);
+    }
+  }
+  PROCESS_SWITCH(ft0CorrectedTable, processStandard, "Process standard table (default)", true);
+
+  void processWithBypassFT0timeInMC(soa::Join<aod::Collisions, aod::EvSels, aod::McCollisionLabels> const& collisions,
+                                    soa::Join<BCsWithMatchings, aod::Timestamps> const& bcs,
+                                    aod::FT0s const&,
+                                    aod::McCollisions const&)
+  {
+    if (cfgCollisionSystem.value == -1) {
+      o2::parameters::GRPLHCIFData* grpo = ccdb->template getForTimeStamp<o2::parameters::GRPLHCIFData>(cfgPathGrpLhcIf,
+                                                                                                        bcs.iteratorAt(0).timestamp());
+      cfgCollisionSystem.value = CollisionSystemType::getCollisionTypeFromGrp(grpo);
+      switch (cfgCollisionSystem.value) {
+        case CollisionSystemType::kCollSyspp:
+          resoFT0A.value = 24.f;
+          resoFT0C.value = 24.f;
+          break;
+        case CollisionSystemType::kCollSysPbPb:
+          resoFT0A.value = 5.65f;
+          resoFT0C.value = 5.65f;
+          break;
+        default:
+          break;
+      }
+    }
+    table.reserve(collisions.size());
+    float t0A = 1e10f;
+    float t0C = 1e10f;
+    float eventtimeMC = 1e10f;
+    float posZMC = 0;
+    bool hasMCcoll = false;
+
+    for (auto& collision : collisions) {
+      hasMCcoll = false;
+      eventtimeMC = 1e10f;
+      t0A = 1e10f;
+      t0C = 1e10f;
+      posZMC = 0;
+      const float vertexPV = collision.posZ();
+      const float vertex_corr = vertexPV * invLightSpeedCm2NS;
+      constexpr float dummyTime = 30.; // Due to HW limitations time can be only within range (-25,25) ns, dummy time is around 32 ns
+      if (collision.has_mcCollision()) {
+        hasMCcoll = true;
+        const auto& collisionMC = collision.mcCollision();
+        eventtimeMC = collisionMC.t();
+        posZMC = collisionMC.posZ();
+      }
+      if (collision.has_foundFT0()) {
+        const auto& ft0 = collision.foundFT0();
+        const std::bitset<8>& triggers = ft0.triggerMask();
+        const bool ora = triggers[o2::ft0::Triggers::bitA];
+        const bool orc = triggers[o2::ft0::Triggers::bitC];
+
+        if (ora && ft0.timeA() < dummyTime) {
+          t0A = ft0.timeA();
+          if (hasMCcoll) {
+            const float diff = eventtimeMC - posZMC * invLightSpeedCm2NS + gRandom->Gaus(0.f, resoFT0A);
+            t0A = diff;
+          }
+          t0A += vertex_corr;
+        }
+        if (orc && ft0.timeC() < dummyTime) {
+          t0C = ft0.timeC();
+          if (hasMCcoll) {
+            const float diff = eventtimeMC + posZMC * invLightSpeedCm2NS + gRandom->Gaus(0.f, resoFT0C);
+            t0C = diff;
+          }
+          t0C -= vertex_corr;
+        }
+      }
+      LOGF(debug, " T0 collision time T0A = %f, T0C = %f", t0A, t0C);
+      if (addHistograms) {
+        histos.fill(HIST("t0A"), t0A);
+        histos.fill(HIST("t0C"), t0C);
+        histos.fill(HIST("t0AC"), (t0A + t0C) * 0.5f);
+        histos.fill(HIST("deltat0AC"), t0A - t0C);
+        if (hasMCcoll) {
+          histos.fill(HIST("MC/deltat0A"), (t0A - eventtimeMC) * 1000.f);
+          histos.fill(HIST("MC/deltat0C"), (t0C - eventtimeMC) * 1000.f);
+          histos.fill(HIST("MC/deltat0AC"), ((t0A + t0C) * 0.5f - eventtimeMC) * 1000.f);
+        }
+      }
       table(t0A, t0C);
     }
   }
+  PROCESS_SWITCH(ft0CorrectedTable, processWithBypassFT0timeInMC, "Process MC with bypass of the AO2D information. Use with care!", false);
 };
-WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
-{
-  return WorkflowSpec{adaptAnalysisTask<FT0CorrectedTable>(cfgc, TaskName{"ft0-corrected-table"})};
-}
+
+WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask<ft0CorrectedTable>(cfgc)}; }