TPC: Merging SAC CCDB files into one object

- adding option to enable/disable writing of FFT coefficients to the CCDB
AliceO2Group · Mar 4, 2025 · ea35977 · ea35977
1 parent 2abc6f4
commit ea35977
Show file tree

Hide file tree

Showing 5 changed files with 38 additions and 38 deletions.
diff --git a/Detectors/TPC/base/include/TPCBase/CDBTypes.h b/Detectors/TPC/base/include/TPCBase/CDBTypes.h
@@ -66,6 +66,7 @@ enum class CDBType {
   CalSAC1,              ///< I_1(t) = <I(r,\phi,t) / I_0(r,\phi)>_{r,\phi}
   CalSACDelta,          ///< \Delta I(r,\phi,t) = I(r,\phi,t) / ( I_0(r,\phi) * I_1(t) )
   CalSACFourier,        ///< Fourier coefficients of CalSAC1
+  CalSAC,               ///< CalSAC0, CalSAC1 and CalSACDelta
                         ///
   CalITPC0,             ///< 2D average TPC clusters for longer time interval
   CalITPC1,             ///< 1D integrated TPC clusters
@@ -133,6 +134,7 @@ const std::unordered_map<CDBType, const std::string> CDBTypeMap{
   {CDBType::CalSAC0, "TPC/Calib/SAC_0"},
   {CDBType::CalSAC1, "TPC/Calib/SAC_1"},
   {CDBType::CalSACDelta, "TPC/Calib/SAC_DELTA"},
+  {CDBType::CalSAC, "TPC/Calib/SAC"},
   {CDBType::CalSACFourier, "TPC/Calib/SAC_FOURIER"},
   // ITPCCs
   {CDBType::CalITPC0, "TPC/Calib/ITPCC_0"},

diff --git a/Detectors/TPC/calibration/include/TPCCalibration/IDCContainer.h b/Detectors/TPC/calibration/include/TPCCalibration/IDCContainer.h
@@ -402,6 +402,14 @@ struct SACDelta {
   std::array<IDCDelta<DataT>, SIDES> mSACDelta{};
 };
 
+/// container to be written to CCDB
+template <typename DataT>
+struct SAC {
+  SACZero mSACZero{};
+  SACOne mSACOne{};
+  SACDelta<DataT> mSACDelta{};
+};
+
 struct FourierCoeffSAC {
   std::array<FourierCoeff, SIDES> mCoeff{};
 };

diff --git a/Detectors/TPC/calibration/src/TPCCalibrationLinkDef.h b/Detectors/TPC/calibration/src/TPCCalibrationLinkDef.h
@@ -96,6 +96,9 @@
 #pragma link C++ struct o2::tpc::SACDelta < float> + ;
 #pragma link C++ struct o2::tpc::SACDelta < unsigned short> + ;
 #pragma link C++ struct o2::tpc::SACDelta < unsigned char> + ;
+#pragma link C++ struct o2::tpc::SAC < float> + ;
+#pragma link C++ struct o2::tpc::SAC < unsigned short> + ;
+#pragma link C++ struct o2::tpc::SAC < unsigned char> + ;
 #pragma link C++ struct o2::tpc::SACZero + ;
 #pragma link C++ struct o2::tpc::SACOne + ;
 #pragma link C++ struct o2::tpc::FourierCoeffSAC + ;

diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFactorizeSACSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFactorizeSACSpec.h
@@ -82,9 +82,7 @@ class TPCFactorizeSACSpec : public o2::framework::Task
   static constexpr header::DataDescription getDataDescriptionLane() { return header::DataDescription{"SACLANE"}; }
 
   // for CCDB
-  static constexpr header::DataDescription getDataDescriptionCCDBSAC0() { return header::DataDescription{"TPC_CalibSAC0"}; }
-  static constexpr header::DataDescription getDataDescriptionCCDBSAC1() { return header::DataDescription{"TPC_CalibSAC1"}; }
-  static constexpr header::DataDescription getDataDescriptionCCDBSACDelta() { return header::DataDescription{"TPC_SACDelta"}; }
+  static constexpr header::DataDescription getDataDescriptionCCDBSAC() { return header::DataDescription{"TPC_CalibSAC"}; }
 
  private:
   SACFactorization mSACFactorization;                                                                                                                                     ///< object for performing the factorization of the SACs
@@ -106,42 +104,30 @@ class TPCFactorizeSACSpec : public o2::framework::Task
       output.snapshot(Output{gDataOriginTPC, getDataDescriptionTimeStamp()}, std::vector<uint64_t>{timeStampStart, timeStampEnd});
       output.snapshot(Output{gDataOriginTPC, getDataDescriptionLane()}, mLaneId);
 
-      o2::ccdb::CcdbObjectInfo ccdbInfoSAC0(CDBTypeMap.at(CDBType::CalSAC0), std::string{}, std::string{}, std::map<std::string, std::string>{}, timeStampStart, timeStampEnd);
-      auto imageSAC0 = o2::ccdb::CcdbApi::createObjectImage(&mSACFactorization.getSACZero(), &ccdbInfoSAC0);
-      LOGP(info, "Sending object {} / {} of size {} bytes, valid for {} : {} ", ccdbInfoSAC0.getPath(), ccdbInfoSAC0.getFileName(), imageSAC0->size(), ccdbInfoSAC0.getStartValidityTimestamp(), ccdbInfoSAC0.getEndValidityTimestamp());
-      output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, getDataDescriptionCCDBSAC0(), 0}, *imageSAC0.get());
-      output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, getDataDescriptionCCDBSAC0(), 0}, ccdbInfoSAC0);
-
-      o2::ccdb::CcdbObjectInfo ccdbInfoSAC1(CDBTypeMap.at(CDBType::CalSAC1), std::string{}, std::string{}, std::map<std::string, std::string>{}, timeStampStart, timeStampEnd);
-      auto imageSAC1 = o2::ccdb::CcdbApi::createObjectImage(&mSACFactorization.getSACOne(), &ccdbInfoSAC1);
-      LOGP(info, "Sending object {} / {} of size {} bytes, valid for {} : {} ", ccdbInfoSAC1.getPath(), ccdbInfoSAC1.getFileName(), imageSAC1->size(), ccdbInfoSAC1.getStartValidityTimestamp(), ccdbInfoSAC1.getEndValidityTimestamp());
-      output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, getDataDescriptionCCDBSAC1(), 0}, *imageSAC1.get());
-      output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, getDataDescriptionCCDBSAC1(), 0}, ccdbInfoSAC1);
-
-      o2::ccdb::CcdbObjectInfo ccdbInfoSACDelta(CDBTypeMap.at(CDBType::CalSACDelta), std::string{}, std::string{}, std::map<std::string, std::string>{}, timeStampStart, timeStampEnd);
+      o2::ccdb::CcdbObjectInfo ccdbInfoSAC(CDBTypeMap.at(CDBType::CalSAC), std::string{}, std::string{}, std::map<std::string, std::string>{}, timeStampStart, timeStampEnd);
 
       std::unique_ptr<std::vector<char>> imageSACDelta{};
       switch (mCompressionDeltaSAC) {
         case SACFactorization::SACDeltaCompression::MEDIUM:
         default: {
-          const SACDelta<unsigned short> sacDelta = mSACFactorization.getSACDeltaMediumCompressed();
-          imageSACDelta = o2::ccdb::CcdbApi::createObjectImage(&sacDelta, &ccdbInfoSACDelta);
+          SAC<unsigned short> sacContainer{mSACFactorization.getSACZero(), mSACFactorization.getSACOne(), mSACFactorization.getSACDeltaMediumCompressed()};
+          imageSACDelta = o2::ccdb::CcdbApi::createObjectImage(&sacContainer, &ccdbInfoSAC);
           break;
         }
         case SACFactorization::SACDeltaCompression::HIGH: {
-          const SACDelta<unsigned char> sacDelta = mSACFactorization.getSACDeltaHighCompressed();
-          imageSACDelta = o2::ccdb::CcdbApi::createObjectImage(&sacDelta, &ccdbInfoSACDelta);
+          SAC<unsigned char> sacContainer{mSACFactorization.getSACZero(), mSACFactorization.getSACOne(), mSACFactorization.getSACDeltaHighCompressed()};
+          imageSACDelta = o2::ccdb::CcdbApi::createObjectImage(&sacContainer, &ccdbInfoSAC);
           break;
         }
         case SACFactorization::SACDeltaCompression::NO:
-          SACDelta<float> sacDelta = std::move(mSACFactorization).getSACDeltaUncompressed();
-          imageSACDelta = o2::ccdb::CcdbApi::createObjectImage(&sacDelta, &ccdbInfoSACDelta);
+          SAC<float> sacContainer{mSACFactorization.getSACZero(), mSACFactorization.getSACOne(), std::move(mSACFactorization).getSACDeltaUncompressed()};
+          imageSACDelta = o2::ccdb::CcdbApi::createObjectImage(&sacContainer, &ccdbInfoSAC);
           break;
       }
 
-      LOGP(info, "Sending object {} / {} of size {} bytes, valid for {} : {} ", ccdbInfoSACDelta.getPath(), ccdbInfoSACDelta.getFileName(), imageSACDelta->size(), ccdbInfoSACDelta.getStartValidityTimestamp(), ccdbInfoSACDelta.getEndValidityTimestamp());
-      output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, getDataDescriptionCCDBSACDelta(), 0}, *imageSACDelta.get());
-      output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, getDataDescriptionCCDBSACDelta(), 0}, ccdbInfoSACDelta);
+      LOGP(info, "Sending object {} / {} of size {} bytes, valid for {} : {} ", ccdbInfoSAC.getPath(), ccdbInfoSAC.getFileName(), imageSACDelta->size(), ccdbInfoSAC.getStartValidityTimestamp(), ccdbInfoSAC.getEndValidityTimestamp());
+      output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, getDataDescriptionCCDBSAC(), 0}, *imageSACDelta.get());
+      output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, getDataDescriptionCCDBSAC(), 0}, ccdbInfoSAC);
     } else {
       LOGP(warning, "Received empty data for SACs! SACs will not be stored for the current aggregation interval!");
     }
@@ -153,12 +139,8 @@ class TPCFactorizeSACSpec : public o2::framework::Task
 DataProcessorSpec getTPCFactorizeSACSpec(const int lane, const unsigned int timeframes, const SACFactorization::SACFactorization::SACDeltaCompression compression, const bool debug)
 {
   std::vector<OutputSpec> outputSpecs;
-  outputSpecs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBPayload, TPCFactorizeSACSpec::getDataDescriptionCCDBSAC0()}, Lifetime::Sporadic);
-  outputSpecs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper, TPCFactorizeSACSpec::getDataDescriptionCCDBSAC0()}, Lifetime::Sporadic);
-  outputSpecs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBPayload, TPCFactorizeSACSpec::getDataDescriptionCCDBSAC1()}, Lifetime::Sporadic);
-  outputSpecs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper, TPCFactorizeSACSpec::getDataDescriptionCCDBSAC1()}, Lifetime::Sporadic);
-  outputSpecs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBPayload, TPCFactorizeSACSpec::getDataDescriptionCCDBSACDelta()}, Lifetime::Sporadic);
-  outputSpecs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper, TPCFactorizeSACSpec::getDataDescriptionCCDBSACDelta()}, Lifetime::Sporadic);
+  outputSpecs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBPayload, TPCFactorizeSACSpec::getDataDescriptionCCDBSAC()}, Lifetime::Sporadic);
+  outputSpecs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper, TPCFactorizeSACSpec::getDataDescriptionCCDBSAC()}, Lifetime::Sporadic);
 
   outputSpecs.emplace_back(ConcreteDataMatcher{gDataOriginTPC, TPCFactorizeSACSpec::getDataDescriptionSAC1(), header::DataHeader::SubSpecificationType{Side::A}}, Lifetime::Sporadic);
   outputSpecs.emplace_back(ConcreteDataMatcher{gDataOriginTPC, TPCFactorizeSACSpec::getDataDescriptionSAC1(), header::DataHeader::SubSpecificationType{Side::C}}, Lifetime::Sporadic);

diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFourierTransformAggregatorSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFourierTransformAggregatorSpec.h
@@ -63,6 +63,7 @@ class TPCFourierTransformAggregatorSpec : public o2::framework::Task
     mIntervalsSACs = ic.options().get<int>("intervalsSACs");
     mLengthIDCScalerSeconds = ic.options().get<float>("tpcScalerLengthS");
     mDisableScaler = ic.options().get<bool>("disable-scaler");
+    mEnableFFTCCDB = ic.options().get<bool>("enable-fft-CCDB");
     resizeBuffer(mInputLanes);
   }
 
@@ -173,11 +174,13 @@ class TPCFourierTransformAggregatorSpec : public o2::framework::Task
           mIDCFourierTransform[side].calcFourierCoefficients(mIntervalsBuffer[mExpectedInputLane].size());
 
           if (!mProcessSACs) {
-            o2::ccdb::CcdbObjectInfo ccdbInfo(CDBTypeMap.at(((side == 0) ? CDBType::CalIDCFourierA : CDBType::CalIDCFourierC)), std::string{}, std::string{}, std::map<std::string, std::string>{}, mCCDBBuffer[mExpectedInputLane].front(), mCCDBBuffer[mExpectedInputLane].back());
-            auto imageFFT = o2::ccdb::CcdbApi::createObjectImage(&mIDCFourierTransform[side].getFourierCoefficients(), &ccdbInfo);
-            LOGP(info, "Sending object {} / {} of size {} bytes, valid for {} : {} ", ccdbInfo.getPath(), ccdbInfo.getFileName(), imageFFT->size(), ccdbInfo.getStartValidityTimestamp(), ccdbInfo.getEndValidityTimestamp());
-            pc.outputs().snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, getDataDescriptionCCDBFourier(), 0}, *imageFFT.get());
-            pc.outputs().snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, getDataDescriptionCCDBFourier(), 0}, ccdbInfo);
+            if (mEnableFFTCCDB) {
+              o2::ccdb::CcdbObjectInfo ccdbInfo(CDBTypeMap.at(((side == 0) ? CDBType::CalIDCFourierA : CDBType::CalIDCFourierC)), std::string{}, std::string{}, std::map<std::string, std::string>{}, mCCDBBuffer[mExpectedInputLane].front(), mCCDBBuffer[mExpectedInputLane].back());
+              auto imageFFT = o2::ccdb::CcdbApi::createObjectImage(&mIDCFourierTransform[side].getFourierCoefficients(), &ccdbInfo);
+              LOGP(info, "Sending object {} / {} of size {} bytes, valid for {} : {} ", ccdbInfo.getPath(), ccdbInfo.getFileName(), imageFFT->size(), ccdbInfo.getStartValidityTimestamp(), ccdbInfo.getEndValidityTimestamp());
+              pc.outputs().snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, getDataDescriptionCCDBFourier(), 0}, *imageFFT.get());
+              pc.outputs().snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, getDataDescriptionCCDBFourier(), 0}, ccdbInfo);
+            }
           } else {
             coeffSAC.mCoeff[side] = mIDCFourierTransform[side].getFourierCoefficients();
           }
@@ -192,7 +195,7 @@ class TPCFourierTransformAggregatorSpec : public o2::framework::Task
           }
         }
 
-        if (mProcessSACs) {
+        if (mProcessSACs && mEnableFFTCCDB) {
           o2::ccdb::CcdbObjectInfo ccdbInfo(CDBTypeMap.at(CDBType::CalSACFourier), std::string{}, std::string{}, std::map<std::string, std::string>{}, mCCDBBuffer[mExpectedInputLane].front(), mCCDBBuffer[mExpectedInputLane].back());
           auto imageFFT = o2::ccdb::CcdbApi::createObjectImage(&coeffSAC, &ccdbInfo);
           LOGP(info, "Sending object {} / {} of size {} bytes, valid for {} : {} ", ccdbInfo.getPath(), ccdbInfo.getFileName(), imageFFT->size(), ccdbInfo.getStartValidityTimestamp(), ccdbInfo.getEndValidityTimestamp());
@@ -233,6 +236,7 @@ class TPCFourierTransformAggregatorSpec : public o2::framework::Task
   long mIDCSCalerEndTSLast = 0;                                    ///< end time stamp of last TPC IDC scaler object to ensure no gapps
   o2::tpc::TPCScaler mScalerLast;                                  ///< buffer last scaler to easily add internal overlap for the beginning
   bool mDisableScaler{false};                                      ///< disable the creation of TPC IDC scalers
+  bool mEnableFFTCCDB{false};                                      ///< write FFT coefficients to CCDB
   int mRun{};
   const std::array<std::vector<InputSpec>, 2> mFilter = {std::vector<InputSpec>{{"idcone", ConcreteDataTypeMatcher{o2::header::gDataOriginTPC, TPCFactorizeIDCSpec::getDataDescriptionIDC1()}, Lifetime::Sporadic}},
                                                          std::vector<InputSpec>{{"sacone", ConcreteDataTypeMatcher{o2::header::gDataOriginTPC, TPCFactorizeSACSpec::getDataDescriptionSAC1()}, Lifetime::Sporadic}}}; ///< filter for looping over input data
@@ -438,7 +442,8 @@ DataProcessorSpec getTPCFourierTransformAggregatorSpec(const unsigned int rangeI
     Options{{"intervalsSACs", VariantType::Int, 11, {"Number of integration intervals which will be sampled for the fourier coefficients"}},
             {"dump-coefficients-agg", VariantType::Bool, false, {"Dump fourier coefficients to file"}},
             {"tpcScalerLengthS", VariantType::Float, 300.f, {"Length of the TPC scalers in seconds"}},
-            {"disable-scaler", VariantType::Bool, false, {"Disable creation of IDC scaler"}}}};
+            {"disable-scaler", VariantType::Bool, false, {"Disable creation of IDC scaler"}},
+            {"enable-fft-CCDB", VariantType::Bool, false, {"Enable writing of FFT coefficients to CCDB"}}}};
 }
 
 } // namespace o2::tpc