TRD vDrift calib uses proper CCDB output mechanism

Author: martenole

Detectors/TRD/calibration/include/TRDCalibration/CalibratorVdExB.h

@@ -20,6 +20,8 @@
 #include "DetectorsCalibration/TimeSlot.h"
 #include "DataFormatsTRD/Constants.h"
 #include "DataFormatsTRD/AngularResidHistos.h"
+#include "CCDB/CcdbObjectInfo.h"
+#include "DataFormatsTRD/CalVdriftExB.h"
 
 #include "Rtypes.h"
 #include "TProfile.h"
@@ -60,12 +62,17 @@ class CalibratorVdExB final : public o2::calibration::TimeSlotCalibration<o2::tr
   void finalizeSlot(Slot& slot) final;
   Slot& emplaceNewSlot(bool front, TFType tStart, TFType tEnd) final;
 
+  const std::vector<o2::trd::CalVdriftExB>& getCcdbObjectVector() const { return mObjectVector; }
+  std::vector<o2::ccdb::CcdbObjectInfo>& getCcdbObjectInfoVector() { return mInfoVector; }
+
   void initProcessing();
 
  private:
   bool mInitDone{false}; ///< flag to avoid creating the TProfiles multiple times
   size_t mMinEntries; ///< minimum total number of angular deviations (on average ~3 entries per bin for each TRD chamber)
   FitFunctor mFitFunctor; ///< used for minimization procedure
+  std::vector<o2::ccdb::CcdbObjectInfo> mInfoVector; ///< vector of CCDB infos; each element is filled with CCDB description of accompanying CCDB calibration object
+  std::vector<o2::trd::CalVdriftExB> mObjectVector;  ///< vector of CCDB calibration objects; the extracted vDrift and ExB per chamber for given slot
   ClassDefOverride(CalibratorVdExB, 1);
 };
 

Detectors/TRD/calibration/src/CalibratorVdExB.cxx

@@ -14,7 +14,6 @@
 /// \author Ole Schmidt
 
 #include "TRDCalibration/CalibratorVdExB.h"
-#include "DataFormatsTRD/CalVdriftExB.h"
 #include "Fit/Fitter.h"
 #include "TStopwatch.h"
 #include "CCDB/CcdbApi.h"
@@ -23,6 +22,7 @@
 #include <map>
 #include <memory>
 #include "CommonUtils/NameConf.h"
+#include "CommonUtils/MemFileHelper.h"
 
 using namespace o2::trd::constants;
 
@@ -89,8 +89,9 @@ using Slot = o2::calibration::TimeSlot<AngularResidHistos>;
 
 void CalibratorVdExB::initOutput()
 {
-  // prepare output objects which will go to CCDB
-  // nothing to be done
+  // reset the CCDB output vectors
+  mInfoVector.clear();
+  mObjectVector.clear();
 }
 
 void CalibratorVdExB::initProcessing()
@@ -153,22 +154,20 @@ void CalibratorVdExB::finalizeSlot(Slot& slot)
   timer.Stop();
   LOGF(info, "Done fitting angular residual histograms. CPU time: %f, real time: %f", timer.CpuTime(), timer.RealTime());
 
-  // write results to CCDB
-  o2::ccdb::CcdbApi ccdb;
-  ccdb.init(o2::base::NameConf::getCCDBServer());
-  // ccdb.init("http://localhost:8080");
-  std::map<std::string, std::string> metadata; // TODO: do we want to store any meta data?
+  // assemble CCDB object
   CalVdriftExB calObject;
   for (int iDet = 0; iDet < MAXCHAMBER; ++iDet) {
     // OS: what about chambers for which we had no data in this slot? should we use the initial parameters or something else?
     // maybe it is better not to overwrite an older result if we don't have anything better?
     calObject.setVdrift(iDet, vdFitResults[iDet]);
     calObject.setExB(iDet, laFitResults[iDet]);
   }
-  auto timeStamp = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
-  auto timeStampEnd = timeStamp;
-  timeStampEnd += 1e3 * 60 * 60 * 24 * 7; // set validity of 7 days
-  ccdb.storeAsTFileAny(&calObject, "TRD/Calib/CalVdriftExB", metadata, timeStamp, timeStampEnd);
+  auto clName = o2::utils::MemFileHelper::getClassName(calObject);
+  auto flName = o2::ccdb::CcdbApi::generateFileName(clName);
+  std::map<std::string, std::string> metadata; // TODO: do we want to store any meta data?
+  long startValidity = slot.getStartTimeMS() - 10 * o2::ccdb::CcdbObjectInfo::SECOND;
+  mInfoVector.emplace_back("TRD/Calib/CalVdriftExB", clName, flName, metadata, startValidity, startValidity + o2::ccdb::CcdbObjectInfo::HOUR);
+  mObjectVector.push_back(calObject);
 }
 
 Slot& CalibratorVdExB::emplaceNewSlot(bool front, TFType tStart, TFType tEnd)

Detectors/TRD/workflow/include/TRDWorkflow/VdAndExBCalibSpec.h

@@ -43,10 +43,10 @@ class VdAndExBCalibDevice : public o2::framework::Task
   {
     o2::base::GRPGeomHelper::instance().setRequest(mCCDBRequest);
     int minEnt = ic.options().get<int>("min-entries");
-    auto slotL = ic.options().get<uint32_t>("tf-per-slot");
+    auto slotL = ic.options().get<uint32_t>("sec-per-slot");
     auto delay = ic.options().get<uint32_t>("max-delay");
     mCalibrator = std::make_unique<o2::trd::CalibratorVdExB>(minEnt);
-    mCalibrator->setSlotLength(slotL);
+    mCalibrator->setSlotLengthInSeconds(slotL);
     mCalibrator->setMaxSlotsDelay(delay);
   }
 
@@ -78,9 +78,26 @@ class VdAndExBCalibDevice : public o2::framework::Task
   //________________________________________________________________
   void sendOutput(DataAllocator& output)
   {
-    // See LHCClockCalibratorSpec.h
-    // Before this can be implemented the output CCDB objects need to be defined
-    // and added to CalibratorVdExB
+    // extract CCDB infos and calibration objects, convert it to TMemFile and send them to the output
+    // TODO in principle, this routine is generic, can be moved to Utils.h
+
+    using clbUtils = o2::calibration::Utils;
+    const auto& payloadVec = mCalibrator->getCcdbObjectVector();
+    auto& infoVec = mCalibrator->getCcdbObjectInfoVector(); // use non-const version as we update it
+    assert(payloadVec.size() == infoVec.size());
+
+    for (uint32_t i = 0; i < payloadVec.size(); i++) {
+      auto& w = infoVec[i];
+      auto image = o2::ccdb::CcdbApi::createObjectImage(&payloadVec[i], &w);
+      LOG(info) << "Sending object " << w.getPath() << "/" << w.getFileName() << " of size " << image->size()
+                << " bytes, valid for " << w.getStartValidityTimestamp() << " : " << w.getEndValidityTimestamp();
+
+      output.snapshot(Output{clbUtils::gDataOriginCDBPayload, "VDRIFTEXB", i}, *image.get()); // vector<char>
+      output.snapshot(Output{clbUtils::gDataOriginCDBWrapper, "VDRIFTEXB", i}, w);            // root-serialized
+    }
+    if (payloadVec.size()) {
+      mCalibrator->initOutput(); // reset the outputs once they are already sent
+    }
   }
 };
 
@@ -95,8 +112,8 @@ DataProcessorSpec getTRDVdAndExBCalibSpec()
   using clbUtils = o2::calibration::Utils;
 
   std::vector<OutputSpec> outputs;
-  //outputs.emplace_back(ConcreteDataTypeMatcher{clbUtils::gDataOriginCLB, clbUtils::gDataDescriptionCLBPayload});
-  //outputs.emplace_back(ConcreteDataTypeMatcher{clbUtils::gDataOriginCLB, clbUtils::gDataDescriptionCLBInfo});
+  outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBPayload, "VDRIFTEXB"}, Lifetime::Sporadic);
+  outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper, "VDRIFTEXB"}, Lifetime::Sporadic);
   std::vector<InputSpec> inputs{{"input", "TRD", "ANGRESHISTS"}};
   auto ccdbRequest = std::make_shared<o2::base::GRPGeomRequest>(true,                           // orbitResetTime
                                                                 true,                           // GRPECS=true
@@ -111,9 +128,9 @@ DataProcessorSpec getTRDVdAndExBCalibSpec()
     outputs,
     AlgorithmSpec{adaptFromTask<device>(ccdbRequest)},
     Options{
-      {"tf-per-slot", VariantType::UInt32, 5u, {"number of TFs per calibration time slot"}},
-      {"max-delay", VariantType::UInt32, 90'000u, {"number of slots in past to consider"}}, // 15 minutes delay, 10ms TF
-      {"min-entries", VariantType::Int, 500, {"minimum number of entries to fit single time slot"}}}};
+      {"sec-per-slot", VariantType::UInt32, 900u, {"number of seconds per calibration time slot"}},
+      {"max-delay", VariantType::UInt32, 2u, {"number of slots in past to consider"}},
+      {"min-entries", VariantType::Int, 40'000, {"minimum number of entries to fit single time slot"}}}}; // around 3 entries per bin per chamber
 }
 
 } // namespace framework

Detectors/TRD/workflow/src/trd-calib-workflow.cxx

@@ -20,7 +20,8 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
 {
   // option allowing to set parameters
   std::vector<o2::framework::ConfigParamSpec> options{
-    {"enable-root-input", o2::framework::VariantType::Bool, false, {"enable root-files input readers"}}};
+    {"enable-root-input", o2::framework::VariantType::Bool, false, {"enable root-files input readers"}},
+    {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}}};
 
   std::swap(workflowOptions, options);
 }