ZDC Small fixes and improved printout in waveform calibration

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

@@ -59,12 +59,18 @@ struct WaveformCalibData {
   inline void setFirstValid(int isig, int ipos)
   {
     if (ipos > mWave[isig].mFirstValid) {
+#ifdef O2_ZDC_WAVEFORMCALIB_DEBUG
+      printf("WaveformCalibChData::%s isig=%-2d mFirstValid %5d -> %5d\n", __func__, isig, mWave[isig].mFirstValid, ipos);
+#endif
       mWave[isig].mFirstValid = ipos;
     }
   }
   inline void setLastValid(int isig, int ipos)
   {
     if (ipos < mWave[isig].mLastValid) {
+#ifdef O2_ZDC_WAVEFORMCALIB_DEBUG
+      printf("WaveformCalibChData::%s isig=%-2d mLastValid %5d -> %5d\n", __func__, isig, mWave[isig].mLastValid, ipos);
+#endif
       mWave[isig].mLastValid = ipos;
     }
   }
@@ -77,6 +83,7 @@ struct WaveformCalibData {
   int getLastValid(int is) const;
   void print() const;
   void clear();
+  void clearWaveforms();
   void setCreationTime(uint64_t ctime);
   void setN(int n);
   int saveDebugHistos(const std::string fn);

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

@@ -29,7 +29,7 @@ class WaveformCalibEPN
  public:
   WaveformCalibEPN() = default;
   int init();
-  void clear(int ih = -1);
+  void clear();
   int process(const gsl::span<const o2::zdc::BCRecData>& bcrec,
               const gsl::span<const o2::zdc::ZDCEnergy>& energy,
               const gsl::span<const o2::zdc::ZDCTDCData>& tdc,
@@ -54,7 +54,7 @@ class WaveformCalibEPN
 
   int mFirst = 0;
   int mLast = 0;
-  int mN = 1;
+  int mN = 10;
 
   void configure(int ifirst, int ilast)
   {
@@ -64,6 +64,7 @@ class WaveformCalibEPN
     mFirst = ifirst;
     mLast = ilast;
     mN = ilast - ifirst + 1;
+    LOG(info) << "WaveformCalibEPN::" << __func__ << " mN=" << mN << "[" << mFirst << ":" << mLast << "]";
   }
 
   WaveformCalibQueue mQueue;

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

@@ -47,6 +47,7 @@ struct WaveformCalibQueue {
   int mNP = 0;              // Number of interpolated points in waveform
   int mTimeLow[NChannels];  /// Cut on position difference low
   int mTimeHigh[NChannels]; /// Cut on position difference high
+  int mVerbosity = 0;
 
   const WaveformCalibConfig* mCfg = nullptr;
 

Detectors/ZDC/calib/src/BaselineCalibConfig.cxx

@@ -83,6 +83,6 @@ void BaselineCalibConfig::setCuts(int low, int high)
 
 void BaselineCalibConfig::setCuts(int isig, int low, int high)
 {
-  cutHigh[isig] = low;
-  cutLow[isig] = high;
+  cutLow[isig] = low;
+  cutHigh[isig] = high;
 }

Detectors/ZDC/calib/src/InterCalibConfig.cxx

@@ -106,8 +106,8 @@ void InterCalibConfig::setCuts(double low, double high)
 
 void InterCalibConfig::setCuts(int ih, double low, double high)
 {
-  cutHigh[ih] = low;
-  cutLow[ih] = high;
+  cutLow[ih] = low;
+  cutHigh[ih] = high;
 }
 
 void InterCalibConfig::setBinning1D(int nb, double amin, double amax)

Detectors/ZDC/calib/src/TDCCalibConfig.cxx

@@ -106,8 +106,8 @@ void TDCCalibConfig::setCuts(double low, double high)
 
 void TDCCalibConfig::setCuts(int ih, double low, double high)
 {
-  cutHigh[ih] = low;
-  cutLow[ih] = high;
+  cutLow[ih] = low;
+  cutHigh[ih] = high;
 }
 
 void TDCCalibConfig::setBinning1D(int nb, double amin, double amax)

Detectors/ZDC/calib/src/WaveformCalibConfig.cxx

@@ -21,8 +21,8 @@ WaveformCalibConfig::WaveformCalibConfig()
     cutHigh[isig] = std::numeric_limits<float>::infinity();
   }
   for (int itdc = 0; itdc < NTDCChannels; itdc++) {
-    cutTimeLow[itdc] = -2.5;
-    cutTimeHigh[itdc] = 2.5;
+    cutTimeLow[itdc] = -1.25;
+    cutTimeHigh[itdc] = 1.25;
   }
 }
 
@@ -132,8 +132,8 @@ void WaveformCalibConfig::setCuts(double low, double high)
 
 void WaveformCalibConfig::setCuts(int isig, double low, double high)
 {
-  cutHigh[isig] = low;
-  cutLow[isig] = high;
+  cutLow[isig] = low;
+  cutHigh[isig] = high;
 }
 
 void WaveformCalibConfig::setTimeCuts(double low, double high)

Detectors/ZDC/calib/src/WaveformCalibData.cxx

@@ -59,9 +59,15 @@ WaveformCalibChData& WaveformCalibChData::operator+=(const WaveformCalibChData&
 {
   if (other.mEntries > 0) {
     if (other.mFirstValid > mFirstValid) {
+#ifdef O2_ZDC_WAVEFORMCALIB_DEBUG
+      printf("WaveformCalibChData::+= mFirstValid %5d -> %5d\n", mFirstValid, other.mFirstValid);
+#endif
       mFirstValid = other.mFirstValid;
     }
     if (other.mLastValid < mLastValid) {
+#ifdef O2_ZDC_WAVEFORMCALIB_DEBUG
+      printf("WaveformCalibChData::+= mLastValid %5d -> %5d\n", mLastValid, other.mLastValid);
+#endif
       mLastValid = other.mLastValid;
     }
     mEntries = mEntries + other.mEntries;
@@ -130,23 +136,23 @@ int WaveformCalibChData::getLastValid() const
 //______________________________________________________________________________
 void WaveformCalibData::setN(int n)
 {
-  if (n >= 0 && n < NBT) {
+  if (n > 0 && n <= NBT) {
     mN = n;
     for (int is = 0; is < NChannels; is++) {
       mWave[is].setN(n);
     }
   } else {
-    LOG(fatal) << "WaveformCalibData " << __func__ << " wrong stored b.c. setting " << n << " not in range [0:" << NBT << "]";
+    LOG(warn) << "WaveformCalibData " << __func__ << " wrong stored b.c. setting " << n << " not in range [1:" << NBT << "]";
   }
 }
 
 void WaveformCalibChData::setN(int n)
 {
-  if (n >= 0 && n < NBT) {
+  if (n > 0 && n <= NBT) {
     mFirstValid = 0;
     mLastValid = n * NTimeBinsPerBC * TSN - 1;
   } else {
-    LOG(fatal) << "WaveformCalibChData " << __func__ << " wrong stored b.c. setting " << n << " not in range [0:" << NBT << "]";
+    LOG(warn) << "WaveformCalibChData " << __func__ << " wrong stored b.c. setting " << n << " not in range [1:" << NBT << "]";
   }
 }
 
@@ -172,6 +178,8 @@ int WaveformCalibData::saveDebugHistos(const std::string fn)
       }
       h.SetEntries(mWave[is].mEntries);
       h.Write("", TObject::kOverwrite);
+    } else {
+      LOG(warn) << "WaveformCalibData " << __func__ << " waveform for ch " << is << " has too few entries: " << mWave[is].mEntries;
     }
   }
   f->Close();
@@ -191,6 +199,16 @@ void WaveformCalibData::clear()
   }
 }
 
+//______________________________________________________________________________
+void WaveformCalibData::clearWaveforms()
+{
+  mCTimeBeg = 0;
+  mCTimeEnd = 0;
+  for (int32_t is = 0; is < NChannels; is++) {
+    mWave[is].clear();
+  }
+}
+
 void WaveformCalibChData::clear()
 {
   mEntries = 0;

Detectors/ZDC/calib/src/WaveformCalibEPN.cxx

@@ -45,17 +45,29 @@ int WaveformCalibEPN::init()
   if (mVerbosity > DbgZero) {
     mQueue.printConf();
   }
+  mQueue.mVerbosity = mVerbosity;
 
   // number of bins
-  mNBin = cfg->nbun * TSN;
+  mNBin = cfg->nbun * TSN * NTimeBinsPerBC;
   mFirst = cfg->ibeg;
   mLast = cfg->iend;
   mData.setN(cfg->nbun);
   mData.mPeak = mQueue.mPeak;
+  LOGF(info, "o2::zdc::WaveformCalibEPN::%s mNBin=%d mFirst=%d mLast=%d mN=%d mPeak=%d", __func__, mNBin, mFirst, mLast, cfg->nbun, mData.mPeak);
   mInitDone = true;
   return 0;
 }
 
+void WaveformCalibEPN::clear()
+{
+#ifdef O2_ZDC_WAVEFORMCALIB_DEBUG
+  LOG(info) << "o2::zdc::WaveformCalibEPN::" << __func__;
+#endif
+  //  mQueue.clear();
+  mData.clearWaveforms();
+  mData.setN(mN);
+}
+
 //______________________________________________________________________________
 int WaveformCalibEPN::process(const gsl::span<const o2::zdc::BCRecData>& RecBC,
                               const gsl::span<const o2::zdc::ZDCEnergy>& Energy,
@@ -111,9 +123,10 @@ int WaveformCalibEPN::endOfRun()
     LOGF(info, "WaveformCalibEPN::endOfRun ts (%llu:%llu)", mData.mCTimeBeg, mData.mCTimeEnd);
     for (int is = 0; is < NChannels; is++) {
       if (mData.getEntries(is) > 0) {
-        LOGF(info, "Waveform %2d %s with %10d events and cuts AMP:(%g:%g) TDC:(%g:%g) Valid:[%d:%d:%d]", is, ChannelNames[is].data(),
+        int itdc = SignalTDC[is];
+        LOGF(info, "Waveform %2d %s with %10d events and cuts AMP:(%g:%g) TDC:%d:(%g:%g) Valid:[%d:%d:%d]", is, ChannelNames[is].data(),
              mData.getEntries(is), mConfig->cutLow[is], mConfig->cutHigh[is],
-             mConfig->cutTimeLow[is], mConfig->cutTimeHigh[is],
+             itdc, mConfig->cutTimeLow[itdc], mConfig->cutTimeHigh[itdc],
              mData.getFirstValid(is), mData.mPeak, mData.getLastValid(is));
       }
     }

Detectors/ZDC/calib/src/WaveformCalibEPNSpec.cxx

@@ -88,10 +88,13 @@ void WaveformCalibEPNSpec::run(ProcessingContext& pc)
     mTimer.Stop();
     mTimer.Reset();
     mTimer.Start(false);
+  } else {
+    mWorker.clear();
   }
 
   auto creationTime = pc.services().get<o2::framework::TimingInfo>().creation; // approximate time in ms
   WaveformCalibData& data = mWorker.getData();
+
   data.setCreationTime(creationTime);
 
   auto bcrec = pc.inputs().get<gsl::span<o2::zdc::BCRecData>>("bcrec");

Detectors/ZDC/calib/src/WaveformCalibQueue.cxx

@@ -52,6 +52,9 @@ uint32_t WaveformCalibQueue::append(RecEventFlat& ev)
   auto& last = mIR.back();
   // If BC are not consecutive, clear queue
   if (toadd.differenceInBC(last) > 1) {
+#ifdef O2_ZDC_WAVEFORMCALIB_DEBUG
+    LOG(info) << "WaveformCalibQueue::" << __func__ << " gap detected. Clearing " << mIR.size() << " bc";
+#endif
     clear();
   }
   // If queue is not empty and is too long remove first element
@@ -61,6 +64,9 @@ uint32_t WaveformCalibQueue::append(RecEventFlat& ev)
   // If BC are consecutive or cleared queue append element
   appendEv(ev);
   if (mIR.size() == mN) {
+#ifdef O2_ZDC_WAVEFORMCALIB_DEBUG
+    LOG(info) << "WaveformCalibQueue::" << __func__ << " processing " << mIR.size() << " bcs";
+#endif
     uint32_t mask = 0;
     for (int32_t itdc = 0; itdc < NTDCChannels; itdc++) {
       // Check which channels satisfy the condition on TDC
@@ -92,6 +98,9 @@ uint32_t WaveformCalibQueue::append(RecEventFlat& ev)
     }
     return mask;
   } else {
+    // #ifdef O2_ZDC_WAVEFORMCALIB_DEBUG
+    //     LOG(info) << "WaveformCalibQueue::" << __func__ << " IR size = " << mIR.size() << " != " << mN;
+    // #endif
     return 0;
   }
 }
@@ -182,7 +191,7 @@ int WaveformCalibQueue::hasData(int isig, const gsl::span<const o2::zdc::ZDCWave
   } else {
     int ipos = NTimeBinsPerBC * TSN * ipkb + ipk;
 #ifdef O2_ZDC_WAVEFORMCALIB_DEBUG
-    LOG(info) << "WaveformCalibConfig::" << __func__ << " isig = " << isig << " ipkb " << ipkb << " ipk " << ipk << " min " << min;
+    LOG(info) << "WaveformCalibQueue::" << __func__ << " isig = " << isig << " ipkb " << ipkb << " ipk " << ipk << " min " << min;
 #endif
     return ipos;
   }
@@ -199,9 +208,9 @@ int WaveformCalibQueue::addData(int isig, const gsl::span<const o2::zdc::ZDCWave
   bool hasInfos = false;
   for (int ib = 0; ib < mN; ib++) {
     bool ifound = false;
-#ifdef O2_ZDC_WAVEFORMCALIB_DEBUG
-    LOG(info) << "mNW[" << ib << "] = " << mNW[ib] << " mFirstW = " << mFirstW[ib];
-#endif
+    // #ifdef O2_ZDC_WAVEFORMCALIB_DEBUG
+    //     LOG(info) << "mNW[" << ib << "/" << mN << "] = " << mNW[ib] << " mFirstW = " << mFirstW[ib];
+    // #endif
     if (mHasInfos[isig][ib] || mHasInfos[TDCSignal[SignalTDC[isig]]][ib]) {
 #ifdef O2_ZDC_WAVEFORMCALIB_DEBUG
       LOG(info) << "isig=" << isig << " ib=" << ib << " tdcid=" << SignalTDC[isig] << " tdc_sig=" << TDCSignal[SignalTDC[isig]] << " " << mHasInfos[isig][ib] << " " << mHasInfos[TDCSignal[SignalTDC[isig]]][ib];
@@ -237,6 +246,9 @@ int WaveformCalibQueue::addData(int isig, const gsl::span<const o2::zdc::ZDCWave
     }
   }
   if (ipkb != mPk) {
+#ifdef O2_ZDC_WAVEFORMCALIB_DEBUG
+    LOG(info) << "WaveformCalibQueue::" << __func__ << " isig = " << isig << " ipkb " << ipkb << " != mPk " << mPk << " SKIP";
+#endif
     return -1;
   } else {
     int ppos = NIS * ipkb + ipk;
@@ -249,8 +261,10 @@ int WaveformCalibQueue::addData(int isig, const gsl::span<const o2::zdc::ZDCWave
         return -1;
       }
       if ((ppos - mPeak) < mTimeLow[itdc] || (ppos - mPeak) > mTimeHigh[itdc]) {
-        // Put a warning message for a signal out of time
-        LOGF(warning, "%d.%04d Signal %2d peak position %d-%d=%d is outside allowed range [%d:%d]", mIR[mPk].orbit, mIR[mPk].bc, isig, ppos, mPeak, ppos - mPeak, mTimeLow[isig], mTimeHigh[isig]);
+        if (mVerbosity > DbgMinimal) {
+          // Put a warning message for a signal out of time
+          LOGF(warning, "%d.%04d Signal %2d peak position %d-%d=%d is outside allowed range [%d:%d]", mIR[mPk].orbit, mIR[mPk].bc, isig, ppos, mPeak, ppos - mPeak, mTimeLow[isig], mTimeHigh[isig]);
+        }
         return -1;
       }
     }
@@ -277,7 +291,7 @@ int WaveformCalibQueue::addData(int isig, const gsl::span<const o2::zdc::ZDCWave
     // Restrict validity range because of signal jitter
     data.setLastValid(isig, ipos);
 #ifdef O2_ZDC_WAVEFORMCALIB_DEBUG
-    LOG(info) << "WaveformCalibConfig::" << __func__ << " isig = " << isig << " ipkb " << ipkb << " ipk " << ipk << " min " << min << " range=[" << data.getFirstValid(isig) << ":" << ppos << ":" << data.getLastValid(isig) << "]";
+    LOG(info) << "WaveformCalibQueue::" << __func__ << " isig = " << isig << " ipkb " << ipkb << " ipk " << ipk << " min " << min << " range=[" << data.getFirstValid(isig) << ":" << ppos << ":" << data.getLastValid(isig) << "]";
 #endif
     return ipos;
   }
@@ -286,36 +300,61 @@ int WaveformCalibQueue::addData(int isig, const gsl::span<const o2::zdc::ZDCWave
 void WaveformCalibQueue::print()
 {
   int n = mIR.size();
+  printf("WaveformCalibQueue::print() %d consecutive bunches\n", n);
   for (int i = 0; i < n; i++) {
-    printf("%d.%04d mEntry=%d mFirstW=%d mNW=%d\n", mIR[i].orbit, mIR[i].bc, mEntry[i], mFirstW[i], mNW[i]);
-    printf("mHasInfos:");
+    printf("%d.%04d mEntry=%d mFirstW=%d mNW=%d waveforms\n", mIR[i].orbit, mIR[i].bc, mEntry[i], mFirstW[i], mNW[i]);
+    bool printed = false;
     for (int j = 0; j < NChannels; j++) {
       if (mHasInfos[j][i] != 0) {
+        if (!printed) {
+          printf("mHasInfos:");
+          printed = true;
+        }
         printf(" %2d=%d", j, mHasInfos[j][i] != 0);
       }
     }
-    printf("\n");
-    printf("mNTDC:");
+    if (printed) {
+      printf("\n");
+      printed = false;
+    }
     for (int j = 0; j < NTDCChannels; j++) {
       if (mNTDC[j][i] > 0) {
+        if (!printed) {
+          printf("mNTDC:");
+          printed = true;
+        }
         printf(" %2d=%6u", j, mNTDC[j][i]);
       }
     }
-    printf("\n");
-    printf("mTDCA:");
+    if (printed) {
+      printf("\n");
+      printed = false;
+    }
     for (int j = 0; j < NTDCChannels; j++) {
       if (mNTDC[j][i] > 0) {
+        if (!printed) {
+          printf("mTDCA:");
+          printed = true;
+        }
         printf(" %2d=%6.1f", j, mTDCA[j][i]);
       }
     }
-    printf("\n");
-    printf("mTDCP:");
+    if (printed) {
+      printf("\n");
+      printed = false;
+    }
     for (int j = 0; j < NTDCChannels; j++) {
       if (mNTDC[j][i] > 0) {
+        if (!printed) {
+          printf("mTDCP:");
+          printed = true;
+        }
         printf(" %2d=%6.1f", j, mTDCP[j][i]);
       }
     }
-    printf("\n");
+    if (printed) {
+      printf("\n");
+    }
   }
 }