AliceO2Group · shahor02 · Dec 15, 2022 · Dec 12, 2022 · Dec 12, 2022 · Dec 12, 2022
@@ -13,6 +13,7 @@ o2_add_library(DataFormatsFT0
  SOURCES src/ChannelData.cxx
          src/Digit.cxx
          src/DigitFilterParam.cxx
+          src/CalibParam.cxx
          src/RecPoints.cxx
          src/RawEventData.cxx
          src/CTF.cxx
@@ -28,6 +29,7 @@ o2_target_root_dictionary(DataFormatsFT0
  HEADERS include/DataFormatsFT0/ChannelData.h
          include/DataFormatsFT0/Digit.h
          include/DataFormatsFT0/DigitFilterParam.h
+          include/DataFormatsFT0/CalibParam.h
          include/DataFormatsFT0/MCLabel.h
          include/DataFormatsFT0/HitType.h
          include/DataFormatsFT0/RecPoints.h

@@ -27,18 +27,18 @@ struct CalibParam : o2::conf::ConfigurableParamHelper<CalibParam> {
  // Logic for obtaining bad channels and for making decision concerning slot finalization
  std::size_t mMinEntriesThreshold = 500;  // Min number of entries
  std::size_t mMaxEntriesThreshold = 1000; // Max number of entries
-  uint8_t mNExtraSlots = 1;                // Number of extra slots
+  uint8_t mNExtraSlots = 0;                // Number of extra slots
  // Fitting ranges
  double mMinFitRange = -200.; // Min fit range
  double mMaxFitRange = 200.;  // Max fit range
  // Conditions for checking fit quality, otherwise hist mean will be taken as offset
-  double mMaxDiffMean = 20;                 // Max differnce between mean and fit result
+  double mMaxDiffMean = 5;                  // Max differnce between mean and fit result
  double mMinRMS = 3;                       // Min RMS
-  double mMaxSigma = 30;                    // Max fit sigma
+  double mMaxSigma = 32;                    // Max fit sigma
  int mRebinFactorPerChID[Nchannels] = {0}; //[Nchannels]
  //
-  bool mUseDynamicRange = false; // use dynamic ranges [mean-RMS*mRangeInRMS,mean+RMS*mRangeInRMS] for fitting
-  double mRangeInRMS = 3;        // Range for RMS in dynamic case
+  bool mUseDynamicRange = true; // use dynamic ranges [mean-RMS*mRangeInRMS,mean+RMS*mRangeInRMS] for fitting
+  double mRangeInRMS = 1.5;     // Range for RMS in dynamic case

  O2ParamDef(CalibParam, "FT0CalibParam");
 };

@@ -33,5 +33,70 @@ struct DigitFilterParam : o2::conf::ConfigurableParamHelper<DigitFilterParam> {

  O2ParamDef(DigitFilterParam, "FT0DigitFilterParam");
 };
+
+struct ChannelFilterParam : o2::conf::ConfigurableParamHelper<ChannelFilterParam> {
+  int16_t mAmpUpper = 4200;
+  int16_t mAmpLower = -4200;
+  int16_t mTimeUpper = 2050;
+  int16_t mTimeLower = -2050;
+
+  uint8_t mPMbitsGood = (1 << ChannelData::EEventDataBit::kIsCFDinADCgate); // use only in ADC gate amplitudes, for physics
+  uint8_t mPMbitsBad = 0;                                                   // no checking for bad bits
+  uint8_t mPMbitsToCheck = mPMbitsGood | mPMbitsBad;
+
+  uint8_t mTrgBitsGood = (1 << Triggers::bitDataIsValid); // only good data
+  uint8_t mTrgBitsBad = 0;                                // Laser haven't been used in 2022, no check for bad bits
+  uint8_t mTrgBitsToCheck = mTrgBitsGood | mTrgBitsBad;
+  bool checkPMbits(uint8_t pmBits) const
+  {
+    return (pmBits & mPMbitsToCheck) == mPMbitsGood;
+  }
+  bool checkTCMbits(uint8_t tcmBits) const
+  {
+    return (tcmBits & mTrgBitsToCheck) == mTrgBitsGood;
+  }
+  bool checkTimeWindow(int16_t time) const
+  {
+    return time >= mTimeLower && time <= mTimeUpper;
+  }
+  bool checkAmpWindow(int16_t amp) const
+  {
+    return amp >= mAmpLower && amp <= mAmpUpper;
+  }
+  bool checkAll(const o2::ft0::ChannelData& channelData) const
+  {
+    return checkPMbits(channelData.ChainQTC) && checkAmpWindow(channelData.QTCAmpl) && checkTimeWindow(channelData.CFDTime);
+  }
+  O2ParamDef(ChannelFilterParam, "FT0ChannelFilterParam");
+};
+
+struct TimeFilterParam : o2::conf::ConfigurableParamHelper<TimeFilterParam> {
+  int16_t mAmpUpper = 4200;
+  int16_t mAmpLower = -4200;
+  int16_t mTimeUpper = 2050;
+  int16_t mTimeLower = -2050;
+
+  uint8_t mPMbitsGood = 0;                                                                                                          // No need in checking good PM bits
+  uint8_t mPMbitsBad = (1 << ChannelData::EEventDataBit::kIsTimeInfoNOTvalid) | (1 << ChannelData::EEventDataBit::kIsTimeInfoLost); // Check only two bad PM bits
+  uint8_t mPMbitsToCheck = mPMbitsGood | mPMbitsBad;
+  bool checkPMbits(uint8_t pmBits) const
+  {
+    return (pmBits & mPMbitsToCheck) == mPMbitsGood;
+  }
+  bool checkTimeWindow(int16_t time) const
+  {
+    return time >= mTimeLower && time <= mTimeUpper;
+  }
+  bool checkAmpWindow(int16_t amp) const
+  {
+    return amp >= mAmpLower && amp <= mAmpUpper;
+  }
+  bool checkAll(const o2::ft0::ChannelData& channelData) const
+  {
+    return checkPMbits(channelData.ChainQTC) && checkAmpWindow(channelData.QTCAmpl) && checkTimeWindow(channelData.CFDTime);
+  }
+  O2ParamDef(TimeFilterParam, "FT0TimeFilterParam");
+};
+
 } // namespace o2::ft0
 #endif
@@ -9,7 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.

-#include "FT0Calibration/CalibParam.h"
+#include "DataFormatsFT0/CalibParam.h"

 using namespace o2::ft0;
 O2ParamImpl(CalibParam);
@@ -17,6 +17,9 @@

 #pragma link C++ class o2::ft0::Digit + ;
 #pragma link C++ class o2::ft0::DigitFilterParam + ;
+#pragma link C++ class o2::ft0::ChannelFilterParam + ;
+#pragma link C++ class o2::ft0::TimeFilterParam + ;
+#pragma link C++ class o2::ft0::CalibParam + ;
 #pragma link C++ class o2::ft0::ChannelData + ;
 #pragma link C++ class o2::ft0::DetTrigInput + ;
 #pragma link C++ class o2::ft0::TriggersExt + ;

@@ -12,4 +12,6 @@
 #include "DataFormatsFT0/DigitFilterParam.h"

 using namespace o2::ft0;
-O2ParamImpl(DigitFilterParam);
+O2ParamImpl(DigitFilterParam);
+O2ParamImpl(ChannelFilterParam);
+O2ParamImpl(TimeFilterParam);
@@ -11,7 +11,6 @@

 o2_add_library(FT0Calibration
        SOURCES
-        src/CalibParam.cxx
        src/FT0TimeOffsetSlotContainer.cxx
        src/GlobalOffsetsContainer.cxx
        src/FT0CalibTimeSlewing.cxx
@@ -28,7 +27,6 @@ o2_add_library(FT0Calibration
           )
       o2_target_root_dictionary(FT0Calibration
        HEADERS
-        include/FT0Calibration/CalibParam.h
        include/FT0Calibration/FT0TimeOffsetSlotContainer.h
        include/FT0Calibration/GlobalOffsetsContainer.h
        include/FT0Calibration/FT0CalibTimeSlewing.h

@@ -18,6 +18,8 @@
 #include "CommonDataFormat/FlatHisto2D.h"
 #include "DataFormatsFT0/SpectraInfoObject.h"

+#include "TList.h"
+
 #include "Rtypes.h"
 namespace o2::ft0
 {
@@ -34,10 +36,10 @@ class FT0TimeOffsetSlotContainer final
  FT0TimeOffsetSlotContainer& operator=(FT0TimeOffsetSlotContainer&&) = default;
  bool hasEnoughEntries() const;
  void fill(const gsl::span<const float>& data);
-  SpectraInfoObject getSpectraInfoObject(std::size_t channelID) const;
+  SpectraInfoObject getSpectraInfoObject(std::size_t channelID, TList* listHists) const;
  void merge(FT0TimeOffsetSlotContainer* prev);
  void print() const;
-  TimeSpectraInfoObject generateCalibrationObject() const;
+  TimeSpectraInfoObject generateCalibrationObject(long tsStartMS, long tsEndMS, const std::string& pathToHists) const;
  typedef float FlatHistoValue_t;
  typedef o2::dataformats::FlatHisto2D<FlatHistoValue_t> FlatHisto2D_t;


@@ -38,7 +38,7 @@ class GlobalOffsetsContainer final
  int getMeanGaussianFitValue() const;
  void merge(GlobalOffsetsContainer* prev);
  void print() const;
-  GlobalOffsetsCalibrationObject generateCalibrationObject() const;
+  GlobalOffsetsCalibrationObject generateCalibrationObject(long, long, const std::string&) const;
  void updateFirstCreation(std::uint64_t creation)
  {
    if (creation < mFirstCreation) {

@@ -15,7 +15,6 @@
 #pragma link off all classes;
 #pragma link off all functions;

-#pragma link C++ class o2::ft0::CalibParam + ;
 #pragma link C++ class o2::ft0::FT0TimeOffsetSlotContainer + ;
 #pragma link C++ class o2::ft0::GlobalOffsetsContainer + ;
 #pragma link C++ class o2::ft0::FT0CalibTimeSlewing + ;

@@ -10,12 +10,13 @@
 // or submit itself to any jurisdiction.

 #include "FT0Calibration/FT0TimeOffsetSlotContainer.h"
-#include "FT0Calibration/CalibParam.h"
+#include "DataFormatsFT0/CalibParam.h"
 #include "CommonDataFormat/FlatHisto1D.h"

 #include <Framework/Logger.h>

 #include "TH1.h"
+#include "TFile.h"
 #include "TFitResult.h"

 using namespace o2::ft0;
@@ -29,16 +30,17 @@ bool FT0TimeOffsetSlotContainer::hasEnoughEntries() const
    LOG(info) << "RESULT: ready";
    print();
    return true;
-  } else if (mCurrentSlot > CalibParam::Instance().mNExtraSlots) {
-    LOG(info) << "RESULT: Extra slots are used";
+  } else if (mCurrentSlot >= CalibParam::Instance().mNExtraSlots) {
+    LOG(info) << "RESULT: Extra slots(" << CalibParam::Instance().mNExtraSlots << ") are used";
    print();
    return true;
-  } else if (mCurrentSlot == 0) {
+  } else if (mCurrentSlot < CalibParam::Instance().mNExtraSlots) {
    for (int iCh = 0; iCh < sNCHANNELS; iCh++) {
      const auto nEntries = mArrEntries[iCh];
      if (nEntries >= CalibParam::Instance().mMinEntriesThreshold && nEntries < CalibParam::Instance().mMaxEntriesThreshold) {
        // Check if there are any pending channel in first slot
        LOG(info) << "RESULT: pending channels";
+        print();
        return false;
      }
    }
@@ -47,10 +49,10 @@ bool FT0TimeOffsetSlotContainer::hasEnoughEntries() const
    print();
    return true;
  } else {
-    // Probably will never happen, all other conditions are already checked
+    // Probably will be never happen, all other conditions are already checked
    LOG(info) << "RESULT: should be never happen";
    print();
-    return false;
+    return true;
  }
 }

@@ -64,7 +66,6 @@ void FT0TimeOffsetSlotContainer::fill(const gsl::span<const float>& data)
    mIsFirstTF = false;
  }
  mHistogram.add(histView);
-  //  if (!mIsReady) {
  // This part should at the stage `hasEnoughData()` but it is const method
  for (int iCh = 0; iCh < sNCHANNELS; iCh++) {
    if (mBitsetGoodChIDs.test(iCh) || mBitsetBadChIDs.test(iCh)) {
@@ -81,13 +82,10 @@ void FT0TimeOffsetSlotContainer::fill(const gsl::span<const float>& data)
      mBitsetGoodChIDs.set(iCh);
    }
  }
-  /*
-      const auto totalNCheckedChIDs = mBitsetGoodChIDs.count() + mBitsetBadChIDs.count();
-      if (totalNCheckedChIDs == sNCHANNELS) {
-        mIsReady = true;
-      }
-  */
-  //  }
+  const auto totalNCheckedChIDs = mBitsetGoodChIDs.count() + mBitsetBadChIDs.count();
+  if (totalNCheckedChIDs == sNCHANNELS) {
+    mIsReady = true;
+  }
 }

 void FT0TimeOffsetSlotContainer::merge(FT0TimeOffsetSlotContainer* prev)
@@ -107,7 +105,7 @@ void FT0TimeOffsetSlotContainer::merge(FT0TimeOffsetSlotContainer* prev)
  mCurrentSlot++;
 }

-SpectraInfoObject FT0TimeOffsetSlotContainer::getSpectraInfoObject(std::size_t channelID) const
+SpectraInfoObject FT0TimeOffsetSlotContainer::getSpectraInfoObject(std::size_t channelID, TList* listHists) const
 {
  uint32_t statusBits{};
  double minFitRange{0};
@@ -142,22 +140,44 @@ SpectraInfoObject FT0TimeOffsetSlotContainer::getSpectraInfoObject(std::size_t c
      statusBits |= (1 << 0);
    }
    if (((int)resultFit) != 0 || std::abs(meanGaus - meanHist) > CalibParam::Instance().mMaxDiffMean || rmsHist < CalibParam::Instance().mMinRMS || sigmaGaus > CalibParam::Instance().mMaxSigma) {
+      statusBits |= (2 << 0);
      LOG(debug) << "Bad gaus fit: meanGaus " << meanGaus << " sigmaGaus " << sigmaGaus << " meanHist " << meanHist << " rmsHist " << rmsHist << "resultFit " << ((int)resultFit);
    }
  }
+  if (listHists != nullptr) {
+    auto histPtr = hist.release();
+    const std::string histName = "histCh" + std::to_string(channelID);
+    histPtr->SetName(histName.c_str());
+    listHists->Add(histPtr);
+  }
  return SpectraInfoObject{meanGaus, sigmaGaus, constantGaus, fitChi2, meanHist, rmsHist, stat, statusBits};
 }

-TimeSpectraInfoObject FT0TimeOffsetSlotContainer::generateCalibrationObject() const
+TimeSpectraInfoObject FT0TimeOffsetSlotContainer::generateCalibrationObject(long tsStartMS, long tsEndMS, const std::string& extraInfo) const
 {
+  TList* listHists = nullptr;
+  bool storeHists{false};
+  if (extraInfo.size() > 0) {
+    storeHists = true;
+    listHists = new TList();
+    listHists->SetOwner(true);
+    listHists->SetName("output");
+  }
  TimeSpectraInfoObject calibrationObject;
  for (unsigned int iCh = 0; iCh < sNCHANNELS; ++iCh) {
-    calibrationObject.mTime[iCh] = getSpectraInfoObject(iCh);
+    calibrationObject.mTime[iCh] = getSpectraInfoObject(iCh, listHists);
+  }
+  calibrationObject.mTimeA = getSpectraInfoObject(sNCHANNELS, listHists);
+  calibrationObject.mTimeC = getSpectraInfoObject(sNCHANNELS + 1, listHists);
+  calibrationObject.mSumTimeAC = getSpectraInfoObject(sNCHANNELS + 2, listHists);
+  calibrationObject.mDiffTimeCA = getSpectraInfoObject(sNCHANNELS + 3, listHists);
+  if (storeHists) {
+    const std::string filename = extraInfo + "/histsTimeSpectra" + std::to_string(tsStartMS) + "_" + std::to_string(tsEndMS) + ".root";
+    TFile fileHists(filename.c_str(), "RECREATE");
+    fileHists.WriteObject(listHists, listHists->GetName(), "SingleKey");
+    fileHists.Close();
+    delete listHists;
  }
-  calibrationObject.mTimeA = getSpectraInfoObject(sNCHANNELS);
-  calibrationObject.mTimeC = getSpectraInfoObject(sNCHANNELS + 1);
-  calibrationObject.mSumTimeAC = getSpectraInfoObject(sNCHANNELS + 2);
-  calibrationObject.mDiffTimeCA = getSpectraInfoObject(sNCHANNELS + 3);
  return calibrationObject;
 }


@@ -75,7 +75,7 @@ int GlobalOffsetsContainer::getMeanGaussianFitValue() const
    return 0;
  }
 }
-GlobalOffsetsCalibrationObject GlobalOffsetsContainer::generateCalibrationObject() const
+GlobalOffsetsCalibrationObject GlobalOffsetsContainer::generateCalibrationObject(long, long, const std::string&) const
 {
  GlobalOffsetsCalibrationObject calibrationObject;
  calibrationObject.mCollisionTimeOffsets = getMeanGaussianFitValue();

@@ -15,7 +15,6 @@
 #include "DataFormatsFT0/SpectraInfoObject.h"
 #include "FITCalibration/FITCalibrationDevice.h"
 #include "FT0Calibration/FT0TimeOffsetSlotContainer.h"
-#include "FT0Calibration/CalibParam.h"

 using namespace o2::framework;

@@ -53,10 +52,11 @@ WorkflowSpec defineDataProcessing(ConfigContext const& config)
    "ft0-time-offset-calib",
    inputs,
    outputs,
-    o2::framework::AlgorithmSpec{o2::framework::adaptFromTask<CalibrationDeviceType>(ccdbRequest)},
+    o2::framework::AlgorithmSpec{o2::framework::adaptFromTask<CalibrationDeviceType>(ccdbRequest, outputDataDescriptor)},
    o2::framework::Options{
      {"tf-per-slot", o2::framework::VariantType::UInt32, 56000u, {""}},
-      {"max-delay", o2::framework::VariantType::UInt32, 3u, {""}}}};
+      {"max-delay", o2::framework::VariantType::UInt32, 3u, {""}},
+      {"extra-info-per-slot", o2::framework::VariantType::String, "", {"Extra info for time slot(usually for debugging)"}}}};

  WorkflowSpec workflow;
  workflow.emplace_back(dataProcessorSpec);

@@ -46,11 +46,12 @@ o2::framework::DataProcessorSpec getGlobalOffsetsCalibrationSpec()
    "ft0-global-offsets",
    inputs, // o2::framework::Inputs{{"input", "FT0", "CALIBDATA"}},
    outputs,
-    o2::framework::AlgorithmSpec{o2::framework::adaptFromTask<CalibrationDeviceType>(ccdbRequest)},
+    o2::framework::AlgorithmSpec{o2::framework::adaptFromTask<CalibrationDeviceType>(ccdbRequest, outputDataDescriptor)},
    Options{
      {"tf-per-slot", VariantType::UInt32, 55000u, {"number of TFs per calibration time slot"}},
      {"max-delay", VariantType::UInt32, 3u, {"number of slots in past to consider"}},
-      {"min-entries", VariantType::Int, 500, {"minimum number of entries to fit single time slot"}}}};
+      {"min-entries", VariantType::Int, 500, {"minimum number of entries to fit single time slot"}},
+      {"extra-info-per-slot", o2::framework::VariantType::String, "", {"Extra info for time slot(usually for debugging)"}}}};
 }

 } // namespace o2::ft0