ZDC - EOR and Start-Stop-Start functionality of BaselineCalib workflow

Detectors/ZDC/calib/include/ZDCCalib/BaselineCalib.h

@@ -38,6 +38,7 @@ class BaselineCalib
   void setBaselineParam(const BaselineParam* param) { mParam = param; };
   const BaselineParam* getBaselineParam() const { return mParam; };
 
+  void resetInitFlag() { mInitDone = false; };
   void clear();
   //int process(const o2::zdc::BaselineCalibSummaryData& data);
   int process(const o2::zdc::BaselineCalibSummaryData* data);

Detectors/ZDC/calib/include/ZDCCalib/BaselineCalibData.h

@@ -107,6 +107,7 @@ struct BaselineCalibData {
   void print() const;
   void clear();
   void setCreationTime(uint64_t ctime);
+  void mergeCreationTime(uint64_t ctime);
   void setN(int n);
   BaselineCalibSummaryData& getSummary();
   int saveDebugHistos(const std::string fn, float factor);

Detectors/ZDC/calib/include/ZDCCalib/BaselineCalibEPN.h

@@ -31,7 +31,8 @@ class BaselineCalibEPN
   void setModuleConfig(const ModuleConfig* moduleConfig) { mModuleConfig = moduleConfig; };
   const ModuleConfig* getModuleConfig() { return mModuleConfig; };
 
-  void clear(int ih = -1);
+  void resetInitFlag() { mInitDone = false; };
+  bool getInitFlag() const { return mInitDone; };
   int process(const gsl::span<const o2::zdc::OrbitData>& orbitdata);
   int endOfRun();
   int saveDebugHistos(const std::string fn = "ZDCBaselineCalibEPN.root");

Detectors/ZDC/calib/include/ZDCCalib/BaselineCalibEPNSpec.h

@@ -45,9 +45,12 @@ class BaselineCalibEPNSpec : public o2::framework::Task
   void endOfStream(o2::framework::EndOfStreamContext& ec) final;
 
  private:
-  int mVerbosity = DbgZero;  // Verbosity level
-  bool mInitialized = false; // Connect once to CCDB during initialization
-  BaselineCalibEPN mWorker;  // Baseline calibration object
+  int mVerbosity = DbgZero;       // Verbosity level
+  int mProcessed = 0;             // Number of TF processed
+  int mModTF = 0;                 // Number of TF to cumulate before transmitting data
+  bool mInitialized = false;      // Connect once to CCDB during initialization
+  bool mRunStopRequested = false; // Request to stop the run from ECS
+  BaselineCalibEPN mWorker;       // Baseline calibration object
   TStopwatch mTimer;
 };
 

Detectors/ZDC/calib/include/ZDCCalib/BaselineCalibSpec.h

@@ -17,6 +17,7 @@
 #define O2_ZDC_BASELINECALIB_SPEC
 
 #include <TStopwatch.h>
+#include "Headers/DataHeader.h"
 #include "Framework/Logger.h"
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/DataAllocator.h"
@@ -46,18 +47,24 @@ class BaselineCalibSpec : public o2::framework::Task
   void finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj) final;
   void run(o2::framework::ProcessingContext& pc) final;
   void endOfStream(o2::framework::EndOfStreamContext& ec) final;
-  void sendOutput(o2::framework::EndOfStreamContext& ec);
+  void sendOutput(); // Send output to CCDB
+  void reset();      // Ask for a reset internal structures
 
  private:
   int mVerbosity = DbgMinimal; // Verbosity level
   bool mInitialized = false;   // Connect once to CCDB during initialization
+  uint64_t mCTimeEnd = 0;      // Time of last processed time frame
+  uint64_t mCTimeMod = 0;      // Integration time slot
+  uint32_t mProcessed = 0;     // Number of cycles since last CCDB write
   BaselineCalib mWorker;       // Baseline calibration object
   TStopwatch mTimer;
-  long mRunStartTime = 0;     /// start time of the run (ms)
-  std::string mOutputDir;     /// where to write calibration digits
-  std::string mHistoFileName; /// file name of output calib digits
+  o2::framework::DataAllocator* mOutput = nullptr;                             /// Pointer to output object
+  std::unique_ptr<o2::dataformats::FileMetaData> mHistoFileMetaData = nullptr; /// Pointer to metadata file
+  std::string mOutputDir;                                                      /// where to write calibration digits
+  std::string mHistoFileName;                                                  /// file name of output calib digits
   std::string mLHCPeriod;
-  int mRunNumber = -1;
+  o2::header::DataHeader::RunNumberType mRunNumber = 0; /// Current run number
+  long mRunStartTime = 0;                               /// start time of the run (ms)
 };
 
 framework::DataProcessorSpec getBaselineCalibSpec();

Detectors/ZDC/calib/include/ZDCCalib/CalibParamZDC.h

@@ -32,8 +32,9 @@ struct CalibParamZDC : public o2::conf::ConfigurableParamHelper<CalibParamZDC> {
   std::string outputDir = "./";                      // ROOT files output directory
   std::string metaFileDir = "/dev/null";             // Metafile output directory
   std::string descr;                                 // Calibration description
+  uint32_t modTF = 0;                                // Number of TF cumulated before transmitting calibration data (0 transmit every timeframe)
+  uint64_t mCTimeMod = 0;                            // Integration time slot (0 = integrate all run)
   int64_t eovTune = -o2::ccdb::CcdbObjectInfo::YEAR; // Tune end of validity of calibration object (eovTune>0 -> absolute, eovTune<0 increase by -eovTune)
-
   int updateCcdbObjectInfo(o2::ccdb::CcdbObjectInfo& info) const;
   void print() const;
   O2ParamDef(CalibParamZDC, "CalibParamZDC");

Detectors/ZDC/calib/include/ZDCCalib/NoiseCalibEPN.h

@@ -10,12 +10,14 @@
 // or submit itself to any jurisdiction.
 
 #include <memory>
+#include <map>
 #include <gsl/span>
 #include "ZDCBase/Constants.h"
 #include "CommonDataFormat/FlatHisto1D.h"
 #include "ZDCBase/ModuleConfig.h"
 #include "DataFormatsZDC/BCData.h"
 #include "DataFormatsZDC/ChannelData.h"
+#include "DataFormatsZDC/OrbitData.h"
 #include "ZDCReconstruction/RecoParamZDC.h"
 #include "ZDCCalib/NoiseCalibData.h"
 #ifndef ALICEO2_ZDC_NOISECALIBEPN_H
@@ -34,7 +36,7 @@ class NoiseCalibEPN
   const ModuleConfig* getModuleConfig() { return mModuleConfig; };
 
   void clear(int ih = -1);
-  int process(const gsl::span<const o2::zdc::BCData>& bcdata, const gsl::span<const o2::zdc::ChannelData>& chdata);
+  int process(const gsl::span<const o2::zdc::OrbitData>& orbitdata, const gsl::span<const o2::zdc::BCData>& bcdata, const gsl::span<const o2::zdc::ChannelData>& chdata);
   int endOfRun();
   int saveDebugHistos(const std::string fn = "ZDCNoiseCalibEPN.root");
   void setSaveDebugHistos() { mSaveDebugHistos = true; }
@@ -43,6 +45,8 @@ class NoiseCalibEPN
   NoiseCalibData mData;
   NoiseCalibData& getData() { return mData; }
   std::array<o2::dataformats::FlatHisto1D<double>*, NChannels> mH{};
+  std::array<o2::dataformats::FlatHisto1D<double>*, NChannels> mHS{};
+  std::array<o2::dataformats::FlatHisto1D<double>*, NChannels> mHD{};
 
  private:
   bool mInitDone = false;

Detectors/ZDC/calib/src/BaselineCalib.cxx

@@ -56,13 +56,27 @@ void BaselineCalib::clear()
 //______________________________________________________________________________
 int BaselineCalib::process(const o2::zdc::BaselineCalibSummaryData* data)
 {
+#ifdef O2_ZDC_DEBUG
+  LOG(info) << "BaselineCalib::process(" << data << ")";
+  if (mVerbosity >= DbgFull) {
+    printf("Data to be added\n");
+    data->print();
+  }
+#endif
+
   if (!mInitDone) {
     init();
   }
+
+#ifdef O2_ZDC_DEBUG
+  printf("Before adding\n");
   if (mVerbosity >= DbgFull) {
-    data->print();
+    mData.print();
   }
+#endif
+
   mData += data;
+
   if (mVerbosity >= DbgFull) {
     mData.print();
   }

Detectors/ZDC/calib/src/BaselineCalibData.cxx

@@ -76,6 +76,9 @@ BaselineCalibData& BaselineCalibData::operator+=(const BaselineCalibData& other)
 //______________________________________________________________________________
 BaselineCalibData& BaselineCalibData::operator=(const BaselineCalibSummaryData& s)
 {
+#ifdef O2_ZDC_DEGUG
+  LOGF(info) << "BaselineCalibData assigning BaselineCalibSummaryData" s.print();
+#endif
   mCTimeBeg = s.mCTimeBeg;
   mCTimeEnd = s.mCTimeEnd;
   mOverflow = s.mOverflow;
@@ -102,6 +105,9 @@ BaselineCalibData& BaselineCalibData::operator+=(const BaselineCalibSummaryData*
     LOG(error) << "BaselineCalibData::operator+=(const BaselineCalibSummaryData* s): null pointer";
     return *this;
   }
+#ifdef O2_ZDC_DEGUG
+  LOGF(info) << "BaselineCalibData cumulating BaselineCalibSummaryData" s.print();
+#endif
   if (s->mOverflow) {
     // Refusing to add an overflow
     LOG(warn) << __func__ << " Refusing to add an overflow BaselineCalibSummaryData BREAK!";
@@ -118,7 +124,7 @@ BaselineCalibData& BaselineCalibData::operator+=(const BaselineCalibSummaryData*
   }
   // Check if sum will result into an overflow
   for (auto& bin : s->mData) {
-    uint64_t sum = mHisto[bin.id].mData[bin.ibin] = bin.cont;
+    uint64_t sum = mHisto[bin.id].mData[bin.ibin] + bin.cont;
     if (sum > 0xffffffff) {
       LOG(warn) << __func__ << " Addition would result in an overflow for ch " << bin.id << " BREAK!";
       return *this;
@@ -131,7 +137,7 @@ BaselineCalibData& BaselineCalibData::operator+=(const BaselineCalibSummaryData*
     mCTimeEnd = s->mCTimeEnd;
   }
   for (auto& bin : s->mData) {
-    mHisto[bin.id].mData[bin.ibin] += bin.cont;
+    mHisto[bin.id].mData[bin.ibin] = mHisto[bin.id].mData[bin.ibin] + bin.cont;
   }
   return *this;
 }
@@ -146,6 +152,20 @@ void BaselineCalibData::setCreationTime(uint64_t ctime)
 #endif
 }
 
+//______________________________________________________________________________
+void BaselineCalibData::mergeCreationTime(uint64_t ctime)
+{
+  if (mCTimeBeg == 0 || ctime < mCTimeBeg) {
+    mCTimeBeg = ctime;
+  }
+  if (ctime > mCTimeEnd) {
+    mCTimeEnd = ctime;
+  }
+#ifdef O2_ZDC_DEBUG
+  LOGF(info, "BaselineCalibData::mergeCreationTime %llu", ctime);
+#endif
+}
+
 //______________________________________________________________________________
 uint64_t BaselineCalibData::getEntries(int is) const
 {
@@ -290,13 +310,13 @@ void BaselineCalibSummaryData::print() const
     }
     printf("\n");
   }
-  int nbin[NChannels] = {0};
-  uint64_t ccont[NChannels] = {0};
+  int nbin[NChannels] = {0};       // Number of bin populated
+  uint64_t ccont[NChannels] = {0}; // Entries in the histogram
   for (auto& bin : mData) {
     nbin[bin.id]++;
     ccont[bin.id] += bin.cont;
   }
   for (int32_t is = 0; is < NChannels; is++) {
-    LOG(info) << "Summary ch " << is << " nbin = " << nbin[is] << " ccont = " << ccont[is];
+    LOGF(info, "Summary ch %2d nbin = %d events = %llu", is, nbin[is], ccont[is]);
   }
 }

Detectors/ZDC/calib/src/BaselineCalibEPN.cxx

@@ -25,13 +25,23 @@ int BaselineCalibEPN::init()
 {
   // Inspect reconstruction parameters
   const auto& opt = CalibParamZDC::Instance();
-  opt.print();
+  if (mVerbosity >= DbgFull) {
+    opt.print();
+  }
+
   if (opt.debugOutput == true) {
     setSaveDebugHistos();
   }
 
-  if (mVerbosity > DbgZero) {
-    mModuleConfig->print();
+  static bool firstCall = true;
+  if (firstCall) {
+    if (mVerbosity >= DbgMedium) {
+      mModuleConfig->print();
+    }
+    firstCall = false;
+  } else {
+    // Reset data structure
+    mData.clear();
   }
 
   mInitDone = true;
@@ -65,16 +75,21 @@ int BaselineCalibEPN::process(const gsl::span<const o2::zdc::OrbitData>& orbitda
 int BaselineCalibEPN::endOfRun()
 {
   if (mVerbosity > DbgZero) {
-    mData.print();
+    LOG(info) << "BaselineCalibEPN::endOfRun";
   }
   if (mSaveDebugHistos) {
+    if (mVerbosity >= DbgMedium) {
+      mData.print();
+    }
     saveDebugHistos();
   }
+  mInitDone = false;
   return 0;
 }
 
 //______________________________________________________________________________
 int BaselineCalibEPN::saveDebugHistos(const std::string fn)
 {
+  // EPN debug histos refer to histograms from last reset
   return mData.saveDebugHistos(fn, mModuleConfig->baselineFactor);
 }