Developments for pedestal calibration in DPL + misc

DataFormats/Detectors/TPC/include/DataFormatsTPC/ZeroSuppressionLinkBased.h

@@ -10,7 +10,7 @@
 
 /// \file ZeroSuppressionLinkBased.h
 /// \brief definitions to deal with the link based zero suppression format
-/// \author Jens Wiechula
+/// @author Jens Wiechula, Jens.Wiechula@ikf.uni-frankfurt.de
 
 #ifndef ALICEO2_DATAFORMATSTPC_ZeroSuppressionLinkBased_H
 #define ALICEO2_DATAFORMATSTPC_ZeroSuppressionLinkBased_H
@@ -29,7 +29,7 @@ static constexpr uint32_t DataWordSizeBytes = DataWordSizeBits / 8; ///< size of
 
 /// header definition of the zero suppressed link based data format
 struct Header {
-  static constexpr uint32_t MagicWord = 0xFC000000;
+  static constexpr uint32_t MagicWord = 0xFC;
 
   union {
     uint64_t word0 = 0;             ///< lower 64 bits
@@ -44,7 +44,8 @@ struct Header {
       uint64_t bitMaskHigh : 16;    ///< higher bits of the 80 bit bitmask
       uint32_t bunchCrossing : 12;  ///< bunch crossing number
       uint32_t numWordsPayload : 4; ///< number of 128bit words with 12bit ADC values
-      uint32_t magicWord : 32;      ///< not used
+      uint32_t timeBin : 24;        ///< time bin number issues by UL, mainly for debugging, since it might wrap
+      uint32_t magicWord : 8;       ///< not used
     };
   };
 

Detectors/TPC/base/include/TPCBase/Painter.h

@@ -49,7 +49,7 @@ namespace painter
 /// \param CalDet object to draw
 /// \return TCanvas containing CalDet content
 template <class T>
-TCanvas* draw(const CalDet<T>& calDet, int nbins1D = 300, float xMin1D = 0, float xMax1D = 0);
+TCanvas* draw(const CalDet<T>& calDet, int nbins1D = 300, float xMin1D = 0, float xMax1D = 0, TCanvas* outputCanvas = nullptr);
 
 /// Drawing of a CalDet object
 /// \param CalArray object to draw
@@ -93,9 +93,10 @@ TH2* getHistogram2D(const CalArray<T>& calArray);
 /// \param nbins1D number of bins used for the 1D projections
 /// \param xMin1D minimum value for 1D distribution (xMin = 0 and xMax = 0 for auto scaling)
 /// \param xMax1D maximum value for 1D distribution (xMin = 0 and xMax = 0 for auto scaling)
+/// \param outputCanvases if outputCanvases are given, use them instead of creating new ones, 3 are required
 /// \return TCanvas containing CalDet content
 template <class T>
-std::vector<TCanvas*> makeSummaryCanvases(const CalDet<T>& calDet, int nbins1D = 300, float xMin1D = 0, float xMax1D = 0, bool onlyFilled = true);
+std::vector<TCanvas*> makeSummaryCanvases(const CalDet<T>& calDet, int nbins1D = 300, float xMin1D = 0, float xMax1D = 0, bool onlyFilled = true, std::vector<TCanvas*>* outputCanvases = nullptr);
 
 /// Create summary canvases for a CalDet object
 ///

Detectors/TPC/base/src/Painter.cxx

@@ -29,7 +29,7 @@
 using namespace o2::tpc;
 
 template <class T>
-TCanvas* painter::draw(const CalDet<T>& calDet, int nbins1D, float xMin1D, float xMax1D)
+TCanvas* painter::draw(const CalDet<T>& calDet, int nbins1D, float xMin1D, float xMax1D, TCanvas* outputCanvas)
 {
   using DetType = CalDet<T>;
   using CalType = CalArray<T>;
@@ -93,7 +93,11 @@ TCanvas* painter::draw(const CalDet<T>& calDet, int nbins1D, float xMin1D, float
   }
 
   // ===| Draw histograms |=====================================================
-  auto c = new TCanvas(Form("c_%s", name.c_str()), title, 1000, 1000);
+  auto c = outputCanvas;
+  if (!c) {
+    c = new TCanvas(Form("c_%s", name.c_str()), title, 1000, 1000);
+  }
+  c->Clear();
   c->Divide(2, 2);
 
   c->cd(1);
@@ -235,7 +239,7 @@ std::enable_if_t<std::is_unsigned<T>::value, bool> hasData(const CalArray<T>& ca
 }
 
 template <class T>
-std::vector<TCanvas*> painter::makeSummaryCanvases(const CalDet<T>& calDet, int nbins1D, float xMin1D, float xMax1D, bool onlyFilled)
+std::vector<TCanvas*> painter::makeSummaryCanvases(const CalDet<T>& calDet, int nbins1D, float xMin1D, float xMax1D, bool onlyFilled, std::vector<TCanvas*>* outputCanvases)
 {
 
   std::vector<TCanvas*> vecCanvases;
@@ -258,14 +262,33 @@ std::vector<TCanvas*> painter::makeSummaryCanvases(const CalDet<T>& calDet, int
   }
 
   // ===| set up canvases |===
+  TCanvas* cSides = nullptr;
+  TCanvas* cROCs1D = nullptr;
+  TCanvas* cROCs2D = nullptr;
   const std::string_view calName = calDet.getName();
-  auto cSides = draw(calDet, nbins1D, xMin1D, xMax1D);
-  auto cROCs1D = new TCanvas(fmt::format("c_ROCs_{}_1D", calName).data(), fmt::format("{} values for each ROC", calName).data(), 1400, 1000);
-  auto cROCs2D = new TCanvas(fmt::format("c_ROCs_{}_2D", calName).data(), fmt::format("{} values for each ROC", calName).data(), 1400, 1000);
+
+  if (outputCanvases) {
+    if (!(outputCanvases->size() < 3)) {
+      LOGP(error, "At least 3 canvases are needed to fill the output, only {} given", outputCanvases->size());
+      return vecCanvases;
+    }
+
+    cSides = outputCanvases->at(0);
+    cROCs1D = outputCanvases->at(1);
+    cROCs2D = outputCanvases->at(2);
+    cSides->Clear();
+    cROCs1D->Clear();
+    cROCs2D->Clear();
+  } else {
+
+    cROCs1D = new TCanvas(fmt::format("c_ROCs_{}_1D", calName).data(), fmt::format("{} values for each ROC", calName).data(), 1400, 1000);
+    cROCs2D = new TCanvas(fmt::format("c_ROCs_{}_2D", calName).data(), fmt::format("{} values for each ROC", calName).data(), 1400, 1000);
+  }
   vecCanvases.emplace_back(cSides);
   vecCanvases.emplace_back(cROCs1D);
   vecCanvases.emplace_back(cROCs2D);
 
+  cSides = draw(calDet, nbins1D, xMin1D, xMax1D, cSides);
   cROCs1D->DivideSquare(nROCs);
   cROCs2D->DivideSquare(nROCs);
 
@@ -327,34 +350,34 @@ std::vector<TCanvas*> painter::makeSummaryCanvases(const std::string_view fileNa
 // ===| explicit instantiations |===============================================
 // this is required to force the compiler to create instances with the types
 // we usually would like to deal with
-template TCanvas* painter::draw<float>(const CalDet<float>& calDet, int, float, float);
-template std::vector<TCanvas*> painter::makeSummaryCanvases<float>(const CalDet<float>& calDet, int, float, float, bool);
+template TCanvas* painter::draw<float>(const CalDet<float>& calDet, int, float, float, TCanvas*);
+template std::vector<TCanvas*> painter::makeSummaryCanvases<float>(const CalDet<float>& calDet, int, float, float, bool, std::vector<TCanvas*>*);
 template TCanvas* painter::draw<float>(const CalArray<float>& calArray);
 template void painter::fillHistogram2D<float>(TH2& h2D, const CalDet<float>& calDet, Side side);
 template void painter::fillHistogram2D<float>(TH2& h2D, const CalArray<float>& calArray);
 template TH2* painter::getHistogram2D<float>(const CalDet<float>& calDet, Side side);
 template TH2* painter::getHistogram2D<float>(const CalArray<float>& calArray);
 
-template TCanvas* painter::draw<double>(const CalDet<double>& calDet, int, float, float);
-template std::vector<TCanvas*> painter::makeSummaryCanvases<double>(const CalDet<double>& calDet, int, float, float, bool);
+template TCanvas* painter::draw<double>(const CalDet<double>& calDet, int, float, float, TCanvas*);
+template std::vector<TCanvas*> painter::makeSummaryCanvases<double>(const CalDet<double>& calDet, int, float, float, bool, std::vector<TCanvas*>*);
 template TCanvas* painter::draw<double>(const CalArray<double>& calArray);
 template TH2* painter::getHistogram2D<double>(const CalDet<double>& calDet, Side side);
 template TH2* painter::getHistogram2D<double>(const CalArray<double>& calArray);
 
-template TCanvas* painter::draw<int>(const CalDet<int>& calDet, int, float, float);
-template std::vector<TCanvas*> painter::makeSummaryCanvases<int>(const CalDet<int>& calDet, int, float, float, bool);
+template TCanvas* painter::draw<int>(const CalDet<int>& calDet, int, float, float, TCanvas*);
+template std::vector<TCanvas*> painter::makeSummaryCanvases<int>(const CalDet<int>& calDet, int, float, float, bool, std::vector<TCanvas*>*);
 template TCanvas* painter::draw<int>(const CalArray<int>& calArray);
 template TH2* painter::getHistogram2D<int>(const CalDet<int>& calDet, Side side);
 template TH2* painter::getHistogram2D<int>(const CalArray<int>& calArray);
 
-template TCanvas* painter::draw<short>(const CalDet<short>& calDet, int, float, float);
-template std::vector<TCanvas*> painter::makeSummaryCanvases<short>(const CalDet<short>& calDet, int, float, float, bool);
+template TCanvas* painter::draw<short>(const CalDet<short>& calDet, int, float, float, TCanvas*);
+template std::vector<TCanvas*> painter::makeSummaryCanvases<short>(const CalDet<short>& calDet, int, float, float, bool, std::vector<TCanvas*>*);
 template TCanvas* painter::draw<short>(const CalArray<short>& calArray);
 template TH2* painter::getHistogram2D<short>(const CalDet<short>& calDet, Side side);
 template TH2* painter::getHistogram2D<short>(const CalArray<short>& calArray);
 
-template TCanvas* painter::draw<bool>(const CalDet<bool>& calDet, int, float, float);
-template std::vector<TCanvas*> painter::makeSummaryCanvases<bool>(const CalDet<bool>& calDet, int, float, float, bool);
+template TCanvas* painter::draw<bool>(const CalDet<bool>& calDet, int, float, float, TCanvas*);
+template std::vector<TCanvas*> painter::makeSummaryCanvases<bool>(const CalDet<bool>& calDet, int, float, float, bool, std::vector<TCanvas*>*);
 template TCanvas* painter::draw<bool>(const CalArray<bool>& calArray);
 template TH2* painter::getHistogram2D<bool>(const CalDet<bool>& calDet, Side side);
 template TH2* painter::getHistogram2D<bool>(const CalArray<bool>& calArray);

Detectors/TPC/base/src/TPCBaseLinkDef.h

@@ -27,6 +27,7 @@
 #pragma link C++ class o2::tpc::CalDet < short> + ;
 #pragma link C++ class o2::tpc::CalDet < bool> + ;
 #pragma link C++ class std::vector < o2::tpc::CalDet < float>> + ;
+#pragma link C++ class std::vector < o2::tpc::CalDet < float>*> + ;
 #pragma link C++ class std::unordered_map < std::string, o2::tpc::CalDet < float>> + ;
 #pragma link C++ class o2::tpc::CDBInterface;
 #pragma link C++ class o2::tpc::ContainerFactory;

Detectors/TPC/calibration/include/TPCCalibration/CalibPedestal.h

@@ -105,6 +105,9 @@ class CalibPedestal : public CalibRawBase
   /// \return noise calibration object
   const CalPad& getNoise() const { return mNoise; }
 
+  /// return all pad clibrations as vector
+  const std::vector<const o2::tpc::CalDet<float>*> getCalDets() const { return std::vector<const o2::tpc::CalDet<float>*>{&mPedestal, &mNoise}; }
+
   /// Get the statistics type
   StatisticsType getStatisticsType() const { return mStatisticsType; }
 

Detectors/TPC/calibration/include/TPCCalibration/CalibPedestalParam.h

@@ -26,11 +26,11 @@ namespace tpc
 {
 
 struct CalibPedestalParam : public o2::conf::ConfigurableParamHelper<CalibPedestalParam> {
-  int FirstTimeBin{0};                              ///< first time bin used in analysis
-  int LastTimeBin{500};                             ///< first time bin used in analysis
-  int ADCMin{0};                                    ///< minimum adc value
-  int ADCMax{120};                                  ///< maximum adc value
-  StatisticsType StatType{StatisticsType::GausFit}; ///< statistics type to be used for pedestal and noise evaluation
+  int FirstTimeBin{0};                                  ///< first time bin used in analysis
+  int LastTimeBin{500};                                 ///< first time bin used in analysis
+  int ADCMin{0};                                        ///< minimum adc value
+  int ADCMax{120};                                      ///< maximum adc value
+  StatisticsType StatType{StatisticsType::GausFitFast}; ///< statistics type to be used for pedestal and noise evaluation
 
   O2ParamDef(CalibPedestalParam, "TPCCalibPedestal");
 };

Detectors/TPC/calibration/include/TPCCalibration/CalibRawBase.h

@@ -130,7 +130,7 @@ class CalibRawBase
   size_t getPresentEventNumber() const { return mPresentEventNumber; }
 
   /// return number of events
-  int getNumberOfEvents() const { return mRawReaderCRUManager.getNumberOfEvents(); }
+  int getNumberOfEvents() const;
 
   /// check if present event is complete
   bool isPresentEventComplete() const { return mRawReaderCRUManager.isEventComplete(mPresentEventNumber); }
@@ -189,6 +189,21 @@ class CalibRawBase
 //----------------------------------------------------------------
 // Inline Functions
 //----------------------------------------------------------------
+inline int CalibRawBase::getNumberOfEvents() const
+{
+  if (mGBTFrameContainers.size()) {
+    return 0; // to be checked
+  } else if (mRawReaders.size()) {
+    return 0; // to be checked
+  } else if (mRawReaderCRUManager.getNumberOfReaders()) {
+    return mRawReaderCRUManager.getNumberOfEvents();
+  } else if (mDigitTree) {
+    return mDigitTree->GetEntries();
+  } else {
+    return 0;
+  }
+}
+
 inline CalibRawBase::ProcessStatus CalibRawBase::processEvent(int eventNumber)
 {
   if (mGBTFrameContainers.size()) {

Detectors/TPC/calibration/macro/drawPulser.C

@@ -138,7 +138,7 @@ TObjArray* drawPulser(TString pulserFile, int mode = 0, std::string_view outDir
     const auto medianWidth = TMath::Median(rocWidth.getData().size(), rocWidth.getData().data());
     const auto medianQtot = TMath::Median(rocQtot.getData().size(), rocQtot.getData().data());
 
-    const float rangeT0 = 0.5;
+    const float rangeT0 = 1.5;
     const float minT0 = medianT0 - rangeT0;
     const float maxT0 = medianT0 + rangeT0;
 

Detectors/TPC/calibration/macro/runPedestal.sh

@@ -40,7 +40,7 @@ outputFile=pedestals.root
 nevents=1000
 firstTimeBin=0
 lastTimeBin=450
-statisticsType=0
+statisticsType=1
 verbosity=0
 debugLevel=0
 writeDebug=0

Detectors/TPC/calibration/macro/runPulser.C

@@ -69,7 +69,7 @@ void runPulser(std::vector<std::string_view> fileInfos, TString outputFileName =
       if (status == CalibRawBase::ProcessStatus::IncompleteEvent) {
         continue;
       } else if (status != CalibRawBase::ProcessStatus::Ok) {
-        break;
+        //break;
       }
     }
   }

Detectors/TPC/reconstruction/include/TPCReconstruction/RawReaderCRU.h

@@ -498,6 +498,8 @@ class RawReaderCRU
 {
  public:
   class PacketDescriptor;
+  using PacketDescriptorMap = std::vector<PacketDescriptor>;
+  using PacketDescriptorMapArray = std::array<PacketDescriptorMap, MaxNumberOfLinks>;
 
   /// constructor
   /// \param
@@ -645,6 +647,9 @@ class RawReaderCRU
   /// output file prefix
   const std::string& getOutputFilePrefix() const { return mOutputFilePrefix; }
 
+  /// get packet descriptor map array
+  const PacketDescriptorMapArray& getPacketDescriptorMaps() const { return mPacketDescriptorMaps; }
+
   //===========================================================================
   //===| Nested helper classes |===============================================
   //
@@ -723,26 +728,25 @@ class RawReaderCRU
   //
 
  private:
-  using PacketDescriptorMap = std::vector<PacketDescriptor>;
-  uint32_t mDebugLevel;                                                    ///< debug level
-  uint32_t mVerbosity;                                                     ///< verbosity
-  uint32_t mNumTimeBins;                                                   ///< number of time bins to process
-  uint32_t mLink;                                                          ///< present link being processed
-  uint32_t mStream;                                                        ///< present stream being processed
-  uint32_t mEventNumber = 0;                                               ///< current event number to process
-  uint32_t mReaderNumber = 0;                                              ///< raw reader number in manager
-  CRU mCRU;                                                                ///< CRU
-  size_t mFileSize;                                                        ///< size of the input file
-  bool mDumpTextFiles = false;                                             ///< dump debugging text files
-  bool mFillADCdataMap = true;                                             ///< fill the ADC data map
-  bool mForceCRU = false;                                                  ///< force CRU: overwrite value from RDH
-  bool mFileIsScanned = false;                                             ///< if file was already scanned
-  std::array<uint32_t, MaxNumberOfLinks> mPacketsPerLink;                  ///< array to keep track of the number of packets per link
-  std::bitset<MaxNumberOfLinks> mLinkPresent;                              ///< info if link is present in data; information retrieved from scanning the RDH headers
-  std::array<PacketDescriptorMap, MaxNumberOfLinks> mPacketDescriptorMaps; ///< array to hold vectors thhe packet descriptors
-  std::string mInputFileName;                                              ///< input file name
-  std::string mOutputFilePrefix;                                           ///< input file name
-  std::array<SyncArray, MaxNumberOfLinks> mSyncPositions{};                ///< sync positions for each link
+  uint32_t mDebugLevel;                                     ///< debug level
+  uint32_t mVerbosity;                                      ///< verbosity
+  uint32_t mNumTimeBins;                                    ///< number of time bins to process
+  uint32_t mLink;                                           ///< present link being processed
+  uint32_t mStream;                                         ///< present stream being processed
+  uint32_t mEventNumber = 0;                                ///< current event number to process
+  uint32_t mReaderNumber = 0;                               ///< raw reader number in manager
+  CRU mCRU;                                                 ///< CRU
+  size_t mFileSize;                                         ///< size of the input file
+  bool mDumpTextFiles = false;                              ///< dump debugging text files
+  bool mFillADCdataMap = true;                              ///< fill the ADC data map
+  bool mForceCRU = false;                                   ///< force CRU: overwrite value from RDH
+  bool mFileIsScanned = false;                              ///< if file was already scanned
+  std::array<uint32_t, MaxNumberOfLinks> mPacketsPerLink;   ///< array to keep track of the number of packets per link
+  std::bitset<MaxNumberOfLinks> mLinkPresent;               ///< info if link is present in data; information retrieved from scanning the RDH headers
+  PacketDescriptorMapArray mPacketDescriptorMaps;           ///< array to hold vectors thhe packet descriptors
+  std::string mInputFileName;                               ///< input file name
+  std::string mOutputFilePrefix;                            ///< input file name
+  std::array<SyncArray, MaxNumberOfLinks> mSyncPositions{}; ///< sync positions for each link
   // not so nice but simplest way to store the ADC data
   std::map<PadPos, std::vector<uint16_t>> mADCdata; ///< decoded ADC data
   RawReaderCRUManager* mManager{nullptr};           ///< event synchronization information
@@ -952,6 +956,9 @@ class RawReaderCRUManager
     }
   }
 
+  /// get the event sync
+  const RawReaderCRUEventSync& getEventSync() const { return mEventSync; }
+
   /// get number of all events
   size_t getNumberOfEvents() const { return mEventSync.getNumberOfEvents(); }