Merge branch 'AliceO2Group:dev' into new-detector4

Author: pkurash

Common/MathUtils/include/MathUtils/LegendrePols.h

@@ -200,7 +200,7 @@ class Legendre2DPolynominal final : public TNamed,
            boost::math::legendre_p(i - j, y);
   }
 
-  inline int getFlatIdx(int i, int j) const { return i * (i - 1) / 2 + j; }
+  inline int getFlatIdx(int i, int j) const { return i * (i + 1) / 2 + j; }
 
   unsigned int fOrder{0};
   std::vector<double> fParams;

Common/Utils/src/FileFetcher.cxx

@@ -329,6 +329,7 @@ bool FileFetcher::copyFile(size_t id)
   bool aliencpMode = false;
   std::string uuid{};
   std::vector<std::string> logsToClean;
+  std::string dbgset{};
   if (mCopyCmd.find("alien") != std::string::npos) {
     if (!gGrid && !TGrid::Connect("alien://")) {
       LOG(error) << "Copy command refers to alien but connection to Grid failed";
@@ -339,18 +340,18 @@ bool FileFetcher::copyFile(size_t id)
         c = '_';
       }
     }
-    gSystem->Setenv("ALIENPY_DEBUG", "1");
-    logsToClean.push_back(fmt::format("log_alienpy_{}.txt", uuid));
-    gSystem->Setenv("ALIENPY_DEBUG_FILE", logsToClean.back().c_str());
-    gSystem->Setenv("XRD_LOGLEVEL", "Dump");
-    logsToClean.push_back(fmt::format("log_xrd_{}.txt", uuid));
-    gSystem->Setenv("XRD_LOGFILE", logsToClean.back().c_str());
-    LOGP(info, "debug log files for {}: ALIENPY_DEBUG_FILE={} XRD_LOGFILE={}", mInputFiles[id].getOrigName(),
-         getenv("ALIENPY_DEBUG_FILE") ? getenv("ALIENPY_DEBUG_FILE") : "",
-         getenv("XRD_LOGFILE") ? getenv("XRD_LOGFILE") : "");
+    if (!(getenv("ALIENPY_DEBUG") && std::stoi(getenv("ALIENPY_DEBUG")) == 1)) {
+      logsToClean.push_back(fmt::format("log_alienpy_{}.txt", uuid));
+      dbgset += fmt::format("ALIENPY_DEBUG=1 ALIENPY_DEBUG_FILE={} ", logsToClean.back());
+    }
+    if (!(getenv("XRD_LOGLEVEL") && strcmp(getenv("XRD_LOGLEVEL"), "Dump") == 0)) {
+      logsToClean.push_back(fmt::format("log_xrd_{}.txt", uuid));
+      dbgset += fmt::format("XRD_LOGLEVEL=Dump XRD_LOGFILE={} ", logsToClean.back());
+    }
+    LOGP(debug, "debug setting for for {}: {}", mInputFiles[id].getOrigName(), dbgset);
   }
   auto realCmd = std::regex_replace(std::regex_replace(mCopyCmd, std::regex(R"(\?src)"), mInputFiles[id].getOrigName()), std::regex(R"(\?dst)"), mInputFiles[id].getLocalName());
-  auto fullCmd = fmt::format(R"(sh -c "{}" >> {}  2>&1)", realCmd, mCopyCmdLogFile);
+  auto fullCmd = fmt::format(R"(sh -c "{}{}" >> {}  2>&1)", dbgset, realCmd, mCopyCmdLogFile);
   LOG(info) << "Executing " << fullCmd;
   const auto sysRet = gSystem->Exec(fullCmd.c_str());
   if (sysRet != 0) {

Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h

@@ -215,7 +215,7 @@ enum struct AODProducerStreamerFlags : uint8_t {
 class AODProducerWorkflowDPL : public Task
 {
  public:
-  AODProducerWorkflowDPL(GID::mask_t src, std::shared_ptr<DataRequest> dataRequest, std::shared_ptr<o2::base::GRPGeomRequest> gr, bool enableSV, bool useMC = true) : mUseMC(useMC), mEnableSV(enableSV), mInputSources(src), mDataRequest(dataRequest), mGGCCDBRequest(gr) {}
+  AODProducerWorkflowDPL(GID::mask_t src, std::shared_ptr<DataRequest> dataRequest, std::shared_ptr<o2::base::GRPGeomRequest> gr, bool enableSV, bool useMC = true, bool enableFITextra = false) : mUseMC(useMC), mEnableSV(enableSV), mEnableFITextra(enableFITextra), mInputSources(src), mDataRequest(dataRequest), mGGCCDBRequest(gr) {}
   ~AODProducerWorkflowDPL() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -254,6 +254,7 @@ class AODProducerWorkflowDPL : public Task
   int mNThreads = 1;
   bool mUseMC = true;
   bool mEnableSV = true; // enable secondary vertices
+  bool mEnableFITextra = false;
   bool mFieldON = false;
   const float cSpeed = 0.029979246f; // speed of light in TOF units
 
@@ -370,8 +371,11 @@ class AODProducerWorkflowDPL : public Task
   uint32_t mMuonCl = 0xFFFFFF00;               // 15 bits
   uint32_t mMuonClErr = 0xFFFF0000;            // 7 bits
   uint32_t mV0Time = 0xFFFFF000;               // 11 bits
+  uint32_t mV0ChannelTime = 0xFFFFFF00;        // 15 bits
   uint32_t mFDDTime = 0xFFFFF000;              // 11 bits
+  uint32_t mFDDChannelTime = 0xFFFFFF00;       // 15 bits
   uint32_t mT0Time = 0xFFFFFF00;               // 15 bits
+  uint32_t mT0ChannelTime = 0xFFFFFFF0;        // 19 bits
   uint32_t mV0Amplitude = 0xFFFFF000;          // 11 bits
   uint32_t mFDDAmplitude = 0xFFFFF000;         // 11 bits
   uint32_t mT0Amplitude = 0xFFFFF000;          // 11 bits
@@ -668,7 +672,7 @@ class AODProducerWorkflowDPL : public Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, bool enableST, bool useMC, bool CTPConfigPerRun);
+framework::DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, bool enableST, bool useMC, bool CTPConfigPerRun, bool enableFITextra);
 
 // helper interface for calo cells to "befriend" emcal and phos cells
 class CellHelper

Detectors/AOD/src/AODProducerWorkflowSpec.cxx

@@ -1743,8 +1743,11 @@ void AODProducerWorkflowDPL::init(InitContext& ic)
     mMuonCl = 0xFFFFFFFF;
     mMuonClErr = 0xFFFFFFFF;
     mV0Time = 0xFFFFFFFF;
+    mV0ChannelTime = 0xFFFFFFFF;
     mFDDTime = 0xFFFFFFFF;
+    mFDDChannelTime = 0xFFFFFFFF;
     mT0Time = 0xFFFFFFFF;
+    mT0ChannelTime = 0xFFFFFFFF;
     mV0Amplitude = 0xFFFFFFFF;
     mFDDAmplitude = 0xFFFFFFFF;
     mT0Amplitude = 0xFFFFFFFF;
@@ -1829,8 +1832,11 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
   auto trackedV0Cursor = createTableCursor<o2::aod::TrackedV0s>(pc);
   auto tracked3BodyCurs = createTableCursor<o2::aod::Tracked3Bodys>(pc);
   auto fddCursor = createTableCursor<o2::aod::FDDs>(pc);
+  auto fddExtraCursor = createTableCursor<o2::aod::FDDsExtra>(pc);
   auto ft0Cursor = createTableCursor<o2::aod::FT0s>(pc);
+  auto ft0ExtraCursor = createTableCursor<o2::aod::FT0sExtra>(pc);
   auto fv0aCursor = createTableCursor<o2::aod::FV0As>(pc);
+  auto fv0aExtraCursor = createTableCursor<o2::aod::FV0AsExtra>(pc);
   auto fwdTracksCursor = createTableCursor<o2::aod::StoredFwdTracks>(pc);
   auto fwdTracksCovCursor = createTableCursor<o2::aod::StoredFwdTracksCov>(pc);
   auto fwdTrkClsCursor = createTableCursor<o2::aod::FwdTrkCls>(pc);
@@ -1897,16 +1903,18 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
     tfNumber = mTFNumber;
   }
 
-  std::vector<float> aAmplitudes;
+  std::vector<float> aAmplitudes, aTimes;
   std::vector<uint8_t> aChannels;
   fv0aCursor.reserve(fv0RecPoints.size());
   for (auto& fv0RecPoint : fv0RecPoints) {
     aAmplitudes.clear();
     aChannels.clear();
+    aTimes.clear();
     const auto channelData = fv0RecPoint.getBunchChannelData(fv0ChData);
     for (auto& channel : channelData) {
       if (channel.charge > 0) {
         aAmplitudes.push_back(truncateFloatFraction(channel.charge, mV0Amplitude));
+        aTimes.push_back(truncateFloatFraction(channel.time * 1.E-3, mV0ChannelTime));
         aChannels.push_back(channel.channel);
       }
     }
@@ -1923,6 +1931,11 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
                aChannels,
                truncateFloatFraction(fv0RecPoint.getCollisionGlobalMeanTime() * 1E-3, mV0Time), // ps to ns
                fv0RecPoint.getTrigger().getTriggersignals());
+
+    if (mEnableFITextra) {
+      fv0aExtraCursor(bcID,
+                      aTimes);
+    }
   }
 
   std::vector<float> zdcEnergy, zdcAmplitudes, zdcTime;
@@ -2026,25 +2039,17 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
             [](const std::vector<int>& left, const std::vector<int>& right) { return (left[0] < right[0]); });
 
   // vector of FDD amplitudes
-  int16_t aFDDAmplitudesA[8] = {0u};
-  int16_t aFDDAmplitudesC[8] = {0u};
+  int16_t aFDDAmplitudesA[8] = {0u}, aFDDAmplitudesC[8] = {0u};
+  float aFDDTimesA[8] = {0.f}, aFDDTimesC[8] = {0.f};
   // filling FDD table
   fddCursor.reserve(fddRecPoints.size());
   for (const auto& fddRecPoint : fddRecPoints) {
     for (int i = 0; i < 8; i++) {
       aFDDAmplitudesA[i] = 0;
       aFDDAmplitudesC[i] = 0;
+      aFDDTimesA[i] = 0.f;
+      aFDDTimesC[i] = 0.f;
     }
-
-    const auto channelData = fddRecPoint.getBunchChannelData(fddChData);
-    for (const auto& channel : channelData) {
-      if (channel.mPMNumber < 8) {
-        aFDDAmplitudesC[channel.mPMNumber] = channel.mChargeADC; // amplitude
-      } else {
-        aFDDAmplitudesA[channel.mPMNumber - 8] = channel.mChargeADC; // amplitude
-      }
-    }
-
     uint64_t globalBC = fddRecPoint.getInteractionRecord().toLong();
     uint64_t bc = globalBC;
     auto item = bcsMap.find(bc);
@@ -2054,21 +2059,39 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
     } else {
       LOG(fatal) << "Error: could not find a corresponding BC ID for a FDD rec. point; BC = " << bc;
     }
+    const auto channelData = fddRecPoint.getBunchChannelData(fddChData);
+    for (const auto& channel : channelData) {
+      if (channel.mPMNumber < 8) {
+        aFDDAmplitudesC[channel.mPMNumber] = channel.mChargeADC;                                      // amplitude
+        aFDDTimesC[channel.mPMNumber] = truncateFloatFraction(channel.mTime * 1E-3, mFDDChannelTime); // time
+      } else {
+        aFDDAmplitudesA[channel.mPMNumber - 8] = channel.mChargeADC;                                      // amplitude
+        aFDDTimesA[channel.mPMNumber - 8] = truncateFloatFraction(channel.mTime * 1E-3, mFDDChannelTime); // time
+      }
+    }
+
     fddCursor(bcID,
               aFDDAmplitudesA,
               aFDDAmplitudesC,
               truncateFloatFraction(fddRecPoint.getCollisionTimeA() * 1E-3, mFDDTime), // ps to ns
               truncateFloatFraction(fddRecPoint.getCollisionTimeC() * 1E-3, mFDDTime), // ps to ns
               fddRecPoint.getTrigger().getTriggersignals());
+    if (mEnableFITextra) {
+      fddExtraCursor(bcID,
+                     aFDDTimesA,
+                     aFDDTimesC);
+    }
   }
 
   // filling FT0 table
-  std::vector<float> aAmplitudesA, aAmplitudesC;
+  std::vector<float> aAmplitudesA, aAmplitudesC, aTimesA, aTimesC;
   std::vector<uint8_t> aChannelsA, aChannelsC;
   ft0Cursor.reserve(ft0RecPoints.size());
   for (auto& ft0RecPoint : ft0RecPoints) {
     aAmplitudesA.clear();
     aAmplitudesC.clear();
+    aTimesA.clear();
+    aTimesC.clear();
     aChannelsA.clear();
     aChannelsC.clear();
     const auto channelData = ft0RecPoint.getBunchChannelData(ft0ChData);
@@ -2079,9 +2102,11 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
         if (channel.ChId < nFT0ChannelsAside) {
           aChannelsA.push_back(channel.ChId);
           aAmplitudesA.push_back(truncateFloatFraction(channel.QTCAmpl, mT0Amplitude));
+          aTimesA.push_back(truncateFloatFraction(channel.CFDTime * 1E-3, mT0ChannelTime));
         } else {
           aChannelsC.push_back(channel.ChId - nFT0ChannelsAside);
           aAmplitudesC.push_back(truncateFloatFraction(channel.QTCAmpl, mT0Amplitude));
+          aTimesC.push_back(truncateFloatFraction(channel.CFDTime * 1E-3, mT0ChannelTime));
         }
       }
     }
@@ -2102,6 +2127,11 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
               truncateFloatFraction(ft0RecPoint.getCollisionTimeA() * 1E-3, mT0Time), // ps to ns
               truncateFloatFraction(ft0RecPoint.getCollisionTimeC() * 1E-3, mT0Time), // ps to ns
               ft0RecPoint.getTrigger().getTriggersignals());
+    if (mEnableFITextra) {
+      ft0ExtraCursor(bcID,
+                     aTimesA,
+                     aTimesC);
+    }
   }
 
   if (mUseMC) {
@@ -3073,7 +3103,7 @@ void AODProducerWorkflowDPL::endOfStream(EndOfStreamContext& /*ec*/)
   mStreamer.reset();
 }
 
-DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, bool enableStrangenessTracking, bool useMC, bool CTPConfigPerRun)
+DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, bool enableStrangenessTracking, bool useMC, bool CTPConfigPerRun, bool enableFITextra)
 {
   auto dataRequest = std::make_shared<DataRequest>();
   dataRequest->inputs.emplace_back("ctpconfig", "CTP", "CTPCONFIG", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/Config", CTPConfigPerRun));
@@ -3133,8 +3163,11 @@ DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, boo
     OutputForTable<Collisions>::spec(),
     OutputForTable<Decay3Bodys>::spec(),
     OutputForTable<FDDs>::spec(),
+    OutputForTable<FDDsExtra>::spec(),
     OutputForTable<FT0s>::spec(),
+    OutputForTable<FT0sExtra>::spec(),
     OutputForTable<FV0As>::spec(),
+    OutputForTable<FV0AsExtra>::spec(),
     OutputForTable<StoredFwdTracks>::spec(),
     OutputForTable<StoredFwdTracksCov>::spec(),
     OutputForTable<StoredMFTTracks>::spec(),
@@ -3184,7 +3217,7 @@ DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, boo
     "aod-producer-workflow",
     dataRequest->inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<AODProducerWorkflowDPL>(src, dataRequest, ggRequest, enableSV, useMC)},
+    AlgorithmSpec{adaptFromTask<AODProducerWorkflowDPL>(src, dataRequest, ggRequest, enableSV, useMC, enableFITextra)},
     Options{
       ConfigParamSpec{"run-number", VariantType::Int64, -1L, {"The run-number. If left default we try to get it from DPL header."}},
       ConfigParamSpec{"aod-timeframe-id", VariantType::Int64, -1L, {"Set timeframe number"}},

Detectors/AOD/src/aod-producer-workflow.cxx

@@ -37,6 +37,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"disable-mc", o2::framework::VariantType::Bool, false, {"disable MC propagation"}},
     {"disable-secondary-vertices", o2::framework::VariantType::Bool, false, {"disable filling secondary vertices"}},
     {"disable-strangeness-tracker", o2::framework::VariantType::Bool, false, {"disable filling strangeness tracking"}},
+    {"enable-FIT-extra", o2::framework::VariantType::Bool, false, {"enable FIT extra output"}},
     {"info-sources", VariantType::String, std::string{GID::ALL}, {"comma-separated list of sources to use"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}},
     {"combine-source-devices", o2::framework::VariantType::Bool, false, {"merge DPL source devices"}},
@@ -54,6 +55,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   bool enableSV = !configcontext.options().get<bool>("disable-secondary-vertices");
   bool enableST = !configcontext.options().get<bool>("disable-strangeness-tracker");
   bool ctpcfgperrun = !configcontext.options().get<bool>("ctpconfig-run-independent");
+  bool enableFITextra = configcontext.options().get<bool>("enable-FIT-extra");
 
   GID::mask_t allowedSrc = GID::getSourcesMask("ITS,MFT,MCH,MID,MCH-MID,TPC,TRD,ITS-TPC,TPC-TOF,TPC-TRD,ITS-TPC-TOF,ITS-TPC-TRD,TPC-TRD-TOF,ITS-TPC-TRD-TOF,MFT-MCH,FT0,FV0,FDD,ZDC,EMC,CTP,PHS,CPV,HMP");
   GID::mask_t src = allowedSrc & GID::getSourcesMask(configcontext.options().get<std::string>("info-sources"));
@@ -64,7 +66,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   }
 
   WorkflowSpec specs;
-  specs.emplace_back(o2::aodproducer::getAODProducerWorkflowSpec(src, enableSV, enableST, useMC, ctpcfgperrun));
+  specs.emplace_back(o2::aodproducer::getAODProducerWorkflowSpec(src, enableSV, enableST, useMC, ctpcfgperrun, enableFITextra));
 
   auto srcCls = src & ~(GID::getSourceMask(GID::MCH) | GID::getSourceMask(GID::MID)); // Don't read global MID and MCH clusters (those attached to tracks are always read)
   auto srcMtc = src;

Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h

@@ -23,12 +23,14 @@ namespace trk
 enum eLayout {
   kCylinder = 0,
   kTurboStaves,
+  kStaggered,
 };
 
 struct TRKBaseParam : public o2::conf::ConfigurableParamHelper<TRKBaseParam> {
   std::string configFile = "";
   float serviceTubeX0 = 0.02f; // X0 Al2O3
-  eLayout layout = kCylinder;  // Type of segmentation of the layers into staves
+  eLayout layoutML = kCylinder; // Type of segmentation for the middle layers
+  eLayout layoutOL = kCylinder; // Type of segmentation for the outer layers
 
   O2ParamDef(TRKBaseParam, "TRKBase");
 };

Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h

@@ -39,6 +39,9 @@ class TRKLayer
   auto getNumber() const { return mLayerNumber; }
   auto getName() const { return mLayerName; }
 
+  TGeoVolume* createSensor(std::string type, double width = -1);
+  TGeoVolume* createChip(std::string type, double width = -1);
+  TGeoVolume* createStave(std::string type, double width = -1);
   void createLayer(TGeoVolume* motherVolume);
 
  private:

Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx

@@ -116,9 +116,18 @@ void Detector::buildTRKNewVacuumVessel()
   mLayers.emplace_back(10, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(10)}, 80.f, 258.f, 100.e-3);
 
   auto& trkPars = TRKBaseParam::Instance();
-  mLayers[8].setLayout(trkPars.layout);
-  mLayers[9].setLayout(trkPars.layout);
-  mLayers[10].setLayout(trkPars.layout);
+
+  // Middle layers
+  mLayers[3].setLayout(trkPars.layoutML);
+  mLayers[4].setLayout(trkPars.layoutML);
+  mLayers[5].setLayout(trkPars.layoutML);
+  mLayers[6].setLayout(trkPars.layoutML);
+
+  // Outer tracker
+  mLayers[7].setLayout(trkPars.layoutOL);
+  mLayers[8].setLayout(trkPars.layoutOL);
+  mLayers[9].setLayout(trkPars.layoutOL);
+  mLayers[10].setLayout(trkPars.layoutOL);
 }
 
 void Detector::configFromFile(std::string fileName)