Merge branch 'AliceO2Group:master' into master

Author: spucillo

.clang-format

@@ -39,7 +39,60 @@ PenaltyBreakFirstLessLess: 120
 PenaltyBreakString: 1000
 PenaltyExcessCharacter: 1000000
 PenaltyReturnTypeOnItsOwnLine: 200
-SortIncludes: false
+SortIncludes: CaseSensitive
+IncludeBlocks: Regroup
+IncludeCategories:
+  # O2Physics, PWG
+  - Regex: ^(<|")PWG[A-Z]{2}/.*\.h
+    Priority: 2
+    CaseSensitive: true
+  # O2Physics, non-PWG
+  - Regex: ^(<|")(Common|ALICE3|DPG|EventFiltering|Tools|Tutorials)/.*\.h
+    Priority: 3
+    CaseSensitive: true
+  # O2
+  - Regex: ^(<|")(Algorithm|CCDB|Common[A-Z]|DataFormats|DCAFitter|Detectors|EMCAL|Field|Framework|FT0|FV0|GlobalTracking|ITS|MathUtils|MFT|MCH|MID|PHOS|PID|ReconstructionDataFormats|SimulationDataFormat|TOF|TPC|ZDC).*/.*\.h
+    Priority: 4
+    CaseSensitive: true
+  # ROOT
+  - Regex: ^(<|")(T[A-Z]|Math/|Roo[A-Z])[[:alnum:]/]+\.h
+    Priority: 5
+    CaseSensitive: true
+  # known third-party: KFParticle
+  - Regex: ^(<|")KF[A-Z][[:alnum:]]+\.h
+    Priority: 6
+    CaseSensitive: true
+  # known third-party: FastJet
+  - Regex: ^(<|")fastjet/
+    Priority: 6
+    CaseSensitive: true
+  # known third-party: ONNX runtime
+  - Regex: ^(<|")onnxruntime
+    Priority: 6
+    CaseSensitive: true
+  # incomplete path to DataModel
+  - Regex: ^(<|").*DataModel/
+    Priority: 1
+    CaseSensitive: true
+  # other third-party
+  - Regex: ^(<|")([[:alnum:]_]+/)+[[:alnum:]_]+\.h
+    Priority: 6
+    CaseSensitive: true
+  # other local-looking file
+  - Regex: ^".*\.
+    Priority: 1
+    CaseSensitive: true
+  # C system
+  - Regex: ^(<|")[[:lower:]_]+\.h(>|")
+    Priority: 102
+    CaseSensitive: true
+  # C++ system
+  - Regex: ^(<|")[[:lower:]_/]+(>|")
+    Priority: 101
+    CaseSensitive: true
+  # rest
+  - Regex: .*
+    Priority: 100
 SpaceBeforeAssignmentOperators: true
 SpaceBeforeParens: ControlStatements
 SpaceInEmptyParentheses: false

.pre-commit-config.yaml

@@ -7,10 +7,10 @@ repos:
       - id: trailing-whitespace
       - id: end-of-file-fixer
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v18.1.3 # clang-format version
+    rev: v20.1.5 # clang-format version
     hooks:
       - id: clang-format
   - repo: https://github.com/cpplint/cpplint
-    rev: 2.0.0
+    rev: 2.0.2
     hooks:
       - id: cpplint

ALICE3/Core/DelphesO2LutWriter.cxx

@@ -23,9 +23,10 @@
 
 #include "ALICE3/Core/DelphesO2TrackSmearer.h"
 #include "ALICE3/Core/DelphesO2LutWriter.h"
-#include "iostream"
+#include <iostream>
 #include "TMatrixD.h"
 #include "TVectorD.h"
+#include "TAxis.h"
 #include "TMatrixDSymEigen.h"
 #include "TDatabasePDG.h"
 #include "TLorentzVector.h"
@@ -55,17 +56,18 @@ bool DelphesO2LutWriter::fatSolve(lutEntry_t& lutEntry,
                                   const float mass,
                                   int itof,
                                   int otof,
-                                  int q)
+                                  int q,
+                                  const float nch)
 {
   lutEntry.valid = false;
 
   static TLorentzVector tlv;
   tlv.SetPtEtaPhiM(pt, eta, 0., mass);
   o2::track::TrackParCov trkIn;
   o2::upgrade::convertTLorentzVectorToO2Track(q, tlv, {0., 0., 0.}, trkIn);
-
   o2::track::TrackParCov trkOut;
-  if (fat.FastTrack(trkIn, trkOut, 1) < 0) {
+  const int status = fat.FastTrack(trkIn, trkOut, nch);
+  if (status <= 0) {
     Printf(" --- fatSolve: FastTrack failed --- \n");
     tlv.Print();
     return false;
@@ -234,6 +236,9 @@ void DelphesO2LutWriter::lutWrite(const char* filename, int pdg, float field, in
   lutEntry_t lutEntry;
 
   // write entries
+  int nCalls = 0;
+  int successfullCalls = 0;
+  int failedCalls = 0;
   for (int inch = 0; inch < nnch; ++inch) {
     Printf(" --- writing nch = %d/%d", inch, nnch);
     auto nch = lutHeader.nchmap.eval(inch);
@@ -242,6 +247,7 @@ void DelphesO2LutWriter::lutWrite(const char* filename, int pdg, float field, in
     for (int irad = 0; irad < nrad; ++irad) {
       Printf(" --- writing irad = %d/%d", irad, nrad);
       for (int ieta = 0; ieta < neta; ++ieta) {
+        nCalls++;
         Printf(" --- writing ieta = %d/%d", ieta, neta);
         auto eta = lutHeader.etamap.eval(ieta);
         lutEntry.eta = lutHeader.etamap.eval(ieta);
@@ -252,6 +258,7 @@ void DelphesO2LutWriter::lutWrite(const char* filename, int pdg, float field, in
           if (std::fabs(eta) <= etaMaxBarrel) { // full lever arm ends at etaMaxBarrel
             Printf("Solving in the barrel");
             // printf(" --- fatSolve: pt = %f, eta = %f, mass = %f, field=%f \n", lutEntry.pt, lutEntry.eta, lutHeader.mass, lutHeader.field);
+            successfullCalls++;
             if (!fatSolve(lutEntry, lutEntry.pt, lutEntry.eta, lutHeader.mass, itof, otof, q)) {
               // printf(" --- fatSolve: error \n");
               lutEntry.valid = false;
@@ -260,13 +267,16 @@ void DelphesO2LutWriter::lutWrite(const char* filename, int pdg, float field, in
               for (int i = 0; i < 15; ++i) {
                 lutEntry.covm[i] = 0.;
               }
+              successfullCalls--;
+              failedCalls++;
             }
           } else {
             Printf("Solving outside the barrel");
             // printf(" --- fwdSolve: pt = %f, eta = %f, mass = %f, field=%f \n", lutEntry.pt, lutEntry.eta, lutHeader.mass, lutHeader.field);
             lutEntry.eff = 1.;
             lutEntry.eff2 = 1.;
             bool retval = true;
+            successfullCalls++;
             if (useFlatDipole) { // Using the parametrization at the border of the barrel
               retval = fatSolve(lutEntry, lutEntry.pt, etaMaxBarrel, lutHeader.mass, itof, otof, q);
             } else if (usePara) {
@@ -288,6 +298,8 @@ void DelphesO2LutWriter::lutWrite(const char* filename, int pdg, float field, in
               for (int i = 0; i < 15; ++i) {
                 lutEntry.covm[i] = 0.;
               }
+              successfullCalls--;
+              failedCalls++;
             }
           }
           Printf("Diagonalizing");
@@ -298,6 +310,8 @@ void DelphesO2LutWriter::lutWrite(const char* filename, int pdg, float field, in
       }
     }
   }
+  Printf(" --- finished writing LUT file %s", filename);
+  Printf(" --- successfull calls: %d/%d, failed calls: %d/%d", successfullCalls, nCalls, failedCalls, nCalls);
   lutFile.close();
 }
 
@@ -331,10 +345,13 @@ void DelphesO2LutWriter::diagonalise(lutEntry_t& lutEntry)
 
 TGraph* DelphesO2LutWriter::lutRead(const char* filename, int pdg, int what, int vs, float nch, float radius, float eta, float pt)
 {
+  Printf(" --- reading LUT file %s", filename);
+  // vs
   static const int kNch = 0;
   static const int kEta = 1;
   static const int kPt = 2;
 
+  // what
   static const int kEfficiency = 0;
   static const int kEfficiency2 = 1;
   static const int kEfficiencyInnerTOF = 2;
@@ -360,6 +377,58 @@ TGraph* DelphesO2LutWriter::lutRead(const char* filename, int pdg, int what, int
   }
   auto nbins = lutMap.nbins;
   auto g = new TGraph();
+  g->SetName(Form("lut_%s_%d_vs_%d_what_%d", filename, pdg, vs, what));
+  g->SetTitle(Form("LUT for %s, pdg %d, vs %d, what %d", filename, pdg, vs, what));
+  switch (vs) {
+    case kNch:
+      Printf(" --- vs = kNch");
+      g->GetXaxis()->SetTitle("Nch");
+      break;
+    case kEta:
+      Printf(" --- vs = kEta");
+      g->GetXaxis()->SetTitle("#eta");
+      break;
+    case kPt:
+      Printf(" --- vs = kPt");
+      g->GetXaxis()->SetTitle("p_{T} (GeV/c)");
+      break;
+    default:
+      Printf(" --- error: unknown vs %d", vs);
+      return nullptr;
+  }
+  switch (what) {
+    case kEfficiency:
+      Printf(" --- what = kEfficiency");
+      g->GetYaxis()->SetTitle("Efficiency (%)");
+      break;
+    case kEfficiency2:
+      Printf(" --- what = kEfficiency2");
+      g->GetYaxis()->SetTitle("Efficiency2 (%)");
+      break;
+    case kEfficiencyInnerTOF:
+      Printf(" --- what = kEfficiencyInnerTOF");
+      g->GetYaxis()->SetTitle("Inner TOF Efficiency (%)");
+      break;
+    case kEfficiencyOuterTOF:
+      Printf(" --- what = kEfficiencyOuterTOF");
+      g->GetYaxis()->SetTitle("Outer TOF Efficiency (%)");
+      break;
+    case kPtResolution:
+      Printf(" --- what = kPtResolution");
+      g->GetYaxis()->SetTitle("p_{T} Resolution (%)");
+      break;
+    case kRPhiResolution:
+      Printf(" --- what = kRPhiResolution");
+      g->GetYaxis()->SetTitle("R#phi Resolution (#mum)");
+      break;
+    case kZResolution:
+      Printf(" --- what = kZResolution");
+      g->GetYaxis()->SetTitle("Z Resolution (#mum)");
+      break;
+    default:
+      Printf(" --- error: unknown what %d", what);
+      return nullptr;
+  }
 
   bool canBeInvalid = true;
   for (int i = 0; i < nbins; ++i) {

ALICE3/Core/DelphesO2LutWriter.h

@@ -55,7 +55,8 @@ class DelphesO2LutWriter
                 const float mass = 0.13957000,
                 int itof = 0,
                 int otof = 0,
-                int q = 1);
+                int q = 1,
+                const float nch = 1);
   bool fwdSolve(float* covm, float pt = 0.1, float eta = 0.0, float mass = 0.13957000);
   bool fwdPara(lutEntry_t& lutEntry, float pt = 0.1, float eta = 0.0, float mass = 0.13957000, float Bfield = 0.5);
   void lutWrite(const char* filename = "lutCovm.dat", int pdg = 211, float field = 0.2, int itof = 0, int otof = 0);

ALICE3/Core/DetLayer.cxx

@@ -16,4 +16,76 @@
 /// \brief  Basic struct to hold information regarding a detector layer to be used in fast simulation
 ///
 
+#include <vector>
+#include <string>
+
 #include "DetLayer.h"
+
+namespace o2::fastsim
+{
+
+// Parametric constructor
+DetLayer::DetLayer(const TString& name_,
+                   float r_,
+                   float z_,
+                   float x0_,
+                   float xrho_,
+                   float resRPhi_,
+                   float resZ_,
+                   float eff_,
+                   int type_)
+  : name(name_),
+    r(r_),
+    z(z_),
+    x0(x0_),
+    xrho(xrho_),
+    resRPhi(resRPhi_),
+    resZ(resZ_),
+    eff(eff_),
+    type(type_)
+{
+}
+
+DetLayer::DetLayer(const DetLayer& other)
+  : name(other.name), r(other.r), z(other.z), x0(other.x0), xrho(other.xrho), resRPhi(other.resRPhi), resZ(other.resZ), eff(other.eff), type(other.type)
+{
+}
+
+std::string DetLayer::toString() const
+{
+  std::string out = "";
+  out.append("DetLayer: ");
+  out.append(name.Data());
+  out.append(" | r: ");
+  out.append(std::to_string(r));
+  out.append(" cm | z: ");
+  out.append(std::to_string(z));
+  out.append(" cm | x0: ");
+  out.append(std::to_string(x0));
+  out.append(" cm | xrho: ");
+  out.append(std::to_string(xrho));
+  out.append(" g/cm^3 | resRPhi: ");
+  out.append(std::to_string(resRPhi));
+  out.append(" cm | resZ: ");
+  out.append(std::to_string(resZ));
+  out.append(" cm | eff: ");
+  out.append(std::to_string(eff));
+  out.append(" | type: ");
+  switch (type) {
+    case layerInert:
+      out.append("Inert");
+      break;
+    case layerSilicon:
+      out.append("Silicon");
+      break;
+    case layerGas:
+      out.append("Gas/TPC");
+      break;
+    default:
+      out.append("Unknown");
+      break;
+  }
+  return out;
+}
+
+} // namespace o2::fastsim