TPC: Implement usage of CCDB Redirect

Detectors/TPC/base/include/TPCBase/CDBTypes.h

@@ -110,7 +110,7 @@ const std::unordered_map<CDBType, const std::string> CDBTypeMap{
   //
   {CDBType::ConfigFEEPad, "TPC/Config/FEEPad"},
   {CDBType::ConfigFEE, "TPC/Config/FEE"},
-  {CDBType::ConfigRunInfo, "TPC/Config/RunInfo"},
+  {CDBType::ConfigRunInfo, "TPC/Config/RunInfoV2"},
   //
   {CDBType::ParDetector, "TPC/Parameter/Detector"},
   {CDBType::ParElectronics, "TPC/Parameter/Electronics"},

Detectors/TPC/base/include/TPCBase/DeadChannelMapCreator.h

@@ -58,10 +58,11 @@ class DeadChannelMapCreator
   void load(long timeStampOrRun);
   void loadFEEConfigViaRunInfoTS(long timeStamp);
   void loadFEEConfigViaRunInfo(long timeStampOrRun);
-  void loadFEEConfig(long tag, long createdNotAfter = -1);
+  void loadFEEConfig(long timeStamp = -1);
   void loadIDCPadFlags(long timeStampOrRun);
 
   void setDeadChannelMapIDCPadStatus(const CalDetFlag_t& padStatusMap, PadFlags mask = PadFlags::flagAllNoneGood);
+  void setDeadChannelMapFEEConfig(const FEEConfig& feeConfig) { mDeadChannelMapFEE = feeConfig.getDeadChannelMap(); }
 
   const CalDet<bool>& getDeadChannelMapIDC() const { return mDeadChannelMapIDC; }
   const CalDet<bool>& getDeadChannelMapFEE() const { return mDeadChannelMapFEE; }

Detectors/TPC/base/include/TPCBase/FEEConfig.h

@@ -48,16 +48,19 @@ struct CRUConfig {
 struct FEEConfig {
   /// Tag definitions for TPC/Config/FEE
   enum class Tags : uint8_t {
-    Unspecified = 0,    ///< Unspecified
-    TestWithZS = 1,     ///< Test configuration with ZS
-    Pedestals = 2,      ///< Configuration for Pedestal data taking
-    Pulser = 3,         ///< Configuration for Pulser data taking
-    Laser = 4,          ///< Configuration for Laser data taking
-    Cosmics = 5,        ///< Configuration for Cosmics data taking
-    Physics35sigma = 6, ///< Physics configuration with 3.5 sigma thresholds
-    Physics30sigma = 7, ///< Physics configuration with 3.0 sigma thresholds
-    Physics25sigma = 8, ///< Physics configuration with 2.5 sigma thresholds
-    Laser10ADCoff = 9,  ///< Configuration for Laser data taking with 10ADC offset for special studies
+    Unspecified = 0,         ///< Unspecified
+    TestWithZS = 1,          ///< Test configuration with ZS
+    Pedestals = 2,           ///< Configuration for Pedestal data taking
+    Pulser = 3,              ///< Configuration for Pulser data taking
+    Laser = 4,               ///< Configuration for Laser data taking
+    Cosmics = 5,             ///< Configuration for Cosmics data taking
+    Physics35sigma = 6,      ///< Physics configuration with 3.5 sigma thresholds
+    Physics30sigma = 7,      ///< Physics configuration with 3.0 sigma thresholds
+    Physics25sigma = 8,      ///< Physics configuration with 2.5 sigma thresholds
+    Laser10ADCoff = 9,       ///< Configuration for Laser data taking with 10ADC offset for special studies
+    TestNoFilters = 10,      ///< Test configuration without filters
+    Physics2025sigma = 11,   ///< Physics configuration with 2.0/2.5 sigma thresholds (IROC/OROC)
+    Physics30sigmaPbPb = 12, ///< Physics configuration with 3.0 sigma thresholds for PbPb (using differnet CMC settings wrt. pp config 7)
   };
 
   enum class PadConfig {

Detectors/TPC/base/src/CDBInterface.cxx

@@ -556,7 +556,7 @@ void CDBInterface::createFEEConfig()
 
   if (!mUseDefaults) {
     LOGP(info, "trying to load default FEEConfig");
-    mDeadChannelMapCreator.loadFEEConfig(7, 1680525888290); // load oldest physics configuration
+    mDeadChannelMapCreator.loadFEEConfig(1680525888290); // load oldest physics configuration
     if (mFEEConfig) {
       return;
     }

Detectors/TPC/base/src/DeadChannelMapCreator.cxx

@@ -43,13 +43,7 @@ void DeadChannelMapCreator::loadFEEConfigViaRunInfoTS(long timeStamp)
   if (mObjectValidity[CDBType::ConfigRunInfo].isValid(timeStamp)) {
     return;
   }
-  const auto meta = mCCDBApi.retrieveHeaders(CDBTypeMap.at(CDBType::ConfigRunInfo), {}, timeStamp);
-  mObjectValidity[CDBType::ConfigRunInfo].startvalidity = std::stol(meta.at("Valid-From"));
-  mObjectValidity[CDBType::ConfigRunInfo].endvalidity = std::stol(meta.at("Valid-Until"));
-  const long tag = std::stol(meta.at("Tag"));
-  LOGP(info, "Loading FEE config for time stamp {}, via RunInfo with Tag {}, RunType {}, runNumber {}, validity: {} - {}",
-       timeStamp, tag, meta.at("RunType"), meta.at("runNumber"), meta.at("Valid-From"), meta.at("Valid-Until"));
-  loadFEEConfig(tag, timeStamp);
+  loadFEEConfig(timeStamp);
 }
 
 //______________________________________________________________________________
@@ -59,13 +53,13 @@ void DeadChannelMapCreator::loadFEEConfigViaRunInfo(long timeStampOrRun)
 }
 
 //______________________________________________________________________________
-void DeadChannelMapCreator::loadFEEConfig(long tag, long createdNotAfter)
+void DeadChannelMapCreator::loadFEEConfig(long timeStamp)
 {
-  std::map<std::string, std::string> mm, meta;
-  const std::string createdNotAfterS = (createdNotAfter < 0) ? "" : std::to_string(createdNotAfter);
-  mFEEConfig.reset(mCCDBApi.retrieveFromTFileAny<o2::tpc::FEEConfig>(CDBTypeMap.at(CDBType::ConfigFEE), mm, tag, &meta, "", createdNotAfterS));
+  std::map<std::string, std::string> meta;
+  mFEEConfig.reset(mCCDBApi.retrieveFromTFileAny<o2::tpc::FEEConfig>(CDBTypeMap.at(CDBType::ConfigRunInfo), {}, timeStamp, &meta));
+  const long tag = std::stol(meta.at("Tag"));
   if (!mFEEConfig) {
-    LOGP(error, "Could not load {}/{}, createdNotAfter: {}", CDBTypeMap.at(CDBType::ConfigFEE), tag, createdNotAfterS);
+    LOGP(error, "Could not load {}/{}, createdNotAfter: {}", CDBTypeMap.at(CDBType::ConfigFEE), tag, timeStamp);
     return;
   }
   LOGP(info, "Using FEE config for Tag {}, ETag {}, Last-Modified {}", meta.at("Valid-From"), meta.at("ETag"), meta.at("Last-Modified"));

Detectors/TPC/base/src/FEEConfig.cxx

@@ -57,6 +57,9 @@ const std::unordered_map<FEEConfig::Tags, const std::string> FEEConfig::TagNames
   {Tags::Physics30sigma, "Physics30sigma"},
   {Tags::Physics25sigma, "Physics25sigma"},
   {Tags::Laser10ADCoff, "Laser10ADCoff"},
+  {Tags::TestNoFilters, "TestNoFilter"},
+  {Tags::Physics2025sigma, "Physics2025sigma"},
+  {Tags::Physics30sigmaPbPb, "Physics30sigmaPbPb"},
 };
 
 const std::unordered_map<FEEConfig::PadConfig, const std::string> FEEConfig::PadConfigNames{

Detectors/TPC/calibration/SpacePoints/include/SpacePoints/SpacePointsCalibParam.h

@@ -56,7 +56,7 @@ static constexpr int NZ2XBins = 5;  ///< number of bins in z/x
 static constexpr float MaxResid = 20.f; ///< max residual in y and z
 static constexpr float MaxY = 50.f;     ///< max value for y position (sector coordinates)
 static constexpr float MaxZ = 300.f;    ///< max value for z position
-static constexpr float MaxTgSlp = 1.f;  ///< max value for phi and lambda angles
+static constexpr float MaxTgSlp = 1.f;  ///< max value for phi (from snp)
 
 // miscellaneous
 static constexpr float sEps = 1e-6f; ///< small number for float comparisons

Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackResiduals.h

@@ -100,7 +100,7 @@ class TrackResiduals
     LocalResid(short dyIn, short dzIn, short tgSlpIn, std::array<unsigned char, VoxDim> bvoxIn) : dy(dyIn), dz(dzIn), tgSlp(tgSlpIn), bvox(bvoxIn) {}
     short dy{0};                              ///< residual in y, ranges from -param::sMaxResid to +param::sMaxResid
     short dz{0};                              ///< residual in z, ranges from -param::sMaxResid to +param::sMaxResid
-    short tgSlp{0};                           ///< tangens of the phi angle between padrow and track, ranges from -param::sMaxAngle to +param::sMaxAngle
+    short tgSlp{0};                           ///< tangens of the phi angle between padrow and track, ranges from -param::MaxTgSlp to +param::MaxTgSlp
     std::array<unsigned char, VoxDim> bvox{}; ///< voxel identifier: VoxZ, VoxF, VoxX
     ClassDefNV(LocalResid, 1);
   };

Detectors/TPC/dcs/src/DCSConfigSpec.cxx

@@ -189,18 +189,28 @@ void DCSConfigDevice::updateRunInfo(gsl::span<const char> configBuff)
     LOGP(error, "{} has wrong format: {}, expected: {}, not writing RunInformation to CCDB", RunInfoFileName, line, runInfoConf);
     return;
   }
+  const auto tagString = data[2];
+  //
+  // retrieve ETag from FEEConfig to set up Redirect
+  const auto headers = mCCDBApi.retrieveHeaders(CDBTypeMap.at(CDBType::ConfigFEE), {}, std::stol(tagString));
+
   std::map<std::string, std::string> md;
   md[o2::base::NameConf::CCDBRunTag.data()] = data[0];
-  md["Tag"] = data[2];
   md["RunType"] = data[3];
   md[o2::ccdb::CcdbObjectInfo::AdjustableEOV] = "true";
-  char tempChar{static_cast<char>(std::stoi(md["Tag"]))};
+  if (headers.find("ETag") != headers.end()) {
+    auto etag = headers.at("ETag");
+    etag.erase(std::remove(etag.begin(), etag.end(), '"'), etag.end());
+    md["Redirect"] = fmt::format("/{}/{}/{}", CDBTypeMap.at(CDBType::ConfigFEE), tagString, etag);
+  } else {
+    LOGP(error, "No ETag found for Tag {}, not setting Redirect in RunInfo", tagString);
+  }
 
   const long startValRCT = std::stol(data[1]);
   const long endValRCT = startValRCT + 48l * 60l * 60l * 1000l;
   if (!mDontWriteRunInfo) {
     o2::ccdb::CcdbObjectInfo w(CDBTypeMap.at(CDBType::ConfigRunInfo), "", "", md, startValRCT, endValRCT);
-    mCCDBApi.storeAsBinaryFile(&tempChar, sizeof(tempChar), "tmp.dat", "char", CDBTypeMap.at(CDBType::ConfigRunInfo), md, startValRCT, endValRCT);
+    mCCDBApi.storeAsBinaryFile(nullptr, 0, "ignored", "", CDBTypeMap.at(CDBType::ConfigRunInfo), md, startValRCT, endValRCT);
     if (!mCCDBApi.isSnapshotMode()) {
       o2::ccdb::adjustOverriddenEOV(mCCDBApi, w);
     }
@@ -255,7 +265,7 @@ void DCSConfigDevice::fillFEEPad(std::string_view configFileName, gsl::span<cons
     nLines = cru_calib_helpers::fillCalPad<2>(calPad, configBuff);
     mFEEPadDataReceived.set(3);
   } else if (configFileName == "CMkValues") {
-    nLines = cru_calib_helpers::fillCalPad<6>(calPad, configBuff);
+    nLines = cru_calib_helpers::fillCalPad<0>(calPad, configBuff);
     mFEEPadDataReceived.set(4);
   }
 

Detectors/TPC/monitor/src/SimpleEventDisplayGUI.cxx

@@ -774,6 +774,19 @@ void SimpleEventDisplayGUI::drawPadSignal(int event, int x, int y, TObject* o)
     if (mCheckShowClusters->IsDown()) {
       showClusters(roc, row);
     }
+    const auto padTimeValsName = fmt::format("PadTimeVals{}", type[type.Length() - 1]);
+    TCanvas* cPadTimeVals = (TCanvas*)gROOT->GetListOfCanvases()->FindObject(padTimeValsName.data());
+    if (cPadTimeVals) {
+      h = (TH1D*)gROOT->FindObject(("h" + padTimeValsName).data());
+      if (h) {
+        cPadTimeVals->cd();
+        delete cPadTimeVals->GetListOfPrimitives()->FindObject("TLine");
+        TLine l;
+        l.SetLineColor(kRed);
+        const auto timeBin = mSelTimeBin->GetNumberEntry()->GetIntNumber();
+        l.DrawLine(timeBin + 0.5, h->GetYaxis()->GetXmin(), timeBin + 0.5, h->GetYaxis()->GetXmax());
+      }
+    }
     update(Form("%s;%sFFT;PadTimeVals%s;SingleTB", type.Data(), type.Data(), rocType.Data()));
   }
   //   printf("bin=%03d.%03d(%03d)[%05d], name=%s, ROC=%02d content=%.1f, ev: %d\n",row,pad,cpad,chn,h->GetName(), roc, h->GetBinContent(binx,biny), event);

GPU/Workflow/src/GPUWorkflowTPC.cxx

@@ -281,11 +281,15 @@ void GPURecoWorkflowSpec::finaliseCCDBTPC(ConcreteDataMatcher& matcher, void* ob
          mTPCDeadChannelMapCreator->getDeadChannelMapIDC().getSum<int32_t>(), mTPCDeadChannelMapCreator->getDeadChannelMap().getSum<int32_t>());
   } else if (matcher == ConcreteDataMatcher(gDataOriginTPC, "TPCRUNINFO", 0)) {
     copyCalibsToBuffer();
-    mTPCDeadChannelMapCreator->loadFEEConfigViaRunInfoTS(mCreationForCalib);
+    const auto* fee = static_cast<o2::tpc::FEEConfig*>(obj);
+    mTPCDeadChannelMapCreator->setDeadChannelMapFEEConfig(*fee);
     mTPCDeadChannelMapCreator->finalizeDeadChannelMap();
     mdEdxCalibContainerBufferNew.get()->setDeadChannelMap(mTPCDeadChannelMapCreator->getDeadChannelMap());
-    LOGP(info, "Updating dead channel map with the FEE info loaded via TPCRUNINFO for creation time {}: {} / {} dead pads from FEE info / total",
-         mCreationForCalib, mTPCDeadChannelMapCreator->getDeadChannelMapFEE().getSum<int32_t>(), mTPCDeadChannelMapCreator->getDeadChannelMap().getSum<int32_t>());
+    LOGP(info,
+         "Updating dead channel map with the FEE info (tag {}) loaded via TPCRUNINFO"
+         " for creation time {}: {} / {} dead pads from FEE info / total, with",
+         std::underlying_type_t<o2::tpc::FEEConfig::Tags>(fee->tag), mCreationForCalib,
+         mTPCDeadChannelMapCreator->getDeadChannelMapFEE().getSum<int32_t>(), mTPCDeadChannelMapCreator->getDeadChannelMap().getSum<int32_t>());
   } else if (mTPCVDriftHelper->accountCCDBInputs(matcher, obj)) {
   } else if (mCalibObjects.mFastTransformHelper->accountCCDBInputs(matcher, obj)) {
   }
@@ -321,7 +325,7 @@ bool GPURecoWorkflowSpec::fetchCalibsCCDBTPC<GPUCalibObjectsConst>(ProcessingCon
       }
 
       if (mTPCDeadChannelMapCreator->useSource(tpc::SourcesDeadMap::FEEConfig)) {
-        pc.inputs().get<char*>("tpcruninfo");
+        pc.inputs().get<o2::tpc::FEEConfig*>("tpcruninfo");
       }
 
       if (dEdxCalibContainer->isCorrectionCCDB(o2::tpc::CalibsdEdx::CalResidualGainMap)) {