From 05fee66a90c5ffd478282fe39cda6fb5229203ab Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Thu, 5 May 2022 16:15:25 +0200 Subject: [PATCH 01/40] Optional transfer of interpolated waveform for TDC channels --- DataFormats/Detectors/ZDC/CMakeLists.txt | 4 +- .../ZDC/include/DataFormatsZDC/BCRecData.h | 36 ++++++- .../ZDC/include/DataFormatsZDC/RecEvent.h | 27 ++++- .../ZDC/include/DataFormatsZDC/RecEventAux.h | 6 +- DataFormats/Detectors/ZDC/src/BCRecData.cxx | 5 +- .../Detectors/ZDC/src/DataFormatsZDCLinkDef.h | 2 + .../include/ZDCReconstruction/DigiReco.h | 13 ++- .../include/ZDCReconstruction/RecoConfigZDC.h | 9 +- .../include/ZDCReconstruction/RecoParamZDC.h | 10 +- Detectors/ZDC/reconstruction/src/DigiReco.cxx | 61 +++++++---- .../ZDC/reconstruction/src/RecoConfigZDC.cxx | 5 + .../ZDC/reconstruction/src/RecoParamZDC.cxx | 100 ++++++++++++++++++ Detectors/ZDC/workflow/src/DigitRecoSpec.cxx | 21 +++- .../ZDC/workflow/src/ZDCRecoWriterDPLSpec.cxx | 6 +- 14 files changed, 256 insertions(+), 49 deletions(-) diff --git a/DataFormats/Detectors/ZDC/CMakeLists.txt b/DataFormats/Detectors/ZDC/CMakeLists.txt index deda5de9cd739..f03f491708646 100644 --- a/DataFormats/Detectors/ZDC/CMakeLists.txt +++ b/DataFormats/Detectors/ZDC/CMakeLists.txt @@ -11,7 +11,7 @@ o2_add_library(DataFormatsZDC SOURCES src/ChannelData.cxx src/BCData.cxx src/BCRecData.cxx src/RecEvent.cxx src/RecEventAux.cxx src/RawEventData.cxx - src/OrbitRawData.cxx src/OrbitRecData.cxx src/OrbitData.cxx src/ZDCTDCData.cxx src/ZDCEnergy.cxx + src/OrbitRawData.cxx src/OrbitRecData.cxx src/OrbitData.cxx src/ZDCTDCData.cxx src/ZDCEnergy.cxx src/ZDCWaveform.cxx src/CTF.cxx src/RecEventFlat.cxx src/InterCalibData.cxx PUBLIC_LINK_LIBRARIES O2::CommonConstants O2::CommonDataFormat O2::DetectorsCalibration O2::ZDCBase ROOT::MathCore FairRoot::Base @@ -24,6 +24,6 @@ o2_target_root_dictionary(DataFormatsZDC include/DataFormatsZDC/OrbitData.h include/DataFormatsZDC/CTF.h include/DataFormatsZDC/RecEvent.h include/DataFormatsZDC/RecEventAux.h include/DataFormatsZDC/RecEventFlat.h include/DataFormatsZDC/OrbitRawData.h include/DataFormatsZDC/ZDCTDCData.h - include/DataFormatsZDC/BCRecData.h include/DataFormatsZDC/ZDCEnergy.h + include/DataFormatsZDC/BCRecData.h include/DataFormatsZDC/ZDCEnergy.h include/DataFormatsZDC/ZDCWaveform.h include/DataFormatsZDC/OrbitRecData.h include/DataFormatsZDC/RawEventData.h include/DataFormatsZDC/InterCalibData.h) diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/BCRecData.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/BCRecData.h index c7c8f2f23dd4e..d06b1e7fb3b1c 100644 --- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/BCRecData.h +++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/BCRecData.h @@ -35,6 +35,7 @@ struct BCRecData { o2::dataformats::RangeRefComp<5> refe; // Reference to reconstructed energy o2::dataformats::RangeRefComp<5> reft; // Reference to reconstructed TDC o2::dataformats::RangeRefComp<5> refi; // Reference to reconstruction error/information flags + o2::dataformats::RangeRefComp<5> refw; // Reference to waveform interpolated data BCRecData() = default; @@ -47,6 +48,21 @@ struct BCRecData { reft.setEntries(0); refi.setFirstEntry(firsti); refi.setEntries(0); + refw.setFirstEntry(0); + refw.setEntries(0); + ir = iRec; + } + + BCRecData(int firste, int firstt, int firsti, int firstd, o2::InteractionRecord iRec) + { + refe.setFirstEntry(firste); + refe.setEntries(0); + reft.setFirstEntry(firstt); + reft.setEntries(0); + refi.setFirstEntry(firsti); + refi.setEntries(0); + refw.setFirstEntry(firstd); + refw.setEntries(0); ir = iRec; } @@ -68,6 +84,12 @@ struct BCRecData { refi.setEntries(refi.getEntries() + 1); } + // Update counter of Waveform entries + inline void addWaveform() + { + refw.setEntries(refw.getEntries() + 1); + } + // Get information about event inline void getRef(int& firste, int& ne, int& firstt, int& nt, int& firsti, int& ni) { @@ -79,9 +101,21 @@ struct BCRecData { ni = refi.getEntries(); } + inline void getRef(int& firste, int& ne, int& firstt, int& nt, int& firsti, int& ni, int& firstw, int& nw) + { + firste = refe.getFirstEntry(); + firstt = reft.getFirstEntry(); + firsti = refi.getFirstEntry(); + firstw = refw.getFirstEntry(); + ne = refe.getEntries(); + nt = reft.getEntries(); + ni = refi.getEntries(); + nw = refw.getEntries(); + } + void print() const; - ClassDefNV(BCRecData, 1); + ClassDefNV(BCRecData, 2); }; } // namespace zdc } // namespace o2 diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEvent.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEvent.h index ed6151f3be40a..07cb710815c5c 100644 --- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEvent.h +++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEvent.h @@ -17,6 +17,7 @@ #include "DataFormatsZDC/BCRecData.h" #include "DataFormatsZDC/ZDCEnergy.h" #include "DataFormatsZDC/ZDCTDCData.h" +#include "DataFormatsZDC/ZDCWaveform.h" #include "DataFormatsZDC/RecEventAux.h" #include "ZDCBase/Constants.h" #include "MathUtils/Cartesian.h" @@ -34,10 +35,12 @@ namespace o2 namespace zdc { struct RecEvent { - std::vector mRecBC; /// Interaction record and references to data - std::vector mEnergy; /// ZDC energy - std::vector mTDCData; /// ZDC TDC - std::vector mInfo; /// Event quality information + std::vector mRecBC; /// Interaction record and references to data + std::vector mEnergy; /// ZDC energy + std::vector mTDCData; /// ZDC TDC + std::vector mInfo; /// Event quality information + std::vector mWaveform; /// ZDC waveform + // Add new bunch crossing inline void addBC(const RecEventAux& reca) { @@ -48,6 +51,7 @@ struct RecEvent { mRecBC.back().channels = reca.channels; mRecBC.back().triggers = reca.triggers; } + // Add energy inline void addEnergy(uint8_t ch, float energy) { @@ -57,6 +61,7 @@ struct RecEvent { mEnergy.emplace_back(ch, energy); mRecBC.back().addEnergy(); } + // Add TDC - int16_t inline void addTDC(uint8_t ch, int16_t val, int16_t amp, bool isbeg = false, bool isend = false) { @@ -66,6 +71,7 @@ struct RecEvent { mTDCData.emplace_back(ch, val, amp, isbeg, isend); mRecBC.back().addTDC(); } + // Add TDC - float inline void addTDC(uint8_t ch, float val, float amp, bool isbeg = false, bool isend = false) { @@ -75,6 +81,7 @@ struct RecEvent { mTDCData.emplace_back(ch, val, amp, isbeg, isend); mRecBC.back().addTDC(); } + // Add event information inline void addInfo(uint16_t info) { @@ -102,9 +109,19 @@ struct RecEvent { uint32_t addInfo(const RecEventAux& reca, const std::array& vec, const uint16_t code); uint32_t addInfos(const RecEventAux& reca); + // Add waveform + inline void addWaveform(uint8_t ch, float* wave) + { +#ifdef O2_ZDC_DEBUG + printf("ch:%-2u [%s] Waveform\n", ch, ChannelNames[ch].data()); +#endif + mWaveform.emplace_back(ch, wave); + mRecBC.back().addWaveform(); + } + void print() const; // TODO: remove persitency of this object (here for debugging) - ClassDefNV(RecEvent, 1); + ClassDefNV(RecEvent, 2); }; } // namespace zdc diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventAux.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventAux.h index 9fc0c0fb73ea7..42fb8fef88a95 100644 --- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventAux.h +++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventAux.h @@ -31,7 +31,7 @@ namespace zdc { struct RecEventAux : public RecEventFlat { - uint32_t flags; /// reconstruction flags + uint32_t flags; /// Pattern of available data #ifdef O2_ZDC_TDC_C_ARRAY int16_t tdcVal[NTDCChannels][MaxTDCValues]; /// TdcValues (encoded) int16_t tdcAmp[NTDCChannels][MaxTDCValues]; /// TdcAmplitudes (encoded) @@ -43,9 +43,7 @@ struct RecEventAux : public RecEventFlat { uint32_t ref[NChannels]; /// Cache of references std::array err; /// Generic error condition std::array data[NChannels] = {0}; /// Samples (raw or filtered) -#ifdef O2_ZDC_INTERP_DEBUG - float inter[NTDCChannels][NTimeBinsPerBC * TSN] = {0}; /// Interpolated samples -#endif + float inter[NTDCChannels][NTimeBinsPerBC * TSN] = {0}; /// Interpolated samples // Functions RecEventAux() { diff --git a/DataFormats/Detectors/ZDC/src/BCRecData.cxx b/DataFormats/Detectors/ZDC/src/BCRecData.cxx index 7810644f022df..929269dc3070e 100644 --- a/DataFormats/Detectors/ZDC/src/BCRecData.cxx +++ b/DataFormats/Detectors/ZDC/src/BCRecData.cxx @@ -17,8 +17,9 @@ using namespace o2::zdc; void BCRecData::print() const { - printf("Orbit %9u bc %4u nch %2d pos %d ntdc %2d pos %d nmsg %2d pos %d\n", ir.orbit, ir.bc, + printf("Orbit %9u bc %4u nch=%2d pos %d ntdc=%2d pos %d nmsg=%2d pos %d nwav=%d pos %d\n", ir.orbit, ir.bc, refe.getEntries(), refe.getFirstEntry(), reft.getEntries(), reft.getFirstEntry(), - refi.getEntries(), refi.getFirstEntry()); + refi.getEntries(), refi.getFirstEntry(), + refw.getEntries(), refw.getFirstEntry()); } diff --git a/DataFormats/Detectors/ZDC/src/DataFormatsZDCLinkDef.h b/DataFormats/Detectors/ZDC/src/DataFormatsZDCLinkDef.h index abe1d66311913..20b73474060c2 100644 --- a/DataFormats/Detectors/ZDC/src/DataFormatsZDCLinkDef.h +++ b/DataFormats/Detectors/ZDC/src/DataFormatsZDCLinkDef.h @@ -32,6 +32,7 @@ #pragma link C++ class o2::zdc::RecEventFlat + ; #pragma link C++ class o2::zdc::ZDCEnergy + ; #pragma link C++ class o2::zdc::ZDCTDCData + ; +#pragma link C++ class o2::zdc::ZDCWaveform + ; #pragma link C++ class o2::zdc::InterCalibData + ; #pragma link C++ class std::vector < o2::zdc::ChannelData> + ; #pragma link C++ class std::vector < o2::zdc::BCData> + ; @@ -39,6 +40,7 @@ #pragma link C++ class std::vector < o2::zdc::BCRecData> + ; #pragma link C++ class std::vector < o2::zdc::ZDCEnergy> + ; #pragma link C++ class std::vector < o2::zdc::ZDCTDCData> + ; +#pragma link C++ class std::vector < o2::zdc::ZDCWaveform> + ; #pragma link C++ class std::vector < o2::zdc::RecEvent> + ; #pragma link C++ class std::vector < o2::zdc::RecEventAux> + ; #pragma link C++ class std::vector < o2::zdc::OrbitRawData> + ; diff --git a/Detectors/ZDC/reconstruction/include/ZDCReconstruction/DigiReco.h b/Detectors/ZDC/reconstruction/include/ZDCReconstruction/DigiReco.h index 447cf8ca76740..8e2b6efa7a4e6 100644 --- a/Detectors/ZDC/reconstruction/include/ZDCReconstruction/DigiReco.h +++ b/Detectors/ZDC/reconstruction/include/ZDCReconstruction/DigiReco.h @@ -111,6 +111,13 @@ class DigiReco LOG(warn) << __func__ << " Configuration of low pass filtering: " << (mLowPassFilter ? "enabled" : "disabled"); }; bool getLowPassFilter() { return mLowPassFilter; }; + void setFullInterpolation(bool val = true) + { + mFullInterpolation = val; + mFullInterpolationSet = true; + LOG(warn) << __func__ << " Full waveform interpolation: " << (mFullInterpolation ? "enabled" : "disabled"); + }; + bool getFullInterpolation() { return mLowPassFilter; }; // Enable or disable TDC corrections void setCorrSignal(bool val = true) { @@ -143,6 +150,8 @@ class DigiReco void correctTDCPile(); /// Correction of pile-up in TDC bool mLowPassFilter = true; /// Enable low pass filtering bool mLowPassFilterSet = false; /// Low pass filtering set via function call + bool mFullInterpolation = false; /// Full waveform interpolation + bool mFullInterpolationSet = false; /// Full waveform interpolation set via function call bool mCorrSignal = true; /// Enable TDC signal correction bool mCorrSignalSet = false; /// TDC signal correction set via function call bool mCorrBackground = true; /// Enable TDC pile-up correction @@ -152,9 +161,7 @@ class DigiReco int correctTDCBackground(int ibc, int itdc, std::deque& tdc); /// TDC amplitude and time corrections due to pile-up from previous bunches O2_ZDC_DIGIRECO_FLT getPoint(int itdc, int ibeg, int iend, int i); /// Interpolation for current TDC -#ifdef O2_ZDC_INTERP_DEBUG - void setPoint(int itdc, int ibeg, int iend, int i); /// Interpolation for current TDC -#endif + void setPoint(int itdc, int ibeg, int iend, int i); /// Interpolation for current TDC void assignTDC(int ibun, int ibeg, int iend, int itdc, int tdc, float amp); /// Set reconstructed TDC values void findSignals(int ibeg, int iend); /// Find signals around main-main that satisfy condition on TDC diff --git a/Detectors/ZDC/reconstruction/include/ZDCReconstruction/RecoConfigZDC.h b/Detectors/ZDC/reconstruction/include/ZDCReconstruction/RecoConfigZDC.h index 8e485161ad784..0c95e1f1550c1 100644 --- a/Detectors/ZDC/reconstruction/include/ZDCReconstruction/RecoConfigZDC.h +++ b/Detectors/ZDC/reconstruction/include/ZDCReconstruction/RecoConfigZDC.h @@ -32,9 +32,10 @@ struct RecoConfigZDC { void setBit(uint32_t ibit, bool val = true); // Signal processing - bool low_pass_filter = true; // Low pass filtering - bool corr_signal = true; // TDC signal correction - bool corr_background = true; // TDC pile-up correction + bool low_pass_filter = true; // Low pass filtering + bool full_interpolation = false; // Full interpolation of waveform + bool corr_signal = true; // TDC signal correction + bool corr_background = true; // TDC pile-up correction // TDC int tdc_search[NTDCChannels] = {250, 250, 250, 250, 250, 250, 250, 250, 250, 250}; // Search zone for a TDC signal ideally 2.5 ns (units of ~10 ps) @@ -59,7 +60,7 @@ struct RecoConfigZDC { void print(); - ClassDefNV(RecoConfigZDC, 1); + ClassDefNV(RecoConfigZDC, 2); }; } // namespace zdc } // namespace o2 diff --git a/Detectors/ZDC/reconstruction/include/ZDCReconstruction/RecoParamZDC.h b/Detectors/ZDC/reconstruction/include/ZDCReconstruction/RecoParamZDC.h index 01752a9ac8ea9..43edaad8aa1f2 100644 --- a/Detectors/ZDC/reconstruction/include/ZDCReconstruction/RecoParamZDC.h +++ b/Detectors/ZDC/reconstruction/include/ZDCReconstruction/RecoParamZDC.h @@ -32,9 +32,10 @@ struct RecoParamZDC : public o2::conf::ConfigurableParamHelper { void setBit(uint32_t ibit, bool val = true); // Signal processing - int low_pass_filter = -1; // Low pass filtering - int corr_signal = -1; // TDC signal correction - int corr_background = -1; // TDC pile-up correction + int low_pass_filter = -1; // Low pass filtering + int full_interpolation = -1; // Full interpolation of waveform + int corr_signal = -1; // TDC signal correction + int corr_background = -1; // TDC pile-up correction // TDC Int_t tmod[NTDCChannels] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; // Position of TDC channel in raw data @@ -59,6 +60,9 @@ struct RecoParamZDC : public o2::conf::ConfigurableParamHelper { // Energy calibration float energy_calib[NChannels] = {0}; // Energy calibration coefficients float tower_calib[NChannels] = {0}; // Tower calibration coefficients + + void print(); + O2ParamDef(RecoParamZDC, "RecoParamZDC"); }; } // namespace zdc diff --git a/Detectors/ZDC/reconstruction/src/DigiReco.cxx b/Detectors/ZDC/reconstruction/src/DigiReco.cxx index b98b18e508e89..04f9743e46d6c 100644 --- a/Detectors/ZDC/reconstruction/src/DigiReco.cxx +++ b/Detectors/ZDC/reconstruction/src/DigiReco.cxx @@ -45,6 +45,7 @@ void DigiReco::init() // Update reconstruction parameters // auto& ropt=RecoParamZDC::Instance(); o2::zdc::RecoParamZDC& ropt = const_cast(RecoParamZDC::Instance()); + ropt.print(); mRopt = (o2::zdc::RecoParamZDC*)&ropt; // Fill maps to decode the pattern of channels with hit @@ -89,6 +90,21 @@ void DigiReco::init() LOG(info) << "Low pass filtering is " << (mLowPassFilter ? "enabled" : "disabled"); } + // Full interpolation of waveform (N.B. function call overrides other settings) + if (mFullInterpolationSet == false) { + if (ropt.full_interpolation < 0) { + if (!mRecoConfigZDC) { + LOG(fatal) << "Configuration of interpolation: missing configuration object and no manual override"; + } else { + ropt.full_interpolation = mRecoConfigZDC->full_interpolation; + } + } + mFullInterpolation = ropt.full_interpolation > 0 ? true : false; + } + if (mVerbosity > DbgZero) { + LOG(info) << "Full waveform interpolation is " << (mFullInterpolation ? "enabled" : "disabled"); + } + if (mCorrSignalSet == false) { if (ropt.corr_signal < 0) { if (!mRecoConfigZDC) { @@ -143,6 +159,7 @@ void DigiReco::init() LOG(info) << itdc << " " << ChannelNames[TDCSignal[itdc]] << " shift= " << tdc_shift[itdc] << " i.s. = " << val * o2::zdc::FTDCVal << " ns"; } } + // Amplitude calibration for (int itdc = 0; itdc < o2::zdc::NTDCChannels; itdc++) { float fval = ropt.tdc_calib[itdc]; @@ -215,14 +232,14 @@ void DigiReco::init() } } else { ropt.tower_calib[ChTowerCalib[il]] = 1; - LOG(warning) << "Default Tower Calibration " << ChannelNames[ChTowerCalib[il]] << " = " << ropt.tower_calib[ChTowerCalib[il]]; + LOG(warning) << "Default Tower Calibration " << ChannelNames[ChTowerCalib[il]] << " = " << ropt.tower_calib[ChTowerCalib[il]]; } } // Tower energy calibration for (int il = 0; il < ChTowerCalib.size(); il++) { if (ropt.energy_calib[ChTowerCalib[il]] > 0) { - LOG(info) << "Tower Energy Calibration from command line " << ChannelNames[ChTowerCalib[il]] << " = " << ropt.energy_calib[ChTowerCalib[il]]; + LOG(info) << "Tower Energy Calibration set to " << ChannelNames[ChTowerCalib[il]] << " = " << ropt.energy_calib[ChTowerCalib[il]]; } else { ropt.energy_calib[ChTowerCalib[il]] = ropt.tower_calib[ChTowerCalib[il]] * ropt.energy_calib[CaloCommonPM[ChTowerCalib[il]]]; if (mVerbosity > DbgZero) { @@ -1055,6 +1072,7 @@ void DigiReco::processTriggerExtended(int itdc, int ibeg, int iend) interpolate(itdc, ibeg, iend); } // processTrigger +// Interpolation for single point O2_ZDC_DIGIRECO_FLT DigiReco::getPoint(int itdc, int ibeg, int iend, int i) { constexpr int nsbun = TSN * NTimeBinsPerBC; // Total number of interpolated points per bunch crossing @@ -1120,7 +1138,6 @@ O2_ZDC_DIGIRECO_FLT DigiReco::getPoint(int itdc, int ibeg, int iend, int i) } } -#ifdef O2_ZDC_INTERP_DEBUG void DigiReco::setPoint(int itdc, int ibeg, int iend, int i) { constexpr int nsbun = TSN * NTimeBinsPerBC; // Total number of interpolated points per bunch crossing @@ -1143,7 +1160,6 @@ void DigiReco::setPoint(int itdc, int ibeg, int iend, int i) mReco[ibun].inter[itdc][isam] = getPoint(itdc, ibeg, iend, i); } } // setPoint -#endif void DigiReco::interpolate(int itdc, int ibeg, int iend) { @@ -1166,19 +1182,20 @@ void DigiReco::interpolate(int itdc, int ibeg, int iend) constexpr int nsp = 5; // Number of points to be searched + int imod = mRopt->tmod[itdc]; // Module corresponding to TDC channel + // int ich = mRopt->tch[itdc]; // Hardware channel corresponding to TDC channel + int isig = TDCSignal[itdc]; // Signal corresponding to TDC + // At this level there should be no need to check if the TDC channel is connected // since a fatal should have been raised already for (int ibun = ibeg; ibun <= iend; ibun++) { - auto ref = mReco[ibun].ref[TDCSignal[itdc]]; + auto ref = mReco[ibun].ref[isig]; if (ref == ZDCRefInitVal) { LOG(fatal) << "Missing information for bunch crossing"; } + mReco[ibun].flags = mReco[ibun].flags | (0x1<tmod[itdc]; // Module corresponding to TDC channel - // int ich = mRopt->tch[itdc]; // Hardware channel corresponding to TDC channel - int isig = TDCSignal[itdc]; // Signal corresponding to TDC - auto ref_beg = mReco[ibeg].ref[isig]; auto ref_end = mReco[iend].ref[isig]; @@ -1190,13 +1207,14 @@ void DigiReco::interpolate(int itdc, int ibeg, int iend) mLastSample = mChData[ref_end].data[MaxTimeBin]; #endif - // O2_ZDC_INTERP_DEBUG turns on full interpolation for debugging + // mFullInterpolation turns on full interpolation for debugging // otherwise the interpolation is performed only around actual signal -#ifdef O2_ZDC_INTERP_DEBUG - for (int i = 0; i < mNtot; i++) { - setPoint(itdc, ibeg, iend, i); + // TODO: extend full interpolation to all channels + if (mFullInterpolation) { + for (int i = 0; i < mNtot; i++) { + setPoint(itdc, ibeg, iend, i); + } } -#endif // Looking for a local maximum in a search zone O2_ZDC_DIGIRECO_FLT amp = std::numeric_limits::infinity(); // Amplitude to be stored @@ -1337,13 +1355,14 @@ void DigiReco::interpolate(int itdc, int ibeg, int iend) } if (is_searchable) { int mysam = isam % nsbun; -#ifndef O2_ZDC_INTERP_DEBUG - // Perform interpolation for the searched point - // setPoint(itdc, ibeg, iend, isam); - O2_ZDC_DIGIRECO_FLT myval = getPoint(itdc, ibeg, iend, isam); -#else - O2_ZDC_DIGIRECO_FLT myval = mReco[ib_cur].inter[itdc][mysam]; -#endif + O2_ZDC_DIGIRECO_FLT myval; + if (mFullInterpolation) { + // Already interpolated + myval = mReco[ib_cur].inter[itdc][mysam]; + } else { + // Perform interpolation for the searched point + myval = getPoint(itdc, ibeg, iend, isam); + } // Get local minimum of waveform if (myval < amp) { amp = myval; diff --git a/Detectors/ZDC/reconstruction/src/RecoConfigZDC.cxx b/Detectors/ZDC/reconstruction/src/RecoConfigZDC.cxx index 1fbc550c86c18..dd1ab13ffcfad 100644 --- a/Detectors/ZDC/reconstruction/src/RecoConfigZDC.cxx +++ b/Detectors/ZDC/reconstruction/src/RecoConfigZDC.cxx @@ -86,6 +86,11 @@ void RecoConfigZDC::setPedThreshold(int32_t ich, float high, float low) void RecoConfigZDC::print() { + LOGF(info, "RecoConfigZDC:%s%s%s%s", + (low_pass_filter ? " LowPassFilter" : ""), + (full_interpolation ? " FullInterpolation" : ""), + (corr_signal ? " CorrSignal" : ""), + (corr_background ? " CorrBackground" : "")); for (int itdc = 0; itdc < NTDCChannels; itdc++) { LOG(info) << itdc << " " << ChannelNames[TDCSignal[itdc]] << " search= " << tdc_search[itdc] << " = " << tdc_search[itdc] * FTDCVal << " ns"; } diff --git a/Detectors/ZDC/reconstruction/src/RecoParamZDC.cxx b/Detectors/ZDC/reconstruction/src/RecoParamZDC.cxx index 7b8232149e689..2efddf5fa34bf 100644 --- a/Detectors/ZDC/reconstruction/src/RecoParamZDC.cxx +++ b/Detectors/ZDC/reconstruction/src/RecoParamZDC.cxx @@ -22,3 +22,103 @@ void o2::zdc::RecoParamZDC::setBit(uint32_t ibit, bool val) LOG(fatal) << __func__ << " bit " << ibit << " not in allowed range"; } } + +void o2::zdc::RecoParamZDC::print() +{ + bool printed = false; + if (!printed) { + printed = true; + LOG(info) << "RecoParamZDC"; + } + if (low_pass_filter >= 0 || full_interpolation >= 0 || corr_signal >= 0 || corr_background >= 0) { + if (!printed) { + LOG(info) << "RecoParamZDC"; + printed = true; + } + if (low_pass_filter >= 0) { + printf(" LowPassFilter=%d", low_pass_filter); + } + if (full_interpolation >= 0) { + printf(" FullInterpolation=%d", full_interpolation); + } + if (corr_signal >= 0) { + printf(" CorrSignal=%d", corr_signal); + } + if (corr_background >= 0) { + printf(" CorrBackground=%d", corr_background); + } + printf("\n"); + } + /* + Int_t tsh[NTDCChannels] = {4, 4, 4, 4, 4, 4, 4, 4, 4, 4}; // Trigger shift + Int_t tth[NTDCChannels] = {8, 8, 8, 8, 8, 8, 8, 8, 8, 8}; // Trigger threshold + bool bitset[NTDCChannels] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // Set bits in coincidence + void setBit(uint32_t ibit, bool val = true); + + // Signal processing + int low_pass_filter = -1; // Low pass filtering + int full_interpolation = -1; // Full interpolation of waveform + int corr_signal = -1; // TDC signal correction + int corr_background = -1; // TDC pile-up correction + + // TDC + Int_t tmod[NTDCChannels] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; // Position of TDC channel in raw data + Int_t tch[NTDCChannels] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; // Position of TDC channel in raw data + float tdc_shift[NTDCChannels] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; // Correction of TDC position (0-25 ns, units of ~10 ps) + float tdc_calib[NTDCChannels] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; // Correction of TDC amplitude + float tdc_search[NTDCChannels] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; // Search zone for a TDC signal ideally 2.5 ns (units of ~10 ps) + + // Charge integration + Int_t amod[NChannels] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; // Position of ADC channel in raw data + Int_t ach[NChannels] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; // Position of ADC channel in raw data + // Beginning and end of integration range: signal + Int_t beg_int[NChannels] = {DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange}; + Int_t end_int[NChannels] = {DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange}; + // Beginning and end of integration range: pedestal + Int_t beg_ped_int[NChannels] = {DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange}; + Int_t end_ped_int[NChannels] = {DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange, DummyIntRange}; + // Pedestal thresholds for pile-up detection + float ped_thr_hi[NChannels] = {ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange}; + float ped_thr_lo[NChannels] = {ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange, ADCRange}; + */ + bool modified = false; + for (int i = 0; i < o2::zdc::NChannels; i++) { + if (energy_calib[NChannels] != 0) { + modified = true; + break; + } + } + if (modified) { + if (!printed) { + printed = true; + LOG(info) << "RecoParamZDC"; + } + printf("energ_calib: "); + for (int i = 0; i < o2::zdc::NChannels; i++) { + if (energy_calib[NChannels] != 0) { + printf(" %s=%f", o2::zdc::ChannelNames[i].data(), energy_calib[i]); + } + } + printf("\n"); + } + modified = false; + for (int i = 0; i < o2::zdc::NChannels; i++) { + if (tower_calib[NChannels] != 0) { + modified = true; + break; + } + } + if (modified) { + if (!printed) { + printed = true; + LOG(info) << "RecoParamZDC"; + } + printf("tower_calib: "); + for (int i = 0; i < o2::zdc::NChannels; i++) { + if (tower_calib[NChannels] != 0) { + printf(" %s=%f", o2::zdc::ChannelNames[i].data(), tower_calib[i]); + } + } + printf("\n"); + } +} diff --git a/Detectors/ZDC/workflow/src/DigitRecoSpec.cxx b/Detectors/ZDC/workflow/src/DigitRecoSpec.cxx index 4fdaec1c51a08..814dcae85a58d 100644 --- a/Detectors/ZDC/workflow/src/DigitRecoSpec.cxx +++ b/Detectors/ZDC/workflow/src/DigitRecoSpec.cxx @@ -176,8 +176,10 @@ void DigitRecoSpec::run(ProcessingContext& pc) mDR.process(peds, bcdata, chans); const std::vector& recAux = mDR.getReco(); + // Transfer wafeform + bool fullinter = mDR.getFullInterpolation(); RecEvent recEvent; - LOG(info) << "BC processed during reconstruction " << recAux.size(); + LOGF(info, "BC processed during reconstruction %d%s", recAux.size(), (fullinter ? " FullInterpolation" : "")); uint32_t nte = 0, ntt = 0, nti = 0; for (auto reca : recAux) { bool toAddBC = true; @@ -193,6 +195,19 @@ void DigitRecoSpec::run(ProcessingContext& pc) nt++; recEvent.addTDC(it, reca.TDCVal[it][ih], reca.TDCAmp[it][ih], reca.isBeg[it], reca.isEnd[it]); } + // Add waveform information + if (fullinter) { + auto sig = TDCSignal[it]; + uint32_t mask = 0x1 << sig; + if (reca.flags & mask) { + if (toAddBC) { + recEvent.addBC(reca); + toAddBC = false; + } + recEvent.addWaveform(sig, reca.inter[it]); + printf("Orbit %9u bc %4u itdc %d sig %d flags=%x\n", reca.ir.orbit, reca.ir.bc, it, sig, reca.flags); + } + } } if (ne > 0) { if (toAddBC) { @@ -206,7 +221,7 @@ void DigitRecoSpec::run(ProcessingContext& pc) } nte += ne; ntt += nt; - if (mVerbosity > 0 && (nt > 0 || ne > 0)) { + if (mVerbosity > 1 && (nt > 0 || ne > 0)) { printf("Orbit %9u bc %4u ntdc %2d ne %2d\n", reca.ir.orbit, reca.ir.bc, nt, ne); } // Event information @@ -219,6 +234,7 @@ void DigitRecoSpec::run(ProcessingContext& pc) pc.outputs().snapshot(Output{"ZDC", "ENERGY", 0, Lifetime::Timeframe}, recEvent.mEnergy); pc.outputs().snapshot(Output{"ZDC", "TDCDATA", 0, Lifetime::Timeframe}, recEvent.mTDCData); pc.outputs().snapshot(Output{"ZDC", "INFO", 0, Lifetime::Timeframe}, recEvent.mInfo); + pc.outputs().snapshot(Output{"ZDC", "WAVEFORM", 0, Lifetime::Timeframe}, recEvent.mWaveform); mTimer.Stop(); } @@ -241,6 +257,7 @@ framework::DataProcessorSpec getDigitRecoSpec(const int verbosity = 0, const boo outputs.emplace_back("ZDC", "ENERGY", 0, Lifetime::Timeframe); outputs.emplace_back("ZDC", "TDCDATA", 0, Lifetime::Timeframe); outputs.emplace_back("ZDC", "INFO", 0, Lifetime::Timeframe); + outputs.emplace_back("ZDC", "WAVEFORM", 0, Lifetime::Timeframe); return DataProcessorSpec{ "zdc-digi-reco", diff --git a/Detectors/ZDC/workflow/src/ZDCRecoWriterDPLSpec.cxx b/Detectors/ZDC/workflow/src/ZDCRecoWriterDPLSpec.cxx index 5ecb4c5938e11..9a2e4441cadc0 100644 --- a/Detectors/ZDC/workflow/src/ZDCRecoWriterDPLSpec.cxx +++ b/Detectors/ZDC/workflow/src/ZDCRecoWriterDPLSpec.cxx @@ -17,8 +17,9 @@ #include "DataFormatsZDC/BCRecData.h" #include "DataFormatsZDC/ZDCEnergy.h" #include "DataFormatsZDC/ZDCTDCData.h" - +#include "DataFormatsZDC/ZDCWaveform.h" #include "ZDCWorkflow/ZDCRecoWriterDPLSpec.h" + using namespace o2::framework; namespace o2 @@ -42,7 +43,8 @@ DataProcessorSpec getZDCRecoWriterDPLSpec() BranchDefinition>{InputSpec{"bcrec", "ZDC", "BCREC"}, "ZDCRecBC"}, BranchDefinition>{InputSpec{"energy", "ZDC", "ENERGY"}, "ZDCRecE"}, BranchDefinition>{InputSpec{"tdcdata", "ZDC", "TDCDATA"}, "ZDCRecTDC"}, - BranchDefinition>{InputSpec{"info", "ZDC", "INFO"}, "ZDCRecInfo"})(); + BranchDefinition>{InputSpec{"info", "ZDC", "INFO"}, "ZDCRecInfo"}, + BranchDefinition>{InputSpec{"wave", "ZDC", "WAVEFORM"}, "ZDCWaveform"})(); } } // namespace zdc From 57f8fb7927e9637c2613e67c52de4dcd7d7573a6 Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Thu, 5 May 2022 16:15:51 +0200 Subject: [PATCH 02/40] Optional transfer of interpolated waveform for TDC channels --- .../ZDC/include/DataFormatsZDC/ZDCWaveform.h | 66 +++++++++++++++++++ DataFormats/Detectors/ZDC/src/ZDCWaveform.cxx | 20 ++++++ 2 files changed, 86 insertions(+) create mode 100644 DataFormats/Detectors/ZDC/include/DataFormatsZDC/ZDCWaveform.h create mode 100644 DataFormats/Detectors/ZDC/src/ZDCWaveform.cxx diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/ZDCWaveform.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/ZDCWaveform.h new file mode 100644 index 0000000000000..cb0a50912629e --- /dev/null +++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/ZDCWaveform.h @@ -0,0 +1,66 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#ifndef ZDC_WAVEFORM_H +#define ZDC_WAVEFORM_H + +#include "ZDCBase/Constants.h" +#include +#include +#include + +/// \file ZDCWaveform.h +/// \brief Container class to store the interpolated waveform of the ZDC +/// \author pietro.cortese@cern.ch + +namespace o2 +{ +namespace zdc +{ + +struct ZDCWaveform { + + uint8_t sig = 0; /// Signal id + float inter[NTimeBinsPerBC * TSN] = {0}; + + ZDCWaveform() = default; + + ZDCWaveform(uint8_t mych, float* waveform) + { + set(mych, waveform); + } + + inline void set(uint8_t ch, float* waveform) + { + sig = ch; + for (int i = 0; i < (NTimeBinsPerBC * TSN); i++) { + inter[i] = waveform[i]; + } + } + + const float* waveform() const + { + return inter; + } + + uint8_t ch() const + { + return sig; + } + + void print() const; + + ClassDefNV(ZDCWaveform, 1); +}; +} // namespace zdc +} // namespace o2 + +#endif diff --git a/DataFormats/Detectors/ZDC/src/ZDCWaveform.cxx b/DataFormats/Detectors/ZDC/src/ZDCWaveform.cxx new file mode 100644 index 0000000000000..66b398e3fb5f2 --- /dev/null +++ b/DataFormats/Detectors/ZDC/src/ZDCWaveform.cxx @@ -0,0 +1,20 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#include "DataFormatsZDC/ZDCWaveform.h" + +using namespace o2::zdc; + +void ZDCWaveform::print() const +{ + auto id = this->ch(); + printf("%2d (%s)\n", id, channelName(id)); +} From 0648d456ffd6c26b2e0a920261b573457e40cb5f Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Thu, 5 May 2022 18:40:47 +0200 Subject: [PATCH 03/40] WIP --- Detectors/ZDC/calib/CMakeLists.txt | 4 +- .../include/ZDCCalib/WaveformCalibConfig.h | 67 +++++++++ .../calib/include/ZDCCalib/WaveformCalibEPN.h | 63 +++++++++ .../ZDC/calib/src/WaveformCalibConfig.cxx | 129 ++++++++++++++++++ Detectors/ZDC/calib/src/WaveformCalibEPN.cxx | 116 ++++++++++++++++ Detectors/ZDC/calib/src/ZDCCalibLinkDef.h | 1 + Detectors/ZDC/macro/CMakeLists.txt | 6 + .../ZDC/macro/CreateWaveformCalibConfig.C | 63 +++++++++ 8 files changed, 448 insertions(+), 1 deletion(-) create mode 100644 Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h create mode 100644 Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h create mode 100644 Detectors/ZDC/calib/src/WaveformCalibConfig.cxx create mode 100644 Detectors/ZDC/calib/src/WaveformCalibEPN.cxx create mode 100644 Detectors/ZDC/macro/CreateWaveformCalibConfig.C diff --git a/Detectors/ZDC/calib/CMakeLists.txt b/Detectors/ZDC/calib/CMakeLists.txt index d163e440c7af8..18dcb934ec268 100644 --- a/Detectors/ZDC/calib/CMakeLists.txt +++ b/Detectors/ZDC/calib/CMakeLists.txt @@ -16,6 +16,7 @@ o2_add_library(ZDCCalib src/InterCalibSpec.cxx src/InterCalibEPN.cxx src/InterCalibEPNSpec.cxx + src/WaveformCalibConfig.cxx PUBLIC_LINK_LIBRARIES O2::CCDB O2::DPLUtils @@ -38,7 +39,8 @@ o2_target_root_dictionary(ZDCCalib include/ZDCCalib/InterCalibConfig.h include/ZDCCalib/InterCalibSpec.h include/ZDCCalib/InterCalibEPN.h - include/ZDCCalib/InterCalibEPNSpec.h) + include/ZDCCalib/InterCalibEPNSpec.h + include/ZDCCalib/WaveformCalibConfig.h) o2_add_executable(intercalib-workflow COMPONENT_NAME zdc diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h new file mode 100644 index 0000000000000..f6b2d73c7c726 --- /dev/null +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h @@ -0,0 +1,67 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#ifndef O2_ZDC_WAVEFORMCALIBCONFIG_H +#define O2_ZDC_WAVEFORMCALIBCONFIG_H + +#include "ZDCBase/Constants.h" +#include +#include +#include + +/// \file WaveformCalibConfig.h +/// \brief Configuration of ZDC Tower intercalibration procedure +/// \author P. Cortese + +namespace o2 +{ +namespace zdc +{ +struct WaveformCalibConfig { + + WaveformCalibConfig(); + + static constexpr int NH = NTDCChannels; + static constexpr int NBB = 3; + static constexpr int NBA = 6; + static constexpr int NBT = NBB + NBA + 1; + + double cutLow[NH]; + double cutHigh[NH]; + double min_e[NH] = {0.}; + std::string desc = ""; + int ibeg = - NBB; + int iend = NBA; + int nbun = iend - ibeg + 1; + + void print() const; + void restrictRange(int ib, int ie); + void resetCuts(); + void resetCutLow(); + void resetCutHigh(); + void resetCutLow(int ih); + void resetCutHigh(int ih); + void setMinEntries(double val); + void setMinEntries(int ih, double val); + void setCutLow(double val); + void setCutHigh(double val); + void setCutLow(int ih, double val); + void setCutHigh(int ih, double val); + void setCuts(double low, double high); + void setCuts(int ih, double low, double high); + void setDescription(std::string d) { desc = d; } + + ClassDefNV(WaveformCalibConfig, 1); +}; +} // namespace zdc +} // namespace o2 + +#endif diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h new file mode 100644 index 0000000000000..c0f2486b57179 --- /dev/null +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h @@ -0,0 +1,63 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#include +#include +#include +#include +#include +#include +#include +#include "ZDCBase/Constants.h" +#include "CommonDataFormat/FlatHisto1D.h" +#include "CommonDataFormat/FlatHisto2D.h" +#include "DataFormatsZDC/RecEvent.h" +#include "ZDCReconstruction/ZDCEnergyParam.h" +#include "ZDCReconstruction/ZDCTowerParam.h" +#include "ZDCCalib/WaveformCalibConfig.h" +#include "DataFormatsZDC/ZDCWaveform.h" +#ifndef ALICEO2_ZDC_WAVEFORMCALIBEPN_H_ +#define ALICEO2_ZDC_WAVEFORMCALIBEPN_H_ +namespace o2 +{ +namespace zdc +{ +class WaveformCalibEPN +{ + public: + WaveformCalibEPN() = default; + int init(); + static constexpr int NH = WaveformCalibConfig::NH; + void clear(int ih = -1); + int process(const gsl::span& bcrec, + const gsl::span& energy, + const gsl::span& tdc, + const gsl::span& info, + const gsl::span& wave); + int endOfRun(); + int write(const std::string fn = "ZDCWaveformCalibEPN.root"); + void setWaveformCalibConfig(const WaveformCalibConfig* param) { mWaveformCalibConfig = param; }; + const WaveformCalibConfig* getWaveformCalibConfig() const { return mWaveformCalibConfig; }; + void setSaveDebugHistos() { mSaveDebugHistos = true; } + void setDontSaveDebugHistos() { mSaveDebugHistos = false; } + std::array*, NH> mH{}; + + private: + bool mInitDone = false; + bool mSaveDebugHistos = false; + int32_t mNBin = 0; + int32_t mVerbosity = DbgMinimal; + const WaveformCalibConfig* mWaveformCalibConfig = nullptr; /// Configuration of intercalibration +}; +} // namespace zdc +} // namespace o2 + +#endif diff --git a/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx b/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx new file mode 100644 index 0000000000000..db694f9d7c7bb --- /dev/null +++ b/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx @@ -0,0 +1,129 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#include "Framework/Logger.h" +#include "ZDCCalib/WaveformCalibConfig.h" + +using namespace o2::zdc; +WaveformCalibConfig::WaveformCalibConfig() +{ + for (int i = 0; i < NH; i++) { + cutLow[i] = -std::numeric_limits::infinity(); + cutHigh[i] = std::numeric_limits::infinity(); + } +} + +void WaveformCalibConfig::restrictRange(int ib, int ie) +{ + ibeg = -NBB; + iend = NBA; + if (ib >= ibeg && ib < 0) { + ibeg = ib; + } else { + LOG(fatal) << __func__ << " wrong setting for ibeg = " << ib; + } + if (ie <= iend && ie > 0) { + iend = ie; + } else { + LOG(fatal) << __func__ << " wrong setting for iend = " << ie; + } + nbun = iend - ibeg + 1; +} + +void WaveformCalibConfig::print() const +{ + LOG(info) << "WaveformCalibConfig range [" << ibeg << ":" << iend << "]"; + for (Int_t ih = 0; ih < NH; ih++) { + LOG(info) << ChannelNames[TDCSignal[ih]] << " limits = (" << cutLow[ih] << " : " << cutHigh[ih] << ") min_entries = " << min_e[ih]; + } +} + +void WaveformCalibConfig::setMinEntries(double val) +{ + for (int32_t ih = 0; ih < NH; ih++) { + min_e[ih] = val; + } +} + +void WaveformCalibConfig::setMinEntries(int ih, double val) +{ + min_e[ih] = val; +} + +void WaveformCalibConfig::resetCuts() +{ + for (int32_t ih = 0; ih < NH; ih++) { + cutLow[ih] = -std::numeric_limits::infinity(); + cutHigh[ih] = std::numeric_limits::infinity(); + } +} + +void WaveformCalibConfig::resetCutLow() +{ + for (int32_t ih = 0; ih < NH; ih++) { + cutLow[ih] = -std::numeric_limits::infinity(); + } +} + +void WaveformCalibConfig::resetCutHigh() +{ + for (int32_t ih = 0; ih < NH; ih++) { + cutHigh[ih] = std::numeric_limits::infinity(); + } +} + +void WaveformCalibConfig::resetCutLow(int ih) +{ + cutLow[ih] = -std::numeric_limits::infinity(); +} + +void WaveformCalibConfig::resetCutHigh(int ih) +{ + cutHigh[ih] = std::numeric_limits::infinity(); +} + +void WaveformCalibConfig::setCutLow(double val) +{ + for (int32_t ih = 0; ih < NH; ih++) { + cutLow[ih] = val; + } +} + +void WaveformCalibConfig::setCutHigh(double val) +{ + for (int32_t ih = 0; ih < NH; ih++) { + cutHigh[ih] = val; + } +} + +void WaveformCalibConfig::setCutLow(int ih, double val) +{ + cutLow[ih] = val; +} + +void WaveformCalibConfig::setCutHigh(int ih, double val) +{ + cutHigh[ih] = val; +} + +void WaveformCalibConfig::setCuts(double low, double high) +{ + for (int32_t ih = 0; ih < NH; ih++) { + cutLow[ih] = low; + cutHigh[ih] = high; + } +} + +void WaveformCalibConfig::setCuts(int ih, double low, double high) +{ + cutHigh[ih] = low; + cutLow[ih] = high; +} diff --git a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx new file mode 100644 index 0000000000000..1c6a7b866d648 --- /dev/null +++ b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx @@ -0,0 +1,116 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#include +#include +#include +#include +#include +#include +#include +#include +#include "ZDCCalib/WaveformCalibEPN.h" +//#include "ZDCCalib/WaveformCalib.h" +#include "Framework/Logger.h" + +using namespace o2::zdc; + +int WaveformCalibEPN::init() +{ + if (mWaveformCalibConfig == nullptr) { + LOG(fatal) << "o2::zdc::WaveformCalibEPN: missing configuration object"; + return -1; + } + + auto* cfg = mWaveformCalibConfig; + + // number of bins + mNBin = cfg->nbun * TSN; + for (int ih = 0; ih < NH; ih++) { + mH[ih] = new o2::dataformats::FlatHisto1D(mNBin, 0, mNBin); + } + mInitDone = true; + return 0; +} + +int WaveformCalibEPN::process(const gsl::span& RecBC, + const gsl::span& Energy, + const gsl::span& TDCData, + const gsl::span& Info, + const gsl::span& wave) +{ + if (!mInitDone) { + init(); + } + LOG(info) << "o2::zdc::WaveformCalibEPN processing " << RecBC.size() << " b.c. @ TS " << mData.mCTimeBeg << " : " << mData.mCTimeEnd; + o2::zdc::RecEventFlat ev; + ev.init(RecBC, Energy, TDCData, Info); + while (ev.next()) { + if (ev.getNInfo() > 0) { + auto& decodedInfo = ev.getDecodedInfo(); + for (uint16_t info : decodedInfo) { + uint8_t ch = (info >> 10) & 0x1f; + uint16_t code = info & 0x03ff; + // hmsg->Fill(ch, code); + } + if (mVerbosity > DbgMinimal) { + ev.print(); + } + // Need clean data (no messages) + // We are sure there is no pile-up in any channel (too restrictive?) + continue; + } + // Analyze TDC + + } + return 0; +} + +int WaveformCalibEPN::endOfRun() +{ + if (mVerbosity > DbgZero) { + LOGF(info, "WaveformCalibEPN::endOfRun ts (%llu:%llu)", mData.mCTimeBeg, mData.mCTimeEnd); + for (int ih = 0; ih < NH; ih++) { + LOGF(info, "%s %g events and cuts (%g:%g)", WaveformCalibData::DN[ih], mData.mSum[ih][5][5], mWaveformCalibConfig->cutLow[ih], mWaveformCalibConfig->cutHigh[ih]); + } + } + if (mSaveDebugHistos) { + write(); + } + return 0; +} + +int WaveformCalibEPN::write(const std::string fn) +{ + TDirectory* cwd = gDirectory; + TFile* f = new TFile(fn.data(), "recreate"); + if (f->IsZombie()) { + LOG(error) << "Cannot create file: " << fn; + return 1; + } + for (int32_t ih = 0; ih < (2 * NH); ih++) { + if (mH[ih]) { + auto p = mH[ih]->createTH1F(WaveformCalib::mHUncN[ih]); + p->SetTitle(WaveformCalib::mHUncT[ih]); + p->Write("", TObject::kOverwrite); + } + } + for (int32_t ih = 0; ih < NH; ih++) { + if (mC[ih]) { + auto p = mC[ih]->createTH2F(WaveformCalib::mCUncN[ih]); + p->SetTitle(WaveformCalib::mCUncT[ih]); + p->Write("", TObject::kOverwrite); + } + } + f->Close(); + cwd->cd(); + return 0; +} diff --git a/Detectors/ZDC/calib/src/ZDCCalibLinkDef.h b/Detectors/ZDC/calib/src/ZDCCalibLinkDef.h index 800fef2f11d83..58bb990afecf7 100644 --- a/Detectors/ZDC/calib/src/ZDCCalibLinkDef.h +++ b/Detectors/ZDC/calib/src/ZDCCalibLinkDef.h @@ -16,5 +16,6 @@ #pragma link off all functions; #pragma link C++ class o2::zdc::InterCalibConfig + ; +#pragma link C++ class o2::zdc::WaveformCalibConfig + ; #endif diff --git a/Detectors/ZDC/macro/CMakeLists.txt b/Detectors/ZDC/macro/CMakeLists.txt index 4793e8eb3cff0..7f2338d624e7b 100644 --- a/Detectors/ZDC/macro/CMakeLists.txt +++ b/Detectors/ZDC/macro/CMakeLists.txt @@ -58,3 +58,9 @@ o2_add_test_root_macro(CreateInterCalibConfig.C O2::SimulationDataFormat O2::CCDB O2::ZDCCalib LABELS zdc) + +o2_add_test_root_macro(CreateWaveformCalibConfig.C + PUBLIC_LINK_LIBRARIES O2::ZDCBase O2::ZDCReconstruction + O2::SimulationDataFormat O2::CCDB + O2::ZDCCalib + LABELS zdc) diff --git a/Detectors/ZDC/macro/CreateWaveformCalibConfig.C b/Detectors/ZDC/macro/CreateWaveformCalibConfig.C new file mode 100644 index 0000000000000..c0bdd2ab2bfd7 --- /dev/null +++ b/Detectors/ZDC/macro/CreateWaveformCalibConfig.C @@ -0,0 +1,63 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#if !defined(__CLING__) || defined(__ROOTCLING__) + +#include "Framework/Logger.h" +#include "CCDB/CcdbApi.h" +#include +#include + +#endif + +#include "ZDCBase/Constants.h" +#include "ZDCCalib/WaveformCalibConfig.h" + +using namespace o2::zdc; +using namespace std; + +void CreateWaveformCalibConfig(long tmin = 0, long tmax = -1, std::string ccdbHost = "") +{ + + // This object configures the measurement of the average waveforms for the ZDC channels + WaveformCalibConfig conf; + + // Threshold to include the interpolated waveform into the average + // One should avoid to sum signals that are too small and have + // low signal/background + // By taking into account the baseline (~1800) and the waveform + // range -2048 : 2047 one should not use signals too close to + // maximum allowed amplitude (1800+2048) + conf.setCuts(600, 3000); + + conf.setDescription("Simulated data"); + conf.setMinEntries(200); + + conf.print(); + + o2::ccdb::CcdbApi api; + map metadata; // can be empty + if (ccdbHost.size() == 0 || ccdbHost == "external") { + ccdbHost = "http://alice-ccdb.cern.ch:8080"; + } else if (ccdbHost == "internal") { + ccdbHost = "http://o2-ccdb.internal/"; + } else if (ccdbHost == "test") { + ccdbHost = "http://ccdb-test.cern.ch:8080"; + } else if (ccdbHost == "local") { + ccdbHost = "http://localhost:8080"; + } + api.init(ccdbHost.c_str()); + LOG(info) << "CCDB server: " << api.getURL(); + // store abitrary user object in strongly typed manner + api.storeAsTFileAny(&conf, CCDBPathInterCalibConfig, metadata, tmin, tmax); + + // return conf; +} From ab5354905a4b72461cab6b76f1212a088450f6a0 Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Fri, 6 May 2022 17:25:20 +0200 Subject: [PATCH 04/40] WIP --- .../ZDC/include/DataFormatsZDC/RecEventFlat.h | 5 ++ .../DataFormatsZDC/WaveformCalibData.h | 45 ++++++++++++ .../Detectors/ZDC/src/WaveformCalibData.cxx | 72 +++++++++++++++++++ .../ZDC/base/include/ZDCBase/Constants.h | 14 ++++ Detectors/ZDC/calib/CMakeLists.txt | 6 +- .../include/ZDCCalib/WaveformCalibQueue.h | 44 ++++++++++++ Detectors/ZDC/calib/src/WaveformCalibEPN.cxx | 51 +++++++++---- .../ZDC/calib/src/WaveformCalibQueue.cxx | 39 ++++++++++ 8 files changed, 262 insertions(+), 14 deletions(-) create mode 100644 DataFormats/Detectors/ZDC/include/DataFormatsZDC/WaveformCalibData.h create mode 100644 DataFormats/Detectors/ZDC/src/WaveformCalibData.cxx create mode 100644 Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h create mode 100644 Detectors/ZDC/calib/src/WaveformCalibQueue.cxx diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventFlat.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventFlat.h index 11dd493ad722a..826a6a164744a 100644 --- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventFlat.h +++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventFlat.h @@ -100,6 +100,11 @@ struct RecEventFlat { // NOLINT: false positive in clang-tidy !! int next(); + inline int getEntries() const + { + return mNEntries; + } + inline NElem getNEnergy() const { return mNE; diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/WaveformCalibData.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/WaveformCalibData.h new file mode 100644 index 0000000000000..c953d44d47531 --- /dev/null +++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/WaveformCalibData.h @@ -0,0 +1,45 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#ifndef ZDC_WAVEFORMCALIB_DATA_H_ +#define ZDC_WAVEFORMCALIB_DATA_H_ + +#include "ZDCBase/Constants.h" +#include "ZDCCalib/WaveformCalibConfig.h" +#include +#include + +/// \file WaveformCalibData.h +/// \brief Waveform calibration intermediate data +/// \author pietro.cortese@cern.ch + +namespace o2 +{ +namespace zdc +{ + +struct WaveformCalibData { + static constexpr int NH = WaveformCalibConfig::NH; + uint64_t mCTimeBeg = 0; /// Time of processed time frame + uint64_t mCTimeEnd = 0; /// Time of processed time frame + std::array mWave[NH]; + mEntries[NH] = {0}; + WaveformCalibData& operator+=(const WaveformCalibData& other); + int getEntries(int ih) const; + void print() const; + void setCreationTime(uint64_t ctime); + ClassDefNV(WaveformCalibData, 1); +}; + +} // namespace zdc +} // namespace o2 + +#endif diff --git a/DataFormats/Detectors/ZDC/src/WaveformCalibData.cxx b/DataFormats/Detectors/ZDC/src/WaveformCalibData.cxx new file mode 100644 index 0000000000000..87edace64d3e2 --- /dev/null +++ b/DataFormats/Detectors/ZDC/src/WaveformCalibData.cxx @@ -0,0 +1,72 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#include "Framework/Logger.h" +#include "DataFormatsZDC/WaveformCalibData.h" + +using namespace o2::zdc; + +void WaveformCalibData::print() const +{ + for (int i = 0; i < NH; i++) { + LOGF(info, "%s", DN[i]); + for (int j = 0; j < NPAR; j++) { + for (int k = 0; k < NPAR; k++) { + if (k == 0) { + printf("%e", mSum[i][j][k]); + } else { + printf(" %e", mSum[i][j][k]); + } + } + printf("\n"); + } + } +} + +WaveformCalibData& WaveformCalibData::operator+=(const WaveformCalibData& other) +{ + for (int32_t ih = 0; ih < NH; ih++) { + for (int32_t i = 0; i < NPAR; i++) { + for (int32_t j = 0; j < NPAR; j++) { + mSum[ih][i][j] += other.mSum[ih][i][j]; + } + } + } + if (mCTimeBeg == 0 || other.mCTimeBeg < mCTimeBeg) { + mCTimeBeg = other.mCTimeBeg; + } + if (other.mCTimeEnd > mCTimeEnd) { + mCTimeEnd = other.mCTimeEnd; + } + //#ifdef O2_ZDC_DEBUG + LOGF(info, "WaveformCalibData [%llu : %llu]: %s=%d %s=%d %s=%d %s=%d %s=%d", mCTimeBeg, mCTimeEnd, DN[0], getEntries(0), DN[1], getEntries(1), + DN[2], getEntries(2), DN[3], getEntries(3), DN[4], getEntries(4)); + //#endif + return *this; +} + +void WaveformCalibData::setCreationTime(uint64_t ctime) +{ + mCTimeBeg = ctime; + mCTimeEnd = ctime; +#ifdef O2_ZDC_DEBUG + LOGF(info, "WaveformCalibData::setCreationTime %llu", ctime); +#endif +} + +int WaveformCalibData::getEntries(int ih) const +{ + if (ih < 0 || ih >= NH) { + LOGF(error, "WaveformCalibData::getEntries ih = %d is out of range", ih); + return 0; + } + return mSum[ih][5][5]; +} diff --git a/Detectors/ZDC/base/include/ZDCBase/Constants.h b/Detectors/ZDC/base/include/ZDCBase/Constants.h index 015187f87d927..71ad8cf40e728 100644 --- a/Detectors/ZDC/base/include/ZDCBase/Constants.h +++ b/Detectors/ZDC/base/include/ZDCBase/Constants.h @@ -209,6 +209,7 @@ constexpr std::string_view ChannelNames[] = { "ZPC4", "ZPCS"}; +// From TDC ID to signal ID const int TDCSignal[NTDCChannels] = { IdZNAC, // TDCZNAC IdZNASum, // TDCZNAS @@ -222,6 +223,19 @@ const int TDCSignal[NTDCChannels] = { IdZPCSum // TDCZPCS }; +// From Signal ID to TDC ID +const int SignalTDC[NChannels] = { + TDCZNAC, + TDCZNAS, TDCZNAS, TDCZNAS, TDCZNAS, TDCZNAS, + TDCZPAC, + TDCZPAS, TDCZPAS, TDCZPAS, TDCZPAS, TDCZPAS, + TDCZEM1, + TDCZEM2, + TDCZNCC, + TDCZNCS, TDCZNCS, TDCZNCS, TDCZNCS, TDCZNCS, + TDCZPCC, + TDCZPCS, TDCZPCS, TDCZPCS, TDCZPCS, TDCZPCS}; + constexpr int DbgZero = 0; constexpr int DbgMinimal = 1; constexpr int DbgMedium = 2; diff --git a/Detectors/ZDC/calib/CMakeLists.txt b/Detectors/ZDC/calib/CMakeLists.txt index 18dcb934ec268..43c7b565ff71a 100644 --- a/Detectors/ZDC/calib/CMakeLists.txt +++ b/Detectors/ZDC/calib/CMakeLists.txt @@ -17,6 +17,8 @@ o2_add_library(ZDCCalib src/InterCalibEPN.cxx src/InterCalibEPNSpec.cxx src/WaveformCalibConfig.cxx + src/WaveformCalibEPN.cxx + src/WaveformCalibQueue.cxx PUBLIC_LINK_LIBRARIES O2::CCDB O2::DPLUtils @@ -40,7 +42,9 @@ o2_target_root_dictionary(ZDCCalib include/ZDCCalib/InterCalibSpec.h include/ZDCCalib/InterCalibEPN.h include/ZDCCalib/InterCalibEPNSpec.h - include/ZDCCalib/WaveformCalibConfig.h) + include/ZDCCalib/WaveformCalibConfig.h + include/ZDCCalib/WaveformCalibEPN.h + include/ZDCCalib/WaveformCalibQueue.h) o2_add_executable(intercalib-workflow COMPONENT_NAME zdc diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h new file mode 100644 index 0000000000000..252a0051eab1b --- /dev/null +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h @@ -0,0 +1,44 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#ifndef ZDC_WAVEFORMCALIB_QUEUE_H +#define ZDC_WAVEFORMCALIB_QUEUE_H + +#include "CommonDataFormat/InteractionRecord.h" +#include "ZDCBase/Constants.h" +#include "DataFormatsZDC/BCData.h" +#include "DataFormatsZDC/ChannelData.h" +#include "DataFormatsZDC/OrbitData.h" +#include "DataFormatsZDC/RecEvent.h" +#include "DataFormatsZDC/RecEventAux.h" +#include "ZDCCalib/WaveformCalibConfig.h" +#include + +/// \file WaveformCalibQueue.h +/// \brief Waveform calibration intermediate data queue +/// \author pietro.cortese@cern.ch + +namespace o2 +{ +namespace zdc +{ + +struct WaveformCalibQueue { + static constexpr int NH = WaveformCalibConfig::NH; + std::queue mIR; + int append(const RecEventAux &ev); + int appendEv(const RecEventAux &ev); +}; + +} // namespace zdc +} // namespace o2 + +#endif diff --git a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx index 1c6a7b866d648..0443fab682552 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx @@ -9,6 +9,7 @@ // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. +#include #include #include #include @@ -50,38 +51,60 @@ int WaveformCalibEPN::process(const gsl::span& RecBC, if (!mInitDone) { init(); } - LOG(info) << "o2::zdc::WaveformCalibEPN processing " << RecBC.size() << " b.c. @ TS " << mData.mCTimeBeg << " : " << mData.mCTimeEnd; + //slot.getStartTimeMS() and slot.getEndTimeMS() + //LOG(info) << "o2::zdc::WaveformCalibEPN processing " << RecBC.size() << " b.c. @ TS " << mData.mCTimeBeg << " : " << mData.mCTimeEnd; o2::zdc::RecEventFlat ev; ev.init(RecBC, Energy, TDCData, Info); - while (ev.next()) { + auto nen = ev.getEntries(); + std::vector ir; + /* + std::array hasInfos[NTDCChannels]; + std::array ntdc[NTDCChannels]; + std::array tdca[NTDCChannels]; + std::array tdcp[NTDCChannels]; + while (int ientry = ev.next()) { + ir[ientry] = ev.ir; if (ev.getNInfo() > 0) { + // Need clean data (no messages) + // We are sure there is no pile-up in any channel (too restrictive?) auto& decodedInfo = ev.getDecodedInfo(); for (uint16_t info : decodedInfo) { uint8_t ch = (info >> 10) & 0x1f; uint16_t code = info & 0x03ff; - // hmsg->Fill(ch, code); + hasInfos[SignalTDC[ch]][ientry] = true; } if (mVerbosity > DbgMinimal) { ev.print(); } - // Need clean data (no messages) - // We are sure there is no pile-up in any channel (too restrictive?) continue; } - // Analyze TDC - + // NOTE: for the moment NH = NTDCChannels. If we remove this we will need to + // have a mask of affected channels (towers) + for (int32_t itdc = 0; itdc < NTDCChannels; itdc++) { + int ich = o2::zdc::TDCSignal[itdc]; + int nhit = ev.NtdcV(itdc); + ntdc[itdc][ientry] = nhit; + if (ev.NtdcA(itdc) != nhit) { + fprintf(stderr, "Mismatch in TDC %d data Val=%d Amp=%d\n", itdc, ev.NtdcV(itdc), ev.NtdcA(ich)); + continue; + } + // Store just first TDC entry + tdca[itdc][ientry] = o2::zdc::FTDCAmp * ev.TDCAmp[itdc][0]; + tdcp[itdc][ientry] = o2::zdc::FTDCVal * ev.TDCVal[itdc][0]; + } } + */ return 0; } int WaveformCalibEPN::endOfRun() { - if (mVerbosity > DbgZero) { - LOGF(info, "WaveformCalibEPN::endOfRun ts (%llu:%llu)", mData.mCTimeBeg, mData.mCTimeEnd); - for (int ih = 0; ih < NH; ih++) { - LOGF(info, "%s %g events and cuts (%g:%g)", WaveformCalibData::DN[ih], mData.mSum[ih][5][5], mWaveformCalibConfig->cutLow[ih], mWaveformCalibConfig->cutHigh[ih]); - } - } +// if (mVerbosity > DbgZero) { +// LOGF(info, "WaveformCalibEPN::endOfRun ts (%llu:%llu)", mData.mCTimeBeg, mData.mCTimeEnd); +// for (int ih = 0; ih < NH; ih++) { +// LOGF(info, "%s %g events and cuts (%g:%g)", WaveformCalibData::DN[ih], mData.mSum[ih][5][5], mWaveformCalibConfig->cutLow[ih], mWaveformCalibConfig->cutHigh[ih]); +// } +// } if (mSaveDebugHistos) { write(); } @@ -90,6 +113,7 @@ int WaveformCalibEPN::endOfRun() int WaveformCalibEPN::write(const std::string fn) { +/* TDirectory* cwd = gDirectory; TFile* f = new TFile(fn.data(), "recreate"); if (f->IsZombie()) { @@ -112,5 +136,6 @@ int WaveformCalibEPN::write(const std::string fn) } f->Close(); cwd->cd(); +*/ return 0; } diff --git a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx new file mode 100644 index 0000000000000..ac10622bdee10 --- /dev/null +++ b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx @@ -0,0 +1,39 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#include "Framework/Logger.h" +#include "ZDCCalib/WaveformCalibQueue.h" + +namespace o2 +{ +namespace zdc +{ + +int WaveformCalibQueue::append(const RecEventAux& ev) +{ + // If queue is empty insert event + if(mIR.size()==0){ + return appendEv(ev); + } + // If queue is not empty and is too long remove first element + // Check last element + // If BC are not consecutive, clear queue and then append element + // IF BC are consecutive append element +} + +int WaveformCalibQueue::appendEv(const RecEventAux& ev) +{ + mIR.push(ev.ir); + return mIR.size(); +} + +} // namespace zdc +} // namespace o2 From b5b2b689595db286bd706a0105a7333e4e1a3d20 Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Mon, 9 May 2022 17:30:34 +0200 Subject: [PATCH 05/40] WIP --- .../include/ZDCCalib/WaveformCalibEPNSpec.h | 56 +++++++++++++++++++ .../include/ZDCCalib/WaveformCalibQueue.h | 14 +++++ .../ZDC/calib/src/WaveformCalibQueue.cxx | 6 ++ 3 files changed, 76 insertions(+) create mode 100644 Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPNSpec.h diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPNSpec.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPNSpec.h new file mode 100644 index 0000000000000..e70be3b043b51 --- /dev/null +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPNSpec.h @@ -0,0 +1,56 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// @file InterCalibEPNSpec.h +/// @brief ZDC intercalibration pre-processing on EPN +/// @author pietro.cortese@cern.ch + +#ifndef O2_ZDC_WAVEFORMCALIBEPN_SPEC +#define O2_ZDC_WAVEFORMCALIBEPN_SPEC + +#include +#include "Framework/Logger.h" +#include "Framework/DataProcessorSpec.h" +#include "Framework/Task.h" +#include "CommonUtils/NameConf.h" +#include "DataFormatsZDC/WaveformCalibData.h" +#include "ZDCCalib/WaveformCalibEPN.h" +#include "ZDCCalib/WaveformCalibConfig.h" + +namespace o2 +{ +namespace zdc +{ + +class WaveformCalibEPNSpec : public o2::framework::Task +{ + public: + WaveformCalibEPNSpec(); + WaveformCalibEPNSpec(const int verbosity); + ~WaveformCalibEPNSpec() override = default; + void init(o2::framework::InitContext& ic) final; + void updateTimeDependentParams(o2::framework::ProcessingContext& pc); + void run(o2::framework::ProcessingContext& pc) final; + void endOfStream(o2::framework::EndOfStreamContext& ec) final; + + private: + int mVerbosity = 0; // Verbosity level + bool mInitialized = false; // Connect once to CCDB during initialization + WaveformCalibEPN mWaveformCalibEPN; // Waveform calibration object + TStopwatch mTimer; +}; + +framework::DataProcessorSpec getWaveformCalibEPNSpec(); + +} // namespace zdc +} // namespace o2 + +#endif diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h index 252a0051eab1b..b0844b4f3d7d0 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h @@ -32,7 +32,21 @@ namespace zdc { struct WaveformCalibQueue { + WaveformCalibQueue(int ifirst, int ilast){ + configure(ifirst, ilast); + } static constexpr int NH = WaveformCalibConfig::NH; + int mFirst=0; + int mLast=0; + int mN=1; + void configure(int ifirst, int ilast){ + if(ifirst>0 || ilast<0 || ilast mIR; int append(const RecEventAux &ev); int appendEv(const RecEventAux &ev); diff --git a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx index ac10622bdee10..607536a659f4b 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx @@ -24,6 +24,11 @@ int WaveformCalibQueue::append(const RecEventAux& ev) return appendEv(ev); } // If queue is not empty and is too long remove first element + while(mIR.size()>mN){ + auto &todel = mIR.front(); + LOG(info) << __func__ << " delete " << ev.ir.orbit << "." << ev.ir.bc; + mIR.pop(); + } // Check last element // If BC are not consecutive, clear queue and then append element // IF BC are consecutive append element @@ -31,6 +36,7 @@ int WaveformCalibQueue::append(const RecEventAux& ev) int WaveformCalibQueue::appendEv(const RecEventAux& ev) { + LOG(info) << __func__ << " " << ev.ir.orbit << "." << ev.ir.bc; mIR.push(ev.ir); return mIR.size(); } From 7e036008dfd0896c3db72e7e3d20ab9bb1c84b4e Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Mon, 9 May 2022 18:50:25 +0200 Subject: [PATCH 06/40] WIP --- .../ZDC/include/DataFormatsZDC/WaveformCalibData.h | 6 +++--- Detectors/ZDC/base/include/ZDCBase/Constants.h | 1 + Detectors/ZDC/calib/CMakeLists.txt | 7 +++++++ .../ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h | 9 ++++++--- .../ZDC/calib/include/ZDCCalib/WaveformCalibEPNSpec.h | 6 +++--- Detectors/ZDC/calib/src/WaveformCalibQueue.cxx | 11 +++++++++-- 6 files changed, 29 insertions(+), 11 deletions(-) diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/WaveformCalibData.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/WaveformCalibData.h index c953d44d47531..b63f3824f14c8 100644 --- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/WaveformCalibData.h +++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/WaveformCalibData.h @@ -9,8 +9,8 @@ // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. -#ifndef ZDC_WAVEFORMCALIB_DATA_H_ -#define ZDC_WAVEFORMCALIB_DATA_H_ +#ifndef ZDC_WAVEFORMCALIB_DATA_H +#define ZDC_WAVEFORMCALIB_DATA_H #include "ZDCBase/Constants.h" #include "ZDCCalib/WaveformCalibConfig.h" @@ -31,7 +31,7 @@ struct WaveformCalibData { uint64_t mCTimeBeg = 0; /// Time of processed time frame uint64_t mCTimeEnd = 0; /// Time of processed time frame std::array mWave[NH]; - mEntries[NH] = {0}; + uint32_t mEntries[NH] = {0}; WaveformCalibData& operator+=(const WaveformCalibData& other); int getEntries(int ih) const; void print() const; diff --git a/Detectors/ZDC/base/include/ZDCBase/Constants.h b/Detectors/ZDC/base/include/ZDCBase/Constants.h index 71ad8cf40e728..c9e9bd73bb385 100644 --- a/Detectors/ZDC/base/include/ZDCBase/Constants.h +++ b/Detectors/ZDC/base/include/ZDCBase/Constants.h @@ -254,6 +254,7 @@ const std::string CCDBPathTDCCorr = "ZDC/Calib/TDCCorr"; const std::string CCDBPathEnergyCalib = "ZDC/Calib/EnergyCalib"; const std::string CCDBPathTowerCalib = "ZDC/Calib/TowerCalib"; const std::string CCDBPathInterCalibConfig = "ZDC/Calib/InterCalibConfig"; +const std::string CCDBPathWaveformCalibConfig = "ZDC/Calib/WaveformCalibConfig"; enum Ped { PedND = 0, PedEv = 1, diff --git a/Detectors/ZDC/calib/CMakeLists.txt b/Detectors/ZDC/calib/CMakeLists.txt index 43c7b565ff71a..5f0f5efb14714 100644 --- a/Detectors/ZDC/calib/CMakeLists.txt +++ b/Detectors/ZDC/calib/CMakeLists.txt @@ -18,6 +18,7 @@ o2_add_library(ZDCCalib src/InterCalibEPNSpec.cxx src/WaveformCalibConfig.cxx src/WaveformCalibEPN.cxx + src/WaveformCalibEPNSpec.cxx src/WaveformCalibQueue.cxx PUBLIC_LINK_LIBRARIES O2::CCDB @@ -44,6 +45,7 @@ o2_target_root_dictionary(ZDCCalib include/ZDCCalib/InterCalibEPNSpec.h include/ZDCCalib/WaveformCalibConfig.h include/ZDCCalib/WaveformCalibEPN.h + include/ZDCCalib/WaveformCalibEPNSpec.h include/ZDCCalib/WaveformCalibQueue.h) o2_add_executable(intercalib-workflow @@ -55,3 +57,8 @@ o2_add_executable(intercalib-epn-workflow COMPONENT_NAME zdc SOURCES src/zdc-intercalib-epn-workflow.cxx PUBLIC_LINK_LIBRARIES O2::ZDCWorkflow O2::ZDCCalib O2::DetectorsCalibration) + +o2_add_executable(waveformcalib-epn-workflow + COMPONENT_NAME zdc + SOURCES src/zdc-waveformcalib-epn-workflow.cxx + PUBLIC_LINK_LIBRARIES O2::ZDCWorkflow O2::ZDCCalib O2::DetectorsCalibration) diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h index c0f2486b57179..fc62c5e20e884 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h @@ -20,10 +20,11 @@ #include "CommonDataFormat/FlatHisto1D.h" #include "CommonDataFormat/FlatHisto2D.h" #include "DataFormatsZDC/RecEvent.h" +#include "DataFormatsZDC/WaveformCalibData.h" +#include "DataFormatsZDC/ZDCWaveform.h" #include "ZDCReconstruction/ZDCEnergyParam.h" #include "ZDCReconstruction/ZDCTowerParam.h" #include "ZDCCalib/WaveformCalibConfig.h" -#include "DataFormatsZDC/ZDCWaveform.h" #ifndef ALICEO2_ZDC_WAVEFORMCALIBEPN_H_ #define ALICEO2_ZDC_WAVEFORMCALIBEPN_H_ namespace o2 @@ -44,11 +45,13 @@ class WaveformCalibEPN const gsl::span& wave); int endOfRun(); int write(const std::string fn = "ZDCWaveformCalibEPN.root"); - void setWaveformCalibConfig(const WaveformCalibConfig* param) { mWaveformCalibConfig = param; }; - const WaveformCalibConfig* getWaveformCalibConfig() const { return mWaveformCalibConfig; }; + void setConfig(const WaveformCalibConfig* param) { mWaveformCalibConfig = param; }; + const WaveformCalibConfig* getConfig() const { return mWaveformCalibConfig; }; void setSaveDebugHistos() { mSaveDebugHistos = true; } void setDontSaveDebugHistos() { mSaveDebugHistos = false; } std::array*, NH> mH{}; + WaveformCalibData mData; + WaveformCalibData& getData() { return mData; } private: bool mInitDone = false; diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPNSpec.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPNSpec.h index e70be3b043b51..4fedec7184f6e 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPNSpec.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPNSpec.h @@ -42,9 +42,9 @@ class WaveformCalibEPNSpec : public o2::framework::Task void endOfStream(o2::framework::EndOfStreamContext& ec) final; private: - int mVerbosity = 0; // Verbosity level - bool mInitialized = false; // Connect once to CCDB during initialization - WaveformCalibEPN mWaveformCalibEPN; // Waveform calibration object + int mVerbosity = 0; // Verbosity level + bool mInitialized = false; // Connect once to CCDB during initialization + WaveformCalibEPN mWorker; // Waveform calibration object TStopwatch mTimer; }; diff --git a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx index 607536a659f4b..fa6bc50ecf439 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx @@ -19,19 +19,26 @@ namespace zdc int WaveformCalibQueue::append(const RecEventAux& ev) { + auto &toadd ev.ir; // If queue is empty insert event if(mIR.size()==0){ return appendEv(ev); } // If queue is not empty and is too long remove first element - while(mIR.size()>mN){ + while(mIR.size()>=mN){ auto &todel = mIR.front(); - LOG(info) << __func__ << " delete " << ev.ir.orbit << "." << ev.ir.bc; + LOG(info) << __func__ << " delete " << todel.orbit << "." << todel.bc; mIR.pop(); + LOG(info) << __func__ << " size " << mIR.size(); } // Check last element + auto &last = mIR.back(); // If BC are not consecutive, clear queue and then append element + if(toadd.differenceInBC(last)>1){ + mIR.clear(); + } // IF BC are consecutive append element + return appendEv(ev); } int WaveformCalibQueue::appendEv(const RecEventAux& ev) From 96003d064764889c86cbdc13fb63f1124ff6c13c Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Tue, 10 May 2022 18:34:13 +0200 Subject: [PATCH 07/40] WIP --- .../ZDC/include/DataFormatsZDC/BCRecData.h | 20 ++++ .../ZDC/include/DataFormatsZDC/RecEventAux.h | 2 +- .../ZDC/include/DataFormatsZDC/RecEventFlat.h | 12 +- .../Detectors/ZDC/src/RecEventFlat.cxx | 6 + .../calib/include/ZDCCalib/WaveformCalibEPN.h | 22 +++- .../include/ZDCCalib/WaveformCalibQueue.h | 76 +++++++++--- .../ZDC/calib/src/WaveformCalibConfig.cxx | 4 +- Detectors/ZDC/calib/src/WaveformCalibEPN.cxx | 103 +++++++---------- .../ZDC/calib/src/WaveformCalibQueue.cxx | 109 +++++++++++++++--- .../ZDC/macro/CreateWaveformCalibConfig.C | 5 +- Detectors/ZDC/reconstruction/src/DigiReco.cxx | 1 - Detectors/ZDC/workflow/src/DigitRecoSpec.cxx | 9 +- .../ZDC/workflow/src/ZDCRecoWriterDPLSpec.cxx | 2 +- 13 files changed, 259 insertions(+), 112 deletions(-) diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/BCRecData.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/BCRecData.h index d06b1e7fb3b1c..c4417c73a9707 100644 --- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/BCRecData.h +++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/BCRecData.h @@ -112,6 +112,26 @@ struct BCRecData { ni = refi.getEntries(); nw = refw.getEntries(); } + inline void getRefE(int& firste, int& ne) + { + firste = refe.getFirstEntry(); + ne = refe.getEntries(); + } + inline void getRefT(int& firstt, int& nt) + { + firstt = reft.getFirstEntry(); + nt = reft.getEntries(); + } + inline void getRefI(int& firsti, int& ni) + { + firsti = refi.getFirstEntry(); + ni = refi.getEntries(); + } + inline void getRefW(int& firstw, int& nw) + { + firstw = refw.getFirstEntry(); + nw = refw.getEntries(); + } void print() const; diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventAux.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventAux.h index 42fb8fef88a95..b065807485ee8 100644 --- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventAux.h +++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventAux.h @@ -31,7 +31,7 @@ namespace zdc { struct RecEventAux : public RecEventFlat { - uint32_t flags; /// Pattern of available data + uint32_t flags; #ifdef O2_ZDC_TDC_C_ARRAY int16_t tdcVal[NTDCChannels][MaxTDCValues]; /// TdcValues (encoded) int16_t tdcAmp[NTDCChannels][MaxTDCValues]; /// TdcAmplitudes (encoded) diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventFlat.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventFlat.h index 826a6a164744a..f348688266aa4 100644 --- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventFlat.h +++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventFlat.h @@ -63,7 +63,7 @@ struct RecEventFlat { // NOLINT: false positive in clang-tidy !! NElem mNI = 0; //! N info std::array isBeg{}; //! Beginning of sequence std::array isEnd{}; //! End of sequence - o2::zdc::BCRecData mCurB; //! Current BC + BCRecData mCurB; //! Current BC // Reconstruction messages std::array genericE{}; /// 0 Generic error @@ -99,12 +99,22 @@ struct RecEventFlat { // NOLINT: false positive in clang-tidy !! void init(const gsl::span RecBC, const gsl::span Energy, const gsl::span TDCData, const gsl::span Info); int next(); + int at(int ientry); + + BCRecData& getCurB(){ + return mCurB; + } inline int getEntries() const { return mNEntries; } + inline int getNextEntry() const + { + return mEntry; + } + inline NElem getNEnergy() const { return mNE; diff --git a/DataFormats/Detectors/ZDC/src/RecEventFlat.cxx b/DataFormats/Detectors/ZDC/src/RecEventFlat.cxx index 440edff22f27a..7c9d50c3d61eb 100644 --- a/DataFormats/Detectors/ZDC/src/RecEventFlat.cxx +++ b/DataFormats/Detectors/ZDC/src/RecEventFlat.cxx @@ -65,6 +65,12 @@ void RecEventFlat::clearBitmaps() int RecEventFlat::next() { + return at(mEntry); +} + +int RecEventFlat::at(int ientry) +{ + mEntry = ientry; ezdcDecoded = 0; if (mEntry >= mNEntries) { return 0; diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h index fc62c5e20e884..27e58fd5e2d89 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h @@ -25,8 +25,9 @@ #include "ZDCReconstruction/ZDCEnergyParam.h" #include "ZDCReconstruction/ZDCTowerParam.h" #include "ZDCCalib/WaveformCalibConfig.h" -#ifndef ALICEO2_ZDC_WAVEFORMCALIBEPN_H_ -#define ALICEO2_ZDC_WAVEFORMCALIBEPN_H_ +#include "ZDCCalib/WaveformCalibQueue.h" +#ifndef ALICEO2_ZDC_WAVEFORMCALIBEPN_H +#define ALICEO2_ZDC_WAVEFORMCALIBEPN_H namespace o2 { namespace zdc @@ -59,6 +60,23 @@ class WaveformCalibEPN int32_t mNBin = 0; int32_t mVerbosity = DbgMinimal; const WaveformCalibConfig* mWaveformCalibConfig = nullptr; /// Configuration of intercalibration + + int mFirst=0; + int mLast=0; + int mN=1; + + void configure(int ifirst, int ilast){ + if(ifirst>0 || ilast<0 || ilast +#include /// \file WaveformCalibQueue.h /// \brief Waveform calibration intermediate data queue @@ -32,24 +32,68 @@ namespace zdc { struct WaveformCalibQueue { - WaveformCalibQueue(int ifirst, int ilast){ + static constexpr int NH = WaveformCalibConfig::NH; + WaveformCalibQueue() = default; + WaveformCalibQueue(int ifirst, int ilast) + { configure(ifirst, ilast); } - static constexpr int NH = WaveformCalibConfig::NH; - int mFirst=0; - int mLast=0; - int mN=1; - void configure(int ifirst, int ilast){ - if(ifirst>0 || ilast<0 || ilast 0 || ilast < 0 || ilast < ifirst) { + LOGF(fatal, "WaveformCalibQueue configure error with ifirst=%d ilast=%d", ifirst, ilast); + } + mFirst = ifirst; + mLast = ilast; + mN = ilast - ifirst + 1; + mPk = -mFirst; + } + std::deque mIR; + std::deque mEntry; + std::deque mHasInfos[NH]; + std::deque mNTDC[NTDCChannels]; + std::deque mTDCA[NTDCChannels]; + std::deque mTDCP[NTDCChannels]; + std::deque mFirstW; + std::deque mNW; + void clear() + { + LOG(info) << __func__; + mIR.clear(); + mEntry.clear(); + for (int ih = 0; ih < NH; ih++) { + mHasInfos[ih].clear(); + } + for (int itdc = 0; itdc < NTDCChannels; itdc++) { + mNTDC[itdc].clear(); + mTDCA[itdc].clear(); + mTDCP[itdc].clear(); + } + mFirstW.clear(); + mNW.clear(); + } + void pop() + { + LOG(info) << __func__; + mIR.pop_front(); + mEntry.pop_front(); + for (int ih = 0; ih < NH; ih++) { + mHasInfos[ih].pop_front(); + } + for (int itdc = 0; itdc < NTDCChannels; itdc++) { + mNTDC[itdc].pop_front(); + mTDCA[itdc].pop_front(); + mTDCP[itdc].pop_front(); } - mFirst=ifirst; - mLast=ilast; - mN=ilast-ifirst+1; + mFirstW.pop_front(); + mNW.pop_front(); } - std::queue mIR; - int append(const RecEventAux &ev); - int appendEv(const RecEventAux &ev); + uint32_t append(RecEventFlat& ev); + void appendEv(RecEventFlat& ev); }; } // namespace zdc diff --git a/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx b/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx index db694f9d7c7bb..7b159cb94fd4f 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx @@ -25,12 +25,12 @@ void WaveformCalibConfig::restrictRange(int ib, int ie) { ibeg = -NBB; iend = NBA; - if (ib >= ibeg && ib < 0) { + if (ib >= ibeg && ib <= 0) { ibeg = ib; } else { LOG(fatal) << __func__ << " wrong setting for ibeg = " << ib; } - if (ie <= iend && ie > 0) { + if (ie <= iend && ie >= 0) { iend = ie; } else { LOG(fatal) << __func__ << " wrong setting for iend = " << ie; diff --git a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx index 0443fab682552..dfcab897fcd65 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx @@ -35,6 +35,8 @@ int WaveformCalibEPN::init() // number of bins mNBin = cfg->nbun * TSN; + mFirst = cfg->ibeg; + mLast = cfg->iend; for (int ih = 0; ih < NH; ih++) { mH[ih] = new o2::dataformats::FlatHisto1D(mNBin, 0, mNBin); } @@ -51,60 +53,35 @@ int WaveformCalibEPN::process(const gsl::span& RecBC, if (!mInitDone) { init(); } - //slot.getStartTimeMS() and slot.getEndTimeMS() - //LOG(info) << "o2::zdc::WaveformCalibEPN processing " << RecBC.size() << " b.c. @ TS " << mData.mCTimeBeg << " : " << mData.mCTimeEnd; + mQueue.configure(mFirst, mLast); o2::zdc::RecEventFlat ev; ev.init(RecBC, Energy, TDCData, Info); auto nen = ev.getEntries(); std::vector ir; - /* - std::array hasInfos[NTDCChannels]; - std::array ntdc[NTDCChannels]; - std::array tdca[NTDCChannels]; - std::array tdcp[NTDCChannels]; while (int ientry = ev.next()) { - ir[ientry] = ev.ir; - if (ev.getNInfo() > 0) { - // Need clean data (no messages) - // We are sure there is no pile-up in any channel (too restrictive?) - auto& decodedInfo = ev.getDecodedInfo(); - for (uint16_t info : decodedInfo) { - uint8_t ch = (info >> 10) & 0x1f; - uint16_t code = info & 0x03ff; - hasInfos[SignalTDC[ch]][ientry] = true; - } - if (mVerbosity > DbgMinimal) { - ev.print(); - } - continue; - } - // NOTE: for the moment NH = NTDCChannels. If we remove this we will need to - // have a mask of affected channels (towers) - for (int32_t itdc = 0; itdc < NTDCChannels; itdc++) { - int ich = o2::zdc::TDCSignal[itdc]; - int nhit = ev.NtdcV(itdc); - ntdc[itdc][ientry] = nhit; - if (ev.NtdcA(itdc) != nhit) { - fprintf(stderr, "Mismatch in TDC %d data Val=%d Amp=%d\n", itdc, ev.NtdcV(itdc), ev.NtdcA(ich)); - continue; + uint32_t mask = mQueue.append(ev); + if (mask != 0) { + // Analyze signals that refer to the TDC channels that satisfy condition + // For the moment this is the same as for the TDCs + for (int itdc = 0; itdc < NTDCChannels; itdc++) { + if ((mask & (0x1 << itdc)) != 0) { + // Check which channels have consecutive data + int isig = TDCSignal[itdc]; + } } - // Store just first TDC entry - tdca[itdc][ientry] = o2::zdc::FTDCAmp * ev.TDCAmp[itdc][0]; - tdcp[itdc][ientry] = o2::zdc::FTDCVal * ev.TDCVal[itdc][0]; } } - */ return 0; } int WaveformCalibEPN::endOfRun() { -// if (mVerbosity > DbgZero) { -// LOGF(info, "WaveformCalibEPN::endOfRun ts (%llu:%llu)", mData.mCTimeBeg, mData.mCTimeEnd); -// for (int ih = 0; ih < NH; ih++) { -// LOGF(info, "%s %g events and cuts (%g:%g)", WaveformCalibData::DN[ih], mData.mSum[ih][5][5], mWaveformCalibConfig->cutLow[ih], mWaveformCalibConfig->cutHigh[ih]); -// } -// } + // if (mVerbosity > DbgZero) { + // LOGF(info, "WaveformCalibEPN::endOfRun ts (%llu:%llu)", mData.mCTimeBeg, mData.mCTimeEnd); + // for (int ih = 0; ih < NH; ih++) { + // LOGF(info, "%s %g events and cuts (%g:%g)", WaveformCalibData::DN[ih], mData.mSum[ih][5][5], mWaveformCalibConfig->cutLow[ih], mWaveformCalibConfig->cutHigh[ih]); + // } + // } if (mSaveDebugHistos) { write(); } @@ -113,29 +90,29 @@ int WaveformCalibEPN::endOfRun() int WaveformCalibEPN::write(const std::string fn) { -/* - TDirectory* cwd = gDirectory; - TFile* f = new TFile(fn.data(), "recreate"); - if (f->IsZombie()) { - LOG(error) << "Cannot create file: " << fn; - return 1; - } - for (int32_t ih = 0; ih < (2 * NH); ih++) { - if (mH[ih]) { - auto p = mH[ih]->createTH1F(WaveformCalib::mHUncN[ih]); - p->SetTitle(WaveformCalib::mHUncT[ih]); - p->Write("", TObject::kOverwrite); + /* + TDirectory* cwd = gDirectory; + TFile* f = new TFile(fn.data(), "recreate"); + if (f->IsZombie()) { + LOG(error) << "Cannot create file: " << fn; + return 1; } - } - for (int32_t ih = 0; ih < NH; ih++) { - if (mC[ih]) { - auto p = mC[ih]->createTH2F(WaveformCalib::mCUncN[ih]); - p->SetTitle(WaveformCalib::mCUncT[ih]); - p->Write("", TObject::kOverwrite); + for (int32_t ih = 0; ih < (2 * NH); ih++) { + if (mH[ih]) { + auto p = mH[ih]->createTH1F(WaveformCalib::mHUncN[ih]); + p->SetTitle(WaveformCalib::mHUncT[ih]); + p->Write("", TObject::kOverwrite); + } } - } - f->Close(); - cwd->cd(); -*/ + for (int32_t ih = 0; ih < NH; ih++) { + if (mC[ih]) { + auto p = mC[ih]->createTH2F(WaveformCalib::mCUncN[ih]); + p->SetTitle(WaveformCalib::mCUncT[ih]); + p->Write("", TObject::kOverwrite); + } + } + f->Close(); + cwd->cd(); + */ return 0; } diff --git a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx index fa6bc50ecf439..707cf74a08493 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx @@ -17,35 +17,106 @@ namespace o2 namespace zdc { -int WaveformCalibQueue::append(const RecEventAux& ev) +uint32_t WaveformCalibQueue::append(RecEventFlat& ev) { - auto &toadd ev.ir; + auto& toadd = ev.ir; // If queue is empty insert event - if(mIR.size()==0){ - return appendEv(ev); + if (mIR.size() == 0) { + appendEv(ev); + return 0; + } + // Check last element + auto& last = mIR.back(); + // If BC are not consecutive, clear queue + if (toadd.differenceInBC(last) > 1) { + clear(); } // If queue is not empty and is too long remove first element - while(mIR.size()>=mN){ - auto &todel = mIR.front(); - LOG(info) << __func__ << " delete " << todel.orbit << "." << todel.bc; - mIR.pop(); - LOG(info) << __func__ << " size " << mIR.size(); + while (mIR.size() >= mN) { + pop(); } - // Check last element - auto &last = mIR.back(); - // If BC are not consecutive, clear queue and then append element - if(toadd.differenceInBC(last)>1){ - mIR.clear(); + // If BC are consecutive or cleared queue append element + appendEv(ev); + if (mIR.size() == mN) { + uint32_t mask = 0; + for (int32_t itdc = 0; itdc < NTDCChannels; itdc++) { + // Check which channels satisfy the condition on TDC + bool tdccond = true; + for(int i = 0; i 0) { + // Need clean data (no messages) + // We are sure there is no pile-up in any channel (too restrictive?) + auto& decodedInfo = ev.getDecodedInfo(); + for (uint16_t info : decodedInfo) { + uint8_t ch = (info >> 10) & 0x1f; + uint16_t code = info & 0x03ff; + auto& last = mHasInfos[SignalTDC[ch]].back(); + last = true; + } + // if (mVerbosity > DbgMinimal) { + // ev.print(); + // } + } + // NOTE: for the moment NH = NTDCChannels. If we remove this we will need to + // have a mask of affected channels (towers) + for (int32_t itdc = 0; itdc < NTDCChannels; itdc++) { + int ich = o2::zdc::TDCSignal[itdc]; + int nhit = ev.NtdcV(itdc); + if (ev.NtdcA(itdc) != nhit) { + LOGF(error, "Mismatch in TDC %d data Val=%d Amp=%d\n", itdc, ev.NtdcV(itdc), ev.NtdcA(ich)); + mNTDC[itdc].push_back(0); + mTDCA[itdc].push_back(0); + mTDCP[itdc].push_back(0); + } else if (nhit == 0) { + mNTDC[itdc].push_back(0); + mTDCA[itdc].push_back(0); + mTDCP[itdc].push_back(0); + } else { + // Store single TDC entry + mNTDC[itdc].push_back(nhit); + mTDCA[itdc].push_back(ev.tdcA(itdc, 0)); + mTDCP[itdc].push_back(ev.tdcV(itdc, 0)); + } + } } } // namespace zdc diff --git a/Detectors/ZDC/macro/CreateWaveformCalibConfig.C b/Detectors/ZDC/macro/CreateWaveformCalibConfig.C index c0bdd2ab2bfd7..2d9977e144eba 100644 --- a/Detectors/ZDC/macro/CreateWaveformCalibConfig.C +++ b/Detectors/ZDC/macro/CreateWaveformCalibConfig.C @@ -41,6 +41,9 @@ void CreateWaveformCalibConfig(long tmin = 0, long tmax = -1, std::string ccdbHo conf.setDescription("Simulated data"); conf.setMinEntries(200); + // Restrict waveform range + conf.restrictRange(-1,0); + conf.print(); o2::ccdb::CcdbApi api; @@ -57,7 +60,7 @@ void CreateWaveformCalibConfig(long tmin = 0, long tmax = -1, std::string ccdbHo api.init(ccdbHost.c_str()); LOG(info) << "CCDB server: " << api.getURL(); // store abitrary user object in strongly typed manner - api.storeAsTFileAny(&conf, CCDBPathInterCalibConfig, metadata, tmin, tmax); + api.storeAsTFileAny(&conf, CCDBPathWaveformCalibConfig, metadata, tmin, tmax); // return conf; } diff --git a/Detectors/ZDC/reconstruction/src/DigiReco.cxx b/Detectors/ZDC/reconstruction/src/DigiReco.cxx index 04f9743e46d6c..8efa4d96e1380 100644 --- a/Detectors/ZDC/reconstruction/src/DigiReco.cxx +++ b/Detectors/ZDC/reconstruction/src/DigiReco.cxx @@ -1193,7 +1193,6 @@ void DigiReco::interpolate(int itdc, int ibeg, int iend) if (ref == ZDCRefInitVal) { LOG(fatal) << "Missing information for bunch crossing"; } - mReco[ibun].flags = mReco[ibun].flags | (0x1< 1 && (nt > 0 || ne > 0)) { - printf("Orbit %9u bc %4u ntdc %2d ne %2d\n", reca.ir.orbit, reca.ir.bc, nt, ne); + printf("Orbit %9u bc %4u ntdc %2d ne %2d channels=0x%08x\n", reca.ir.orbit, reca.ir.bc, nt, ne, reca.channels); } // Event information nti += recEvent.addInfos(reca); @@ -234,7 +233,7 @@ void DigitRecoSpec::run(ProcessingContext& pc) pc.outputs().snapshot(Output{"ZDC", "ENERGY", 0, Lifetime::Timeframe}, recEvent.mEnergy); pc.outputs().snapshot(Output{"ZDC", "TDCDATA", 0, Lifetime::Timeframe}, recEvent.mTDCData); pc.outputs().snapshot(Output{"ZDC", "INFO", 0, Lifetime::Timeframe}, recEvent.mInfo); - pc.outputs().snapshot(Output{"ZDC", "WAVEFORM", 0, Lifetime::Timeframe}, recEvent.mWaveform); + pc.outputs().snapshot(Output{"ZDC", "WAVE", 0, Lifetime::Timeframe}, recEvent.mWaveform); mTimer.Stop(); } @@ -257,7 +256,7 @@ framework::DataProcessorSpec getDigitRecoSpec(const int verbosity = 0, const boo outputs.emplace_back("ZDC", "ENERGY", 0, Lifetime::Timeframe); outputs.emplace_back("ZDC", "TDCDATA", 0, Lifetime::Timeframe); outputs.emplace_back("ZDC", "INFO", 0, Lifetime::Timeframe); - outputs.emplace_back("ZDC", "WAVEFORM", 0, Lifetime::Timeframe); + outputs.emplace_back("ZDC", "WAVE", 0, Lifetime::Timeframe); return DataProcessorSpec{ "zdc-digi-reco", diff --git a/Detectors/ZDC/workflow/src/ZDCRecoWriterDPLSpec.cxx b/Detectors/ZDC/workflow/src/ZDCRecoWriterDPLSpec.cxx index 9a2e4441cadc0..91fd924976dcd 100644 --- a/Detectors/ZDC/workflow/src/ZDCRecoWriterDPLSpec.cxx +++ b/Detectors/ZDC/workflow/src/ZDCRecoWriterDPLSpec.cxx @@ -44,7 +44,7 @@ DataProcessorSpec getZDCRecoWriterDPLSpec() BranchDefinition>{InputSpec{"energy", "ZDC", "ENERGY"}, "ZDCRecE"}, BranchDefinition>{InputSpec{"tdcdata", "ZDC", "TDCDATA"}, "ZDCRecTDC"}, BranchDefinition>{InputSpec{"info", "ZDC", "INFO"}, "ZDCRecInfo"}, - BranchDefinition>{InputSpec{"wave", "ZDC", "WAVEFORM"}, "ZDCWaveform"})(); + BranchDefinition>{InputSpec{"wave", "ZDC", "WAVE"}, "ZDCWaveform"})(); } } // namespace zdc From 5ac27a2f64b3b25033baaea503ddb089e4ffdedb Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Wed, 11 May 2022 23:18:11 +0200 Subject: [PATCH 08/40] WIP --- .../ZDC/include/DataFormatsZDC/RecEvent.h | 2 +- .../ZDC/include/DataFormatsZDC/RecEventAux.h | 2 + .../ZDC/include/DataFormatsZDC/ZDCWaveform.h | 2 +- .../calib/include/ZDCCalib/WaveformCalibEPN.h | 4 +- .../include/ZDCCalib/WaveformCalibQueue.h | 1 + Detectors/ZDC/calib/src/WaveformCalibEPN.cxx | 1 + .../ZDC/calib/src/WaveformCalibQueue.cxx | 52 ++++++++++++++++--- Detectors/ZDC/reconstruction/src/DigiReco.cxx | 38 ++++++++------ Detectors/ZDC/workflow/src/DigitRecoSpec.cxx | 9 ++-- 9 files changed, 79 insertions(+), 32 deletions(-) diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEvent.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEvent.h index 07cb710815c5c..e069a1a654c7a 100644 --- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEvent.h +++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEvent.h @@ -47,7 +47,7 @@ struct RecEvent { #ifdef O2_ZDC_DEBUG printf("addBC %u.%-4u En_start:%-2lu TDC_start:%-2lu Info_start:%-2lu ch=0x%08x tr=0x%08x\n", reca.ir.orbit, reca.ir.bc, mEnergy.size(), mTDCData.size(), mInfo.size(), reca.channels, reca.triggers); #endif - mRecBC.emplace_back(mEnergy.size(), mTDCData.size(), mInfo.size(), reca.ir); + mRecBC.emplace_back(mEnergy.size(), mTDCData.size(), mInfo.size(), mWaveform.size(), reca.ir); mRecBC.back().channels = reca.channels; mRecBC.back().triggers = reca.triggers; } diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventAux.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventAux.h index b065807485ee8..ac4ce5ea8b052 100644 --- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventAux.h +++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventAux.h @@ -44,6 +44,8 @@ struct RecEventAux : public RecEventFlat { std::array err; /// Generic error condition std::array data[NChannels] = {0}; /// Samples (raw or filtered) float inter[NTDCChannels][NTimeBinsPerBC * TSN] = {0}; /// Interpolated samples + std::array interp; /// Pattern of interpolated data + // Functions RecEventAux() { diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/ZDCWaveform.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/ZDCWaveform.h index cb0a50912629e..97c9af0b43b3b 100644 --- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/ZDCWaveform.h +++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/ZDCWaveform.h @@ -51,7 +51,7 @@ struct ZDCWaveform { return inter; } - uint8_t ch() const + int ch() const { return sig; } diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h index 27e58fd5e2d89..71ef1dfe3d498 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h @@ -74,9 +74,7 @@ class WaveformCalibEPN mN=ilast-ifirst+1; } - - - WaveformCalibQueue mQueue; + WaveformCalibQueue mQueue; }; } // namespace zdc } // namespace o2 diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h index b3fbf3ab4b7e4..78f878aeb4c23 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h @@ -94,6 +94,7 @@ struct WaveformCalibQueue { } uint32_t append(RecEventFlat& ev); void appendEv(RecEventFlat& ev); + int hasData(int isig, const gsl::span& wave); }; } // namespace zdc diff --git a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx index dfcab897fcd65..97eb079175466 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx @@ -67,6 +67,7 @@ int WaveformCalibEPN::process(const gsl::span& RecBC, if ((mask & (0x1 << itdc)) != 0) { // Check which channels have consecutive data int isig = TDCSignal[itdc]; + LOG(info) << "check " << isig << " " << mQueue.hasData(isig, wave); } } } diff --git a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx index 707cf74a08493..8d644c861d223 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx @@ -42,22 +42,22 @@ uint32_t WaveformCalibQueue::append(RecEventFlat& ev) for (int32_t itdc = 0; itdc < NTDCChannels; itdc++) { // Check which channels satisfy the condition on TDC bool tdccond = true; - for(int i = 0; i& wave) +{ + int np = NTimeBinsPerBC * TSN; + int ipk = -1; + int ipkb = -1; + float min = std::numeric_limits::infinity(); + for (int ib = 0; ib < mN; ib++) { + int ifound = false; + LOG(info) << "mNW[" << ib<< "] = " << mNW[ib] << " mFirstW = " << mFirstW[ib]; + for (int iw = 0; iw < mNW[ib]; iw++) { + auto& mywave = wave[iw + mFirstW[ib]]; + if (mywave.ch() == isig) { + ifound = true; + for (int ip = 0; ip < np; ip++) { + if (mywave.inter[ip] < min) { + ipkb = ib; + ipk = ip; + min = mywave.inter[ip]; + } + } + } + } + // Need to have consecutive data for all bunches + if (!ifound) { + return -1; + } + } + if (ipkb != mPk) { + return -1; + } else { + int ipos = NTimeBinsPerBC * TSN * ipkb + ipk; + LOG(info) << "isig = " << isig << " ipkb " << ipkb << " ipk " << ipk << " min " << min; + return ipos; + } +} + } // namespace zdc } // namespace o2 diff --git a/Detectors/ZDC/reconstruction/src/DigiReco.cxx b/Detectors/ZDC/reconstruction/src/DigiReco.cxx index 8efa4d96e1380..4b11bf0a333b4 100644 --- a/Detectors/ZDC/reconstruction/src/DigiReco.cxx +++ b/Detectors/ZDC/reconstruction/src/DigiReco.cxx @@ -522,32 +522,37 @@ void DigiReco::lowPassFilter() for (int itdc = 0; itdc < NTDCChannels; itdc++) { auto isig = TDCSignal[itdc]; for (int ibc = 0; ibc < mNBC; ibc++) { + // Indexes of current, previous and next recorded bunch crossings auto ref_c = mReco[ibc].ref[isig]; - uint32_t ref_p = ibc == 0 ? ZDCRefInitVal : mReco[ibc - 1].ref[isig]; - uint32_t ref_n = ibc == (mNBC - 1) ? ZDCRefInitVal : mReco[ibc + 1].ref[isig]; - if (ref_c != ZDCRefInitVal) { + uint32_t ref_p = ZDCRefInitVal; + uint32_t ref_n = ZDCRefInitVal; + int64_t bcd_p = ZDCRefInitVal; + int64_t bcd_n = ZDCRefInitVal; + if (ibc > 0) { // Is not first bunch in list + ref_p = mReco[ibc - 1].ref[isig]; + bcd_p = mReco[ibc].ir.differenceInBC(mReco[ibc - 1].ir); // b.c. number of (ibc) - b.c. number (ibc-1) + } + if (ibc < (mNBC - 1)) { // Is not last bunch in list + ref_n = mReco[ibc + 1].ref[isig]; + bcd_n = mReco[ibc + 1].ir.differenceInBC(mReco[ibc].ir); // b.c. number of (ibc+1) - b.c. number (ibc) + } + if (ref_c != ZDCRefInitVal) { // Should always be true for (int is = 0; is < NTimeBinsPerBC; is++) { int32_t sum = mChData[ref_c].data[is]; if (is == 0) { sum += mChData[ref_c].data[1]; - if (ref_p != ZDCRefInitVal) { - // b.c. number of (ibc) - b.c. number (ibc-1) - auto bcd = mReco[ibc].ir.differenceInBC(mReco[ibc - 1].ir); - if (bcd == 1) { // Previous bunch crossing - sum += mChData[ref_p].data[MaxTimeBin]; - } + if (ref_p != ZDCRefInitVal && bcd_p == 1) { + // Add last sample of previous bunch crossing + sum += mChData[ref_p].data[MaxTimeBin]; } else { // As a backup we count twice the first sample sum += mChData[ref_c].data[0]; } } else if (is == MaxTimeBin) { sum += mChData[ref_c].data[MaxTimeBin - 1]; - if (ref_n != ZDCRefInitVal) { - // b.c. number of (ibc+1) - b.c. number (ibc) - auto bcd = mReco[ibc + 1].ir.differenceInBC(mReco[ibc].ir); - if (bcd == 1) { - sum += mChData[ref_n].data[0]; - } + if (ref_n != ZDCRefInitVal && bcd_n == 1) { + // Add first sample of next bunch crossing + sum += mChData[ref_n].data[0]; } else { // As a backup we count twice the last sample sum += mChData[ref_c].data[MaxTimeBin]; @@ -1210,6 +1215,9 @@ void DigiReco::interpolate(int itdc, int ibeg, int iend) // otherwise the interpolation is performed only around actual signal // TODO: extend full interpolation to all channels if (mFullInterpolation) { + for (int ibun = ibeg; ibun <= iend; ibun++) { + mReco[ibun].interp[itdc] = true; + } for (int i = 0; i < mNtot; i++) { setPoint(itdc, ibeg, iend, i); } diff --git a/Detectors/ZDC/workflow/src/DigitRecoSpec.cxx b/Detectors/ZDC/workflow/src/DigitRecoSpec.cxx index ce134356ee45d..d394afcd2ed7d 100644 --- a/Detectors/ZDC/workflow/src/DigitRecoSpec.cxx +++ b/Detectors/ZDC/workflow/src/DigitRecoSpec.cxx @@ -197,14 +197,15 @@ void DigitRecoSpec::run(ProcessingContext& pc) } // Add waveform information if (fullinter) { - auto sig = TDCSignal[it]; - uint32_t mask = 0x1 << sig; - if (reca.channels & mask) { + // For the moment only TDC channels are interpolated + if (reca.interp[it]) { if (toAddBC) { recEvent.addBC(reca); toAddBC = false; } - recEvent.addWaveform(sig, reca.inter[it]); + auto isig = TDCSignal[it]; + LOG(INFO) << reca.ir.orbit << "." << reca.ir.bc << " isig = " << isig; + recEvent.addWaveform(isig, reca.inter[it]); } } } From 998d37c4866976f84bbca57bc4b6ac9a7f7306cf Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Thu, 12 May 2022 14:27:46 +0200 Subject: [PATCH 09/40] WIP --- .../ZDC/include/DataFormatsZDC/RecEvent.h | 10 +++- .../ZDC/include/DataFormatsZDC/RecEventAux.h | 2 - .../ZDC/include/DataFormatsZDC/RecEventFlat.h | 10 ++++ .../DataFormatsZDC/WaveformCalibData.h | 18 +++++- .../ZDC/base/include/ZDCBase/Constants.h | 1 + .../include/ZDCCalib/WaveformCalibConfig.h | 8 ++- .../include/ZDCCalib/WaveformCalibQueue.h | 6 ++ Detectors/ZDC/calib/src/WaveformCalibEPN.cxx | 9 ++- .../ZDC/calib/src/WaveformCalibQueue.cxx | 60 ++++++++++++++++++- Detectors/ZDC/reconstruction/src/DigiReco.cxx | 8 ++- Detectors/ZDC/workflow/src/DigitRecoSpec.cxx | 3 +- 11 files changed, 121 insertions(+), 14 deletions(-) diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEvent.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEvent.h index e069a1a654c7a..9ac9494a45d1d 100644 --- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEvent.h +++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEvent.h @@ -110,13 +110,17 @@ struct RecEvent { uint32_t addInfos(const RecEventAux& reca); // Add waveform - inline void addWaveform(uint8_t ch, float* wave) + inline void addWaveform(uint8_t ch, std::vector& wave) { #ifdef O2_ZDC_DEBUG printf("ch:%-2u [%s] Waveform\n", ch, ChannelNames[ch].data()); #endif - mWaveform.emplace_back(ch, wave); - mRecBC.back().addWaveform(); + if (wave.size() == NIS) { + mWaveform.emplace_back(ch, wave.data()); + mRecBC.back().addWaveform(); + } else { + LOG(error) << __func__ << ": ch " << int(ch) << " inconsistent waveform size " << wave.size(); + } } void print() const; diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventAux.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventAux.h index ac4ce5ea8b052..e384d19083c02 100644 --- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventAux.h +++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventAux.h @@ -43,8 +43,6 @@ struct RecEventAux : public RecEventFlat { uint32_t ref[NChannels]; /// Cache of references std::array err; /// Generic error condition std::array data[NChannels] = {0}; /// Samples (raw or filtered) - float inter[NTDCChannels][NTimeBinsPerBC * TSN] = {0}; /// Interpolated samples - std::array interp; /// Pattern of interpolated data // Functions RecEventAux() diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventFlat.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventFlat.h index f348688266aa4..cad0e7c19556a 100644 --- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventFlat.h +++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventFlat.h @@ -64,6 +64,7 @@ struct RecEventFlat { // NOLINT: false positive in clang-tidy !! std::array isBeg{}; //! Beginning of sequence std::array isEnd{}; //! End of sequence BCRecData mCurB; //! Current BC + std::vector inter[NTDCChannels]; //! Interpolated samples // Reconstruction messages std::array genericE{}; /// 0 Generic error @@ -101,6 +102,15 @@ struct RecEventFlat { // NOLINT: false positive in clang-tidy !! int next(); int at(int ientry); + void allocate(int itdc){ + if(inter[itdc].size()!=NIS){ + inter[itdc].resize(NIS); + for(int iis=0; iis mWave[NH]; + int mN = 0; /// Number of bunches in waveform + std::array mFirstValid; + std::array mLastValid; + std::array mWave[NH] = {0}; uint32_t mEntries[NH] = {0}; WaveformCalibData& operator+=(const WaveformCalibData& other); int getEntries(int ih) const; void print() const; void setCreationTime(uint64_t ctime); + void setN(int n) + { + if (n >= 0 && n < WaveformCalibConfig::NBT) { + mN = n; + for (int ih = 0; ih < NH; ih++) { + mFirstValid[ih] = 0; + mLastValid[ih] = mH * NTimeBinsPerBC * TSN - 1; + } + } else { + LOG(fatal) << "WaveformCalibData " << __func__ << " wrong stored b.c. setting " << n << " not in range [0:" << WaveformCalibConfig::NBT << "]"; + } + } ClassDefNV(WaveformCalibData, 1); }; diff --git a/Detectors/ZDC/base/include/ZDCBase/Constants.h b/Detectors/ZDC/base/include/ZDCBase/Constants.h index c9e9bd73bb385..f6fd7b99c2d64 100644 --- a/Detectors/ZDC/base/include/ZDCBase/Constants.h +++ b/Detectors/ZDC/base/include/ZDCBase/Constants.h @@ -93,6 +93,7 @@ constexpr int TSN = 200; // Number of interpolated points betwe constexpr int TSNH = TSN / 2; // Half of TSN constexpr int NTS = 2 * TSL * TSN + 1; // Tapered sinc function array size constexpr static float FTDCAmp = 1. / 8.; // Multiplication factor in conversion from integer +constexpr int NIS = NTimeBinsPerBC * TSN; // Number of interpolated samples // With a reference clock of 40 MHz exact this FTDCVal would have been // constexpr static float FTDCVal = 1. / TSNS; // with constexpr int TSNS = 96; diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h index f6b2d73c7c726..42f5e076973a6 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h @@ -34,11 +34,13 @@ struct WaveformCalibConfig { static constexpr int NBA = 6; static constexpr int NBT = NBB + NBA + 1; - double cutLow[NH]; - double cutHigh[NH]; + double cutLow[NH]; /// Amplitude cut low + double cutHigh[NH]; /// Amplitude cut high + double cutTimeLow[NH]; /// TDC cut low + double cutTimeHigh[NH]; /// TDC cut high double min_e[NH] = {0.}; std::string desc = ""; - int ibeg = - NBB; + int ibeg = -NBB; int iend = NBA; int nbun = iend - ibeg + 1; diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h index 78f878aeb4c23..e1d7efc29ca6f 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h @@ -19,6 +19,7 @@ #include "DataFormatsZDC/OrbitData.h" #include "DataFormatsZDC/RecEvent.h" #include "DataFormatsZDC/RecEventFlat.h" +#include "DataFormatsZDC/WaveformCalibData.h" #include "ZDCCalib/WaveformCalibConfig.h" #include @@ -42,6 +43,8 @@ struct WaveformCalibQueue { int mLast = 0; int mPk = 0; int mN = 1; + int mPPos = 0; + int mNP = 0; void configure(int ifirst, int ilast) { if (ifirst > 0 || ilast < 0 || ilast < ifirst) { @@ -51,6 +54,8 @@ struct WaveformCalibQueue { mLast = ilast; mN = ilast - ifirst + 1; mPk = -mFirst; + mPPos = mPk * NIS + NIS/2; + mNP = mN * NIS; } std::deque mIR; std::deque mEntry; @@ -95,6 +100,7 @@ struct WaveformCalibQueue { uint32_t append(RecEventFlat& ev); void appendEv(RecEventFlat& ev); int hasData(int isig, const gsl::span& wave); + int addData(int isig, const gsl::span& wave, WaveformCalibData& data); }; } // namespace zdc diff --git a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx index 97eb079175466..2f1862fdf38df 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx @@ -37,6 +37,7 @@ int WaveformCalibEPN::init() mNBin = cfg->nbun * TSN; mFirst = cfg->ibeg; mLast = cfg->iend; + mData.setN(cfg->nbun); for (int ih = 0; ih < NH; ih++) { mH[ih] = new o2::dataformats::FlatHisto1D(mNBin, 0, mNBin); } @@ -67,7 +68,13 @@ int WaveformCalibEPN::process(const gsl::span& RecBC, if ((mask & (0x1 << itdc)) != 0) { // Check which channels have consecutive data int isig = TDCSignal[itdc]; - LOG(info) << "check " << isig << " " << mQueue.hasData(isig, wave); + int ipos = mQueue.hasData(isig, wave); + LOG(info) << "check " << isig << " " << ipos; + if (ipos >= 0) { + // Add to histogram + int ibun = ipos / NIS; + int isam = ipos % NIS; + } } } } diff --git a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx index 8d644c861d223..fde7ab1b11247 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx @@ -127,7 +127,7 @@ int WaveformCalibQueue::hasData(int isig, const gsl::span::infinity(); for (int ib = 0; ib < mN; ib++) { int ifound = false; - LOG(info) << "mNW[" << ib<< "] = " << mNW[ib] << " mFirstW = " << mFirstW[ib]; + LOG(info) << "mNW[" << ib << "] = " << mNW[ib] << " mFirstW = " << mFirstW[ib]; for (int iw = 0; iw < mNW[ib]; iw++) { auto& mywave = wave[iw + mFirstW[ib]]; if (mywave.ch() == isig) { @@ -155,5 +155,63 @@ int WaveformCalibQueue::hasData(int isig, const gsl::span& wave, WaveformCalibData& data) +{ + int np = NTimeBinsPerBC * TSN; + int ipk = -1; + int ipkb = -1; + float min = std::numeric_limits::infinity(); + for (int ib = 0; ib < mN; ib++) { + int ifound = false; + LOG(info) << "mNW[" << ib << "] = " << mNW[ib] << " mFirstW = " << mFirstW[ib]; + for (int iw = 0; iw < mNW[ib]; iw++) { + auto& mywave = wave[iw + mFirstW[ib]]; + if (mywave.ch() == isig) { + ifound = true; + for (int ip = 0; ip < np; ip++) { + if (mywave.inter[ip] < min) { + ipkb = ib; + ipk = ip; + min = mywave.inter[ip]; + } + } + } + } + // Need to have consecutive data for all bunches + if (!ifound) { + return -1; + } + } + if (ipkb != mPk) { + return -1; + } else { + // For the moment only TDC channels are interpolated + int itdc = SignalTDC[isig]; + int ppos = NTimeBinsPerBC * TSN * ipkb + ipk; + int pset = NTimeBinsPerBC * TSN * ipkb + NTimeBinsPerBC / 2 * TSN; + int ipos = pset - ppos; + if(ipos > 0){ + LOG(error) << "Cannot add waveform: missing data at the beginning"; + return -1; + } + // We know that points are consecutive + for (int ib = 0; ib < mN; ib++) { + for (int iw = 0; iw < mNW[ib]; iw++) { + auto& mywave = wave[iw + mFirstW[ib]]; + if (mywave.ch() == isig) { + for (int ip = 0; ip < np; ip++) { + if (ipos >= 0 && ipos < mNP) { + data.mWave[itdc][ipos] += mywave.inter[ip]; + } + ipos++; + } + } + } + } + LOG(info) << "isig = " << isig << " ipkb " << ipkb << " ipk " << ipk << " min " << min; + return ipos; + } +} + } // namespace zdc } // namespace o2 diff --git a/Detectors/ZDC/reconstruction/src/DigiReco.cxx b/Detectors/ZDC/reconstruction/src/DigiReco.cxx index 4b11bf0a333b4..c54000fc58c9e 100644 --- a/Detectors/ZDC/reconstruction/src/DigiReco.cxx +++ b/Detectors/ZDC/reconstruction/src/DigiReco.cxx @@ -1145,6 +1145,12 @@ O2_ZDC_DIGIRECO_FLT DigiReco::getPoint(int itdc, int ibeg, int iend, int i) void DigiReco::setPoint(int itdc, int ibeg, int iend, int i) { + // This function needs to be used only if mFullInterpolation is true otherwise the + // vectors are not allocated + if(!mFullInterpolation){ + LOG(FATAL) << __func__ << " call with mFullInterpolation = " << mFullInterpolation; + return; + } constexpr int nsbun = TSN * NTimeBinsPerBC; // Total number of interpolated points per bunch crossing if (i >= mNtot || i < 0) { LOG(fatal) << "Error addressing TDC itdc=" << itdc << " i=" << i << " mNtot=" << mNtot; @@ -1216,7 +1222,7 @@ void DigiReco::interpolate(int itdc, int ibeg, int iend) // TODO: extend full interpolation to all channels if (mFullInterpolation) { for (int ibun = ibeg; ibun <= iend; ibun++) { - mReco[ibun].interp[itdc] = true; + mReco[ibun].allocate(itdc); } for (int i = 0; i < mNtot; i++) { setPoint(itdc, ibeg, iend, i); diff --git a/Detectors/ZDC/workflow/src/DigitRecoSpec.cxx b/Detectors/ZDC/workflow/src/DigitRecoSpec.cxx index d394afcd2ed7d..b04cc5bba548a 100644 --- a/Detectors/ZDC/workflow/src/DigitRecoSpec.cxx +++ b/Detectors/ZDC/workflow/src/DigitRecoSpec.cxx @@ -198,13 +198,12 @@ void DigitRecoSpec::run(ProcessingContext& pc) // Add waveform information if (fullinter) { // For the moment only TDC channels are interpolated - if (reca.interp[it]) { + if (reca.inter[it].size()==NIS) { if (toAddBC) { recEvent.addBC(reca); toAddBC = false; } auto isig = TDCSignal[it]; - LOG(INFO) << reca.ir.orbit << "." << reca.ir.bc << " isig = " << isig; recEvent.addWaveform(isig, reca.inter[it]); } } From dfb290b0046d92a072f92ff098a43b0af6a35b55 Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Thu, 12 May 2022 16:29:06 +0200 Subject: [PATCH 10/40] WIP --- .../DataFormatsZDC/WaveformCalibData.h | 2 +- .../include/ZDCCalib/WaveformCalibConfig.h | 9 ++++++- .../include/ZDCCalib/WaveformCalibQueue.h | 14 ++++++++--- .../ZDC/calib/src/WaveformCalibConfig.cxx | 8 ++++--- Detectors/ZDC/calib/src/WaveformCalibEPN.cxx | 10 ++------ .../ZDC/calib/src/WaveformCalibQueue.cxx | 24 ++++++++++++++----- .../ZDC/macro/CreateWaveformCalibConfig.C | 2 +- 7 files changed, 46 insertions(+), 23 deletions(-) diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/WaveformCalibData.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/WaveformCalibData.h index 2e0bf79a7419f..63b18f70f9c52 100644 --- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/WaveformCalibData.h +++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/WaveformCalibData.h @@ -46,7 +46,7 @@ struct WaveformCalibData { mN = n; for (int ih = 0; ih < NH; ih++) { mFirstValid[ih] = 0; - mLastValid[ih] = mH * NTimeBinsPerBC * TSN - 1; + mLastValid[ih] = NH * NTimeBinsPerBC * TSN - 1; } } else { LOG(fatal) << "WaveformCalibData " << __func__ << " wrong stored b.c. setting " << n << " not in range [0:" << WaveformCalibConfig::NBT << "]"; diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h index 42f5e076973a6..4561e6e982eff 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h @@ -61,7 +61,14 @@ struct WaveformCalibConfig { void setCuts(int ih, double low, double high); void setDescription(std::string d) { desc = d; } - ClassDefNV(WaveformCalibConfig, 1); + int getFirst() const{ + return ibeg; + } + int getLast() const{ + return iend; + } + + ClassDefNV(WaveformCalibConfig, 2); }; } // namespace zdc } // namespace o2 diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h index e1d7efc29ca6f..2491a75cfc96d 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h @@ -35,18 +35,25 @@ namespace zdc struct WaveformCalibQueue { static constexpr int NH = WaveformCalibConfig::NH; WaveformCalibQueue() = default; - WaveformCalibQueue(int ifirst, int ilast) + WaveformCalibQueue(WaveformCalibConfig *cfg) { - configure(ifirst, ilast); + configure(cfg); } + int mFirst = 0; int mLast = 0; int mPk = 0; int mN = 1; int mPPos = 0; int mNP = 0; - void configure(int ifirst, int ilast) + + const WaveformCalibConfig *mCfg = nullptr; + + void configure(const WaveformCalibConfig *cfg) { + mCfg = cfg; + int ifirst = mCfg->getFirst(); + int ilast = mCfg->getLast(); if (ifirst > 0 || ilast < 0 || ilast < ifirst) { LOGF(fatal, "WaveformCalibQueue configure error with ifirst=%d ilast=%d", ifirst, ilast); } @@ -57,6 +64,7 @@ struct WaveformCalibQueue { mPPos = mPk * NIS + NIS/2; mNP = mN * NIS; } + std::deque mIR; std::deque mEntry; std::deque mHasInfos[NH]; diff --git a/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx b/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx index 7b159cb94fd4f..5403afc0d41e7 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx @@ -15,9 +15,11 @@ using namespace o2::zdc; WaveformCalibConfig::WaveformCalibConfig() { - for (int i = 0; i < NH; i++) { - cutLow[i] = -std::numeric_limits::infinity(); - cutHigh[i] = std::numeric_limits::infinity(); + for (int ih = 0; ih < NH; ih++) { + cutLow[ih] = -std::numeric_limits::infinity(); + cutHigh[ih] = std::numeric_limits::infinity(); + cutTimeLow[ih] = -2.5; + cutTimeHigh[ih] = 2.5; } } diff --git a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx index 2f1862fdf38df..d30eacef606b0 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx @@ -54,7 +54,7 @@ int WaveformCalibEPN::process(const gsl::span& RecBC, if (!mInitDone) { init(); } - mQueue.configure(mFirst, mLast); + mQueue.configure(mWaveformCalibConfig); o2::zdc::RecEventFlat ev; ev.init(RecBC, Energy, TDCData, Info); auto nen = ev.getEntries(); @@ -68,13 +68,7 @@ int WaveformCalibEPN::process(const gsl::span& RecBC, if ((mask & (0x1 << itdc)) != 0) { // Check which channels have consecutive data int isig = TDCSignal[itdc]; - int ipos = mQueue.hasData(isig, wave); - LOG(info) << "check " << isig << " " << ipos; - if (ipos >= 0) { - // Add to histogram - int ibun = ipos / NIS; - int isam = ipos % NIS; - } + mQueue.addData(isig, wave, mData); } } } diff --git a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx index fde7ab1b11247..375003dff9062 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx @@ -17,6 +17,9 @@ namespace o2 namespace zdc { +// appends an event to the queue with the request that there are at most +// mN consecutive bunches +// The TDC conditions are checked and returned in output uint32_t WaveformCalibQueue::append(RecEventFlat& ev) { auto& toadd = ev.ir; @@ -48,6 +51,13 @@ uint32_t WaveformCalibQueue::append(RecEventFlat& ev) if (n != 1) { tdccond = false; break; + } else { + auto tdca = mTDCA[itdc].at(i); + auto tdcv = mTDCP[itdc].at(i); + if (tdca < mCfg->cutLow[itdc] || tdca > mCfg->cutHigh[itdc] || tdcv < mCfg->cutTimeLow[itdc] || tdcv > mCfg->cutTimeHigh[itdc]) { + tdccond = false; + break; + } } } else { if (n != 0) { @@ -68,8 +78,6 @@ uint32_t WaveformCalibQueue::append(RecEventFlat& ev) void WaveformCalibQueue::appendEv(RecEventFlat& ev) { - LOG(info) << __func__ << " " << ev.ir.orbit << "." << ev.ir.bc; - mIR.push_back(ev.ir); mEntry.push_back(ev.getNextEntry() - 1); @@ -181,6 +189,7 @@ int WaveformCalibQueue::addData(int isig, const gsl::span 0){ - LOG(error) << "Cannot add waveform: missing data at the beginning"; - return -1; + if (ipos > data.mFirstValid[itdc]) { + data.mFirstValid[itdc] = ipos; } // We know that points are consecutive for (int ib = 0; ib < mN; ib++) { @@ -208,7 +216,11 @@ int WaveformCalibQueue::addData(int isig, const gsl::span Date: Fri, 13 May 2022 16:06:30 +0200 Subject: [PATCH 11/40] EPN Waveform workflow --- .../include/DataFormatsZDC/InterCalibData.h | 4 +- .../ZDC/base/include/ZDCBase/Constants.h | 4 - Detectors/ZDC/calib/CMakeLists.txt | 6 +- .../include/ZDCCalib/WaveformCalibConfig.h | 5 +- .../include/ZDCCalib}/WaveformCalibData.h | 20 ++--- .../calib/include/ZDCCalib/WaveformCalibEPN.h | 6 +- .../include/ZDCCalib/WaveformCalibEPNSpec.h | 2 +- .../include/ZDCCalib/WaveformCalibQueue.h | 4 +- .../ZDC/calib}/src/WaveformCalibData.cxx | 63 ++++++++------- Detectors/ZDC/calib/src/WaveformCalibEPN.cxx | 79 ++++++++++--------- .../ZDC/calib/src/WaveformCalibQueue.cxx | 39 ++++----- Detectors/ZDC/calib/src/ZDCCalibLinkDef.h | 1 + .../include/ZDCReconstruction/DigiReco.h | 2 +- .../include/ZDCReconstruction/RecoParamZDC.h | 2 + Detectors/ZDC/reconstruction/src/DigiReco.cxx | 34 ++++---- .../ZDC/reconstruction/src/RecoParamZDC.cxx | 14 ++-- Detectors/ZDC/workflow/src/DigitRecoSpec.cxx | 9 ++- 17 files changed, 155 insertions(+), 139 deletions(-) rename {DataFormats/Detectors/ZDC/include/DataFormatsZDC => Detectors/ZDC/calib/include/ZDCCalib}/WaveformCalibData.h (76%) rename {DataFormats/Detectors/ZDC => Detectors/ZDC/calib}/src/WaveformCalibData.cxx (50%) diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/InterCalibData.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/InterCalibData.h index 82279ad855572..dbe45280def65 100644 --- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/InterCalibData.h +++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/InterCalibData.h @@ -9,8 +9,8 @@ // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. -#ifndef _ZDC_INTERCALIB_DATA_H_ -#define _ZDC_INTERCALIB_DATA_H_ +#ifndef _ZDC_INTERCALIB_DATA_H +#define _ZDC_INTERCALIB_DATA_H #include "ZDCBase/Constants.h" #include diff --git a/Detectors/ZDC/base/include/ZDCBase/Constants.h b/Detectors/ZDC/base/include/ZDCBase/Constants.h index f6fd7b99c2d64..d82c277ce4b1f 100644 --- a/Detectors/ZDC/base/include/ZDCBase/Constants.h +++ b/Detectors/ZDC/base/include/ZDCBase/Constants.h @@ -25,10 +25,6 @@ //#define O2_ZDC_DEBUG // TDC arrays in debug output //#define O2_ZDC_TDC_C_ARRAY -// Debug output of full interpolated function -//#define O2_ZDC_INTERP_DEBUG -// Low pass filtering of acquired samples -#define O2_ZDC_RECO_FILTERING namespace o2 { diff --git a/Detectors/ZDC/calib/CMakeLists.txt b/Detectors/ZDC/calib/CMakeLists.txt index 5f0f5efb14714..3f02bc8d825cf 100644 --- a/Detectors/ZDC/calib/CMakeLists.txt +++ b/Detectors/ZDC/calib/CMakeLists.txt @@ -20,6 +20,8 @@ o2_add_library(ZDCCalib src/WaveformCalibEPN.cxx src/WaveformCalibEPNSpec.cxx src/WaveformCalibQueue.cxx + src/WaveformCalibData.cxx + src/CalibParamZDC.cxx PUBLIC_LINK_LIBRARIES O2::CCDB O2::DPLUtils @@ -46,7 +48,9 @@ o2_target_root_dictionary(ZDCCalib include/ZDCCalib/WaveformCalibConfig.h include/ZDCCalib/WaveformCalibEPN.h include/ZDCCalib/WaveformCalibEPNSpec.h - include/ZDCCalib/WaveformCalibQueue.h) + include/ZDCCalib/WaveformCalibQueue.h + include/ZDCCalib/WaveformCalibData.h + include/ZDCCalib/CalibParamZDC.h) o2_add_executable(intercalib-workflow COMPONENT_NAME zdc diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h index 4561e6e982eff..78456c3be9ae9 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h @@ -27,12 +27,13 @@ namespace zdc { struct WaveformCalibConfig { - WaveformCalibConfig(); - static constexpr int NH = NTDCChannels; static constexpr int NBB = 3; static constexpr int NBA = 6; static constexpr int NBT = NBB + NBA + 1; + static constexpr int NW = NBT * NIS; + + WaveformCalibConfig(); double cutLow[NH]; /// Amplitude cut low double cutHigh[NH]; /// Amplitude cut high diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/WaveformCalibData.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h similarity index 76% rename from DataFormats/Detectors/ZDC/include/DataFormatsZDC/WaveformCalibData.h rename to Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h index 63b18f70f9c52..a98a952b1f55b 100644 --- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/WaveformCalibData.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h @@ -28,10 +28,15 @@ namespace zdc struct WaveformCalibData { static constexpr int NH = WaveformCalibConfig::NH; - static constexpr int NW = WaveformCalibConfig::NBT * TSN; + static constexpr int NBB = WaveformCalibConfig::NBB; + static constexpr int NBA = WaveformCalibConfig::NBA; + static constexpr int NBT = WaveformCalibConfig::NBT; + static constexpr int NW = WaveformCalibConfig::NW; + uint64_t mCTimeBeg = 0; /// Time of processed time frame uint64_t mCTimeEnd = 0; /// Time of processed time frame int mN = 0; /// Number of bunches in waveform + int mPeak = 0; /// Peak position std::array mFirstValid; std::array mLastValid; std::array mWave[NH] = {0}; @@ -40,18 +45,7 @@ struct WaveformCalibData { int getEntries(int ih) const; void print() const; void setCreationTime(uint64_t ctime); - void setN(int n) - { - if (n >= 0 && n < WaveformCalibConfig::NBT) { - mN = n; - for (int ih = 0; ih < NH; ih++) { - mFirstValid[ih] = 0; - mLastValid[ih] = NH * NTimeBinsPerBC * TSN - 1; - } - } else { - LOG(fatal) << "WaveformCalibData " << __func__ << " wrong stored b.c. setting " << n << " not in range [0:" << WaveformCalibConfig::NBT << "]"; - } - } + void setN(int n); ClassDefNV(WaveformCalibData, 1); }; diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h index 71ef1dfe3d498..33e9a6a0fac65 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h @@ -17,13 +17,11 @@ #include #include #include "ZDCBase/Constants.h" -#include "CommonDataFormat/FlatHisto1D.h" -#include "CommonDataFormat/FlatHisto2D.h" #include "DataFormatsZDC/RecEvent.h" -#include "DataFormatsZDC/WaveformCalibData.h" #include "DataFormatsZDC/ZDCWaveform.h" #include "ZDCReconstruction/ZDCEnergyParam.h" #include "ZDCReconstruction/ZDCTowerParam.h" +#include "ZDCCalib/WaveformCalibData.h" #include "ZDCCalib/WaveformCalibConfig.h" #include "ZDCCalib/WaveformCalibQueue.h" #ifndef ALICEO2_ZDC_WAVEFORMCALIBEPN_H @@ -50,7 +48,7 @@ class WaveformCalibEPN const WaveformCalibConfig* getConfig() const { return mWaveformCalibConfig; }; void setSaveDebugHistos() { mSaveDebugHistos = true; } void setDontSaveDebugHistos() { mSaveDebugHistos = false; } - std::array*, NH> mH{}; + void setVerbosity(int val) { mVerbosity = val; } WaveformCalibData mData; WaveformCalibData& getData() { return mData; } diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPNSpec.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPNSpec.h index 4fedec7184f6e..d3493654d7500 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPNSpec.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPNSpec.h @@ -21,7 +21,7 @@ #include "Framework/DataProcessorSpec.h" #include "Framework/Task.h" #include "CommonUtils/NameConf.h" -#include "DataFormatsZDC/WaveformCalibData.h" +#include "ZDCCalib/WaveformCalibData.h" #include "ZDCCalib/WaveformCalibEPN.h" #include "ZDCCalib/WaveformCalibConfig.h" diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h index 2491a75cfc96d..382a519b27845 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h @@ -19,7 +19,7 @@ #include "DataFormatsZDC/OrbitData.h" #include "DataFormatsZDC/RecEvent.h" #include "DataFormatsZDC/RecEventFlat.h" -#include "DataFormatsZDC/WaveformCalibData.h" +#include "ZDCCalib/WaveformCalibData.h" #include "ZDCCalib/WaveformCalibConfig.h" #include @@ -46,6 +46,7 @@ struct WaveformCalibQueue { int mN = 1; int mPPos = 0; int mNP = 0; + int mPeak = 0; const WaveformCalibConfig *mCfg = nullptr; @@ -63,6 +64,7 @@ struct WaveformCalibQueue { mPk = -mFirst; mPPos = mPk * NIS + NIS/2; mNP = mN * NIS; + mPeak = NTimeBinsPerBC * TSN * mPk + NTimeBinsPerBC / 2 * TSN; } std::deque mIR; diff --git a/DataFormats/Detectors/ZDC/src/WaveformCalibData.cxx b/Detectors/ZDC/calib/src/WaveformCalibData.cxx similarity index 50% rename from DataFormats/Detectors/ZDC/src/WaveformCalibData.cxx rename to Detectors/ZDC/calib/src/WaveformCalibData.cxx index 87edace64d3e2..5f353f0ad3c0d 100644 --- a/DataFormats/Detectors/ZDC/src/WaveformCalibData.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibData.cxx @@ -10,46 +10,36 @@ // or submit itself to any jurisdiction. #include "Framework/Logger.h" -#include "DataFormatsZDC/WaveformCalibData.h" +#include "ZDCCalib/WaveformCalibData.h" using namespace o2::zdc; void WaveformCalibData::print() const { for (int i = 0; i < NH; i++) { - LOGF(info, "%s", DN[i]); - for (int j = 0; j < NPAR; j++) { - for (int k = 0; k < NPAR; k++) { - if (k == 0) { - printf("%e", mSum[i][j][k]); - } else { - printf(" %e", mSum[i][j][k]); - } - } - printf("\n"); - } + LOGF(info, "%d ", i); } } WaveformCalibData& WaveformCalibData::operator+=(const WaveformCalibData& other) { - for (int32_t ih = 0; ih < NH; ih++) { - for (int32_t i = 0; i < NPAR; i++) { - for (int32_t j = 0; j < NPAR; j++) { - mSum[ih][i][j] += other.mSum[ih][i][j]; - } - } - } - if (mCTimeBeg == 0 || other.mCTimeBeg < mCTimeBeg) { - mCTimeBeg = other.mCTimeBeg; - } - if (other.mCTimeEnd > mCTimeEnd) { - mCTimeEnd = other.mCTimeEnd; - } - //#ifdef O2_ZDC_DEBUG - LOGF(info, "WaveformCalibData [%llu : %llu]: %s=%d %s=%d %s=%d %s=%d %s=%d", mCTimeBeg, mCTimeEnd, DN[0], getEntries(0), DN[1], getEntries(1), - DN[2], getEntries(2), DN[3], getEntries(3), DN[4], getEntries(4)); - //#endif +// for (int32_t ih = 0; ih < NH; ih++) { +// for (int32_t i = 0; i < NPAR; i++) { +// for (int32_t j = 0; j < NPAR; j++) { +// mSum[ih][i][j] += other.mSum[ih][i][j]; +// } +// } +// } +// if (mCTimeBeg == 0 || other.mCTimeBeg < mCTimeBeg) { +// mCTimeBeg = other.mCTimeBeg; +// } +// if (other.mCTimeEnd > mCTimeEnd) { +// mCTimeEnd = other.mCTimeEnd; +// } +// //#ifdef O2_ZDC_DEBUG +// LOGF(info, "WaveformCalibData [%llu : %llu]: %s=%d %s=%d %s=%d %s=%d %s=%d", mCTimeBeg, mCTimeEnd, DN[0], getEntries(0), DN[1], getEntries(1), +// DN[2], getEntries(2), DN[3], getEntries(3), DN[4], getEntries(4)); +// //#endif return *this; } @@ -68,5 +58,18 @@ int WaveformCalibData::getEntries(int ih) const LOGF(error, "WaveformCalibData::getEntries ih = %d is out of range", ih); return 0; } - return mSum[ih][5][5]; + return 0; // TODO +} + +void WaveformCalibData::setN(int n) +{ + if (n >= 0 && n < WaveformCalibConfig::NBT) { + mN = n; + for (int ih = 0; ih < NH; ih++) { + mFirstValid[ih] = 0; + mLastValid[ih] = NH * NTimeBinsPerBC * TSN - 1; + } + } else { + LOG(fatal) << "WaveformCalibData " << __func__ << " wrong stored b.c. setting " << n << " not in range [0:" << WaveformCalibConfig::NBT << "]"; + } } diff --git a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx index d30eacef606b0..317d373ff71ac 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx @@ -12,14 +12,12 @@ #include #include #include -#include +#include #include #include #include -#include -#include +#include "ZDCCalib/CalibParamZDC.h" #include "ZDCCalib/WaveformCalibEPN.h" -//#include "ZDCCalib/WaveformCalib.h" #include "Framework/Logger.h" using namespace o2::zdc; @@ -31,16 +29,22 @@ int WaveformCalibEPN::init() return -1; } + // Inspect reconstruction parameters + o2::zdc::CalibParamZDC& opt = const_cast(CalibParamZDC::Instance()); + opt.print(); + if (opt.debug_output > 0) { + setSaveDebugHistos(); + } + auto* cfg = mWaveformCalibConfig; + mQueue.configure(mWaveformCalibConfig); // number of bins mNBin = cfg->nbun * TSN; mFirst = cfg->ibeg; mLast = cfg->iend; mData.setN(cfg->nbun); - for (int ih = 0; ih < NH; ih++) { - mH[ih] = new o2::dataformats::FlatHisto1D(mNBin, 0, mNBin); - } + mData.mPeak = mQueue.mPeak; mInitDone = true; return 0; } @@ -54,7 +58,6 @@ int WaveformCalibEPN::process(const gsl::span& RecBC, if (!mInitDone) { init(); } - mQueue.configure(mWaveformCalibConfig); o2::zdc::RecEventFlat ev; ev.init(RecBC, Energy, TDCData, Info); auto nen = ev.getEntries(); @@ -78,12 +81,15 @@ int WaveformCalibEPN::process(const gsl::span& RecBC, int WaveformCalibEPN::endOfRun() { - // if (mVerbosity > DbgZero) { - // LOGF(info, "WaveformCalibEPN::endOfRun ts (%llu:%llu)", mData.mCTimeBeg, mData.mCTimeEnd); - // for (int ih = 0; ih < NH; ih++) { - // LOGF(info, "%s %g events and cuts (%g:%g)", WaveformCalibData::DN[ih], mData.mSum[ih][5][5], mWaveformCalibConfig->cutLow[ih], mWaveformCalibConfig->cutHigh[ih]); - // } - // } + if (mVerbosity > DbgZero) { + LOGF(info, "WaveformCalibEPN::endOfRun ts (%llu:%llu)", mData.mCTimeBeg, mData.mCTimeEnd); + for (int ih = 0; ih < NH; ih++) { + LOGF(info, "Waveform %2d with %10d events and cuts AMP:(%g:%g) TDC:(%g:%g) Valid:[%d:%d:%d]", ih, mData.mEntries[ih], + mWaveformCalibConfig->cutLow[ih], mWaveformCalibConfig->cutHigh[ih], + mWaveformCalibConfig->cutTimeLow[ih], mWaveformCalibConfig->cutTimeHigh[ih], + mData.mFirstValid[ih], mData.mPeak, mData.mLastValid[ih]); + } + } if (mSaveDebugHistos) { write(); } @@ -92,29 +98,30 @@ int WaveformCalibEPN::endOfRun() int WaveformCalibEPN::write(const std::string fn) { - /* - TDirectory* cwd = gDirectory; - TFile* f = new TFile(fn.data(), "recreate"); - if (f->IsZombie()) { - LOG(error) << "Cannot create file: " << fn; - return 1; - } - for (int32_t ih = 0; ih < (2 * NH); ih++) { - if (mH[ih]) { - auto p = mH[ih]->createTH1F(WaveformCalib::mHUncN[ih]); - p->SetTitle(WaveformCalib::mHUncT[ih]); - p->Write("", TObject::kOverwrite); - } - } - for (int32_t ih = 0; ih < NH; ih++) { - if (mC[ih]) { - auto p = mC[ih]->createTH2F(WaveformCalib::mCUncN[ih]); - p->SetTitle(WaveformCalib::mCUncT[ih]); - p->Write("", TObject::kOverwrite); + TDirectory* cwd = gDirectory; + TFile* f = new TFile(fn.data(), "recreate"); + if (f->IsZombie()) { + LOG(error) << "Cannot create file: " << fn; + return 1; + } + for (int32_t ih = 0; ih < NH; ih++) { + if (mData.mEntries[ih] > 0) { + // For the moment we study only TDC channels + int isig = TDCSignal[ih]; + TString n = TString::Format("h%d", isig); + TString t = TString::Format("Waveform %d %s", isig, ChannelNames[isig].data()); + int nbx = mData.mLastValid[ih] - mData.mFirstValid[ih] + 1; + int min = mData.mFirstValid[ih] - mData.mPeak - 0.5; + int max = mData.mLastValid[ih] - mData.mPeak + 0.5; + TH1F h(n, t, nbx, min, max); + for (int ibx = 0; ibx < nbx; ibx++) { + h.SetBinContent(ibx + 1, mData.mWave[ih][mData.mFirstValid[ih] + ibx]); } + h.SetEntries(mData.mEntries[ih]); + h.Write("", TObject::kOverwrite); } - f->Close(); - cwd->cd(); - */ + } + f->Close(); + cwd->cd(); return 0; } diff --git a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx index 375003dff9062..fe45a22aba527 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx @@ -104,8 +104,8 @@ void WaveformCalibQueue::appendEv(RecEventFlat& ev) // ev.print(); // } } - // NOTE: for the moment NH = NTDCChannels. If we remove this we will need to - // have a mask of affected channels (towers) + // NOTE: for the moment NH = NTDCChannels. If we want to extend it to all channels + // we will need to have a mask of affected channels (towers contributing to sum) for (int32_t itdc = 0; itdc < NTDCChannels; itdc++) { int ich = o2::zdc::TDCSignal[itdc]; int nhit = ev.NtdcV(itdc); @@ -129,7 +129,6 @@ void WaveformCalibQueue::appendEv(RecEventFlat& ev) int WaveformCalibQueue::hasData(int isig, const gsl::span& wave) { - int np = NTimeBinsPerBC * TSN; int ipk = -1; int ipkb = -1; float min = std::numeric_limits::infinity(); @@ -140,7 +139,7 @@ int WaveformCalibQueue::hasData(int isig, const gsl::span& wave, WaveformCalibData& data) { - int np = NTimeBinsPerBC * TSN; - int ipk = -1; - int ipkb = -1; + int ipkb = -1; // Bunch where peak is found + int ipk = -1; // peak position within bunch float min = std::numeric_limits::infinity(); for (int ib = 0; ib < mN; ib++) { int ifound = false; @@ -176,7 +176,7 @@ int WaveformCalibQueue::addData(int isig, const gsl::span data.mFirstValid[itdc]) { - data.mFirstValid[itdc] = ipos; + int ipos = mPeak - ppos; + data.mEntries[ih]++; + // Restrict validity range because of signal jitter + if (ipos > data.mFirstValid[ih]) { + data.mFirstValid[ih] = ipos; } // We know that points are consecutive for (int ib = 0; ib < mN; ib++) { for (int iw = 0; iw < mNW[ib]; iw++) { auto& mywave = wave[iw + mFirstW[ib]]; if (mywave.ch() == isig) { - for (int ip = 0; ip < np; ip++) { + for (int ip = 0; ip < NIS; ip++) { if (ipos >= 0 && ipos < mNP) { - data.mWave[itdc][ipos] += mywave.inter[ip]; + data.mWave[ih][ipos] += mywave.inter[ip]; } ipos++; } @@ -217,10 +217,11 @@ int WaveformCalibQueue::addData(int isig, const gsl::span { int corr_signal = -1; // TDC signal correction int corr_background = -1; // TDC pile-up correction + int debug_output = -1; // Debug output + // TDC Int_t tmod[NTDCChannels] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; // Position of TDC channel in raw data Int_t tch[NTDCChannels] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; // Position of TDC channel in raw data diff --git a/Detectors/ZDC/reconstruction/src/DigiReco.cxx b/Detectors/ZDC/reconstruction/src/DigiReco.cxx index c54000fc58c9e..a2d0d132bd68c 100644 --- a/Detectors/ZDC/reconstruction/src/DigiReco.cxx +++ b/Detectors/ZDC/reconstruction/src/DigiReco.cxx @@ -437,6 +437,19 @@ int DigiReco::process(const gsl::span& orbitdata, cons // Low pass filtering if (mLowPassFilter) { lowPassFilter(); + } else { + // Copy samples + for (int itdc = 0; itdc < NTDCChannels; itdc++) { + auto isig = TDCSignal[itdc]; + for (int ibc = 0; ibc < mNBC; ibc++) { + auto ref_c = mReco[ibc].ref[isig]; + if (ref_c != ZDCRefInitVal) { + for (int is = 0; is < NTimeBinsPerBC; is++) { + mReco[ibc].data[isig][is] = mChData[ref_c].data[is]; + } + } + } + } } // Find consecutive bunch crossings by taking into account just the presence @@ -1107,11 +1120,8 @@ O2_ZDC_DIGIRECO_FLT DigiReco::getPoint(int itdc, int ibeg, int iend, int i) LOG(fatal) << "ib=" << ib << " ibun=" << ibun; return std::numeric_limits::infinity(); } -#ifdef O2_ZDC_RECO_FILTERING return mReco[ibun].data[isig][ip]; // Filtered point -#else - return mChData[mReco[ibun].ref[isig]].data[ip]; // Original point -#endif + // return mChData[mReco[ibun].ref[isig]].data[ip]; // Original point } else { // Do the actual interpolation O2_ZDC_DIGIRECO_FLT y = 0; @@ -1124,11 +1134,8 @@ O2_ZDC_DIGIRECO_FLT DigiReco::getPoint(int itdc, int ibeg, int iend, int i) if (ii < mNsam) { int ip = ii % NTimeBinsPerBC; int ib = ibeg + ii / NTimeBinsPerBC; -#ifdef O2_ZDC_RECO_FILTERING yy = mReco[ib].data[isig][ip]; -#else - yy = mChData[mReco[ib].ref[isig]].data[ip]; -#endif + // yy = mChData[mReco[ib].ref[isig]].data[ip]; } else { // Last acquired point yy = mLastSample; @@ -1147,8 +1154,8 @@ void DigiReco::setPoint(int itdc, int ibeg, int iend, int i) { // This function needs to be used only if mFullInterpolation is true otherwise the // vectors are not allocated - if(!mFullInterpolation){ - LOG(FATAL) << __func__ << " call with mFullInterpolation = " << mFullInterpolation; + if (!mFullInterpolation) { + LOG(fatal) << __func__ << " call with mFullInterpolation = " << mFullInterpolation; return; } constexpr int nsbun = TSN * NTimeBinsPerBC; // Total number of interpolated points per bunch crossing @@ -1209,13 +1216,10 @@ void DigiReco::interpolate(int itdc, int ibeg, int iend) auto ref_beg = mReco[ibeg].ref[isig]; auto ref_end = mReco[iend].ref[isig]; -#ifdef O2_ZDC_RECO_FILTERING mFirstSample = mReco[ibeg].data[isig][0]; mLastSample = mReco[iend].data[isig][MaxTimeBin]; -#else - mFirstSample = mChData[ref_beg].data[0]; - mLastSample = mChData[ref_end].data[MaxTimeBin]; -#endif + // mFirstSample = mChData[ref_beg].data[0]; // Original points + // mLastSample = mChData[ref_end].data[MaxTimeBin]; // Original points // mFullInterpolation turns on full interpolation for debugging // otherwise the interpolation is performed only around actual signal diff --git a/Detectors/ZDC/reconstruction/src/RecoParamZDC.cxx b/Detectors/ZDC/reconstruction/src/RecoParamZDC.cxx index 2efddf5fa34bf..8d22343a1f62e 100644 --- a/Detectors/ZDC/reconstruction/src/RecoParamZDC.cxx +++ b/Detectors/ZDC/reconstruction/src/RecoParamZDC.cxx @@ -26,13 +26,9 @@ void o2::zdc::RecoParamZDC::setBit(uint32_t ibit, bool val) void o2::zdc::RecoParamZDC::print() { bool printed = false; - if (!printed) { - printed = true; - LOG(info) << "RecoParamZDC"; - } if (low_pass_filter >= 0 || full_interpolation >= 0 || corr_signal >= 0 || corr_background >= 0) { if (!printed) { - LOG(info) << "RecoParamZDC"; + LOG(info) << "RecoParamZDC::print()"; printed = true; } if (low_pass_filter >= 0) { @@ -49,6 +45,10 @@ void o2::zdc::RecoParamZDC::print() } printf("\n"); } + if (!printed) { + printed = true; + LOG(info) << "RecoParamZDC::print()"; + } /* Int_t tsh[NTDCChannels] = {4, 4, 4, 4, 4, 4, 4, 4, 4, 4}; // Trigger shift Int_t tth[NTDCChannels] = {8, 8, 8, 8, 8, 8, 8, 8, 8, 8}; // Trigger threshold @@ -91,7 +91,7 @@ void o2::zdc::RecoParamZDC::print() if (modified) { if (!printed) { printed = true; - LOG(info) << "RecoParamZDC"; + LOG(info) << "RecoParamZDC::print()"; } printf("energ_calib: "); for (int i = 0; i < o2::zdc::NChannels; i++) { @@ -111,7 +111,7 @@ void o2::zdc::RecoParamZDC::print() if (modified) { if (!printed) { printed = true; - LOG(info) << "RecoParamZDC"; + LOG(info) << "RecoParamZDC::print()"; } printf("tower_calib: "); for (int i = 0; i < o2::zdc::NChannels; i++) { diff --git a/Detectors/ZDC/workflow/src/DigitRecoSpec.cxx b/Detectors/ZDC/workflow/src/DigitRecoSpec.cxx index b04cc5bba548a..13bcbb4ccafda 100644 --- a/Detectors/ZDC/workflow/src/DigitRecoSpec.cxx +++ b/Detectors/ZDC/workflow/src/DigitRecoSpec.cxx @@ -180,7 +180,7 @@ void DigitRecoSpec::run(ProcessingContext& pc) bool fullinter = mDR.getFullInterpolation(); RecEvent recEvent; LOGF(info, "BC processed during reconstruction %d%s", recAux.size(), (fullinter ? " FullInterpolation" : "")); - uint32_t nte = 0, ntt = 0, nti = 0; + uint32_t nte = 0, ntt = 0, nti = 0, ntw = 0; for (auto reca : recAux) { bool toAddBC = true; int32_t ne = reca.ezdc.size(); @@ -198,13 +198,14 @@ void DigitRecoSpec::run(ProcessingContext& pc) // Add waveform information if (fullinter) { // For the moment only TDC channels are interpolated - if (reca.inter[it].size()==NIS) { + if (reca.inter[it].size() == NIS) { if (toAddBC) { recEvent.addBC(reca); toAddBC = false; } auto isig = TDCSignal[it]; recEvent.addWaveform(isig, reca.inter[it]); + ntw++; } } } @@ -226,7 +227,9 @@ void DigitRecoSpec::run(ProcessingContext& pc) // Event information nti += recEvent.addInfos(reca); } - LOG(info) << "Reconstructed " << ntt << " signal TDCs and " << nte << " ZDC energies and " << nti << " info messages in " << recEvent.mRecBC.size() << "/" << recAux.size() << " b.c."; + LOG(info) << "Reconstructed " << ntt << " signal TDCs and " << nte << " ZDC energies and " + << nti << " info messages in " << recEvent.mRecBC.size() << "/" << recAux.size() << " b.c. and " + << ntw << " waveform chunks"; // TODO: rate information for all channels // TODO: summary of reconstruction to be collected by DQM? pc.outputs().snapshot(Output{"ZDC", "BCREC", 0, Lifetime::Timeframe}, recEvent.mRecBC); From bc94ef26e19b0624d6ab58acd87825c7ca8ec006 Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Fri, 13 May 2022 16:07:02 +0200 Subject: [PATCH 12/40] EPN Waveform workflow --- .../calib/include/ZDCCalib/CalibParamZDC.h | 35 +++++ Detectors/ZDC/calib/src/CalibParamZDC.cxx | 30 ++++ .../ZDC/calib/src/WaveformCalibEPNSpec.cxx | 141 ++++++++++++++++++ .../src/zdc-waveformcalib-epn-workflow.cxx | 42 ++++++ 4 files changed, 248 insertions(+) create mode 100644 Detectors/ZDC/calib/include/ZDCCalib/CalibParamZDC.h create mode 100644 Detectors/ZDC/calib/src/CalibParamZDC.cxx create mode 100644 Detectors/ZDC/calib/src/WaveformCalibEPNSpec.cxx create mode 100644 Detectors/ZDC/calib/src/zdc-waveformcalib-epn-workflow.cxx diff --git a/Detectors/ZDC/calib/include/ZDCCalib/CalibParamZDC.h b/Detectors/ZDC/calib/include/ZDCCalib/CalibParamZDC.h new file mode 100644 index 0000000000000..ab02d04d55e6c --- /dev/null +++ b/Detectors/ZDC/calib/include/ZDCCalib/CalibParamZDC.h @@ -0,0 +1,35 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#ifndef O2_ZDC_CALIBPARAMZDC_H +#define O2_ZDC_CALIBPARAMZDC_H + +#include "CommonUtils/ConfigurableParam.h" +#include "CommonUtils/ConfigurableParamHelper.h" +#include "ZDCBase/Constants.h" + +/// \file CalibParamZDC.h +/// \brief ZDC calibration common parameters +/// \author P. Cortese + +namespace o2 +{ +namespace zdc +{ +struct CalibParamZDC : public o2::conf::ConfigurableParamHelper { + int debug_output = -1; // Debug output + void print(); + O2ParamDef(CalibParamZDC, "CalibParamZDC"); +}; +} // namespace zdc +} // namespace o2 + +#endif diff --git a/Detectors/ZDC/calib/src/CalibParamZDC.cxx b/Detectors/ZDC/calib/src/CalibParamZDC.cxx new file mode 100644 index 0000000000000..a9e2720b4db56 --- /dev/null +++ b/Detectors/ZDC/calib/src/CalibParamZDC.cxx @@ -0,0 +1,30 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#include "Framework/Logger.h" +#include "ZDCCalib/CalibParamZDC.h" + +O2ParamImpl(o2::zdc::CalibParamZDC); + +void o2::zdc::CalibParamZDC::print() +{ + bool printed = false; + if (debug_output >= 0) { + if (!printed) { + LOG(info) << "CalibParamZDC::print()"; + printed = true; + } + if (debug_output >= 0) { + printf(" debug_output=%d", debug_output); + } + printf("\n"); + } +} diff --git a/Detectors/ZDC/calib/src/WaveformCalibEPNSpec.cxx b/Detectors/ZDC/calib/src/WaveformCalibEPNSpec.cxx new file mode 100644 index 0000000000000..84ec93c0e75ad --- /dev/null +++ b/Detectors/ZDC/calib/src/WaveformCalibEPNSpec.cxx @@ -0,0 +1,141 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// @file WaveformCalibEPNSpec.cxx +/// @brief ZDC reconstruction +/// @author pietro.cortese@cern.ch + +#include +#include +#include +#include "CCDB/BasicCCDBManager.h" +#include "CCDB/CCDBTimeStampUtils.h" +#include "Framework/Logger.h" +#include "Framework/ControlService.h" +#include "Framework/ConfigParamRegistry.h" +#include "Framework/CCDBParamSpec.h" +#include "Framework/DataRefUtils.h" +#include "DetectorsCommonDataFormats/DetID.h" +#include "DataFormatsZDC/BCData.h" +#include "DataFormatsZDC/ChannelData.h" +#include "DataFormatsZDC/OrbitData.h" +#include "DataFormatsZDC/RecEvent.h" +#include "ZDCBase/ModuleConfig.h" +#include "CommonUtils/NameConf.h" +#include "CCDB/BasicCCDBManager.h" +#include "CCDB/CCDBTimeStampUtils.h" +#include "ZDCCalib/WaveformCalibData.h" +#include "ZDCCalib/WaveformCalibEPNSpec.h" + +using namespace o2::framework; + +namespace o2 +{ +namespace zdc +{ + +WaveformCalibEPNSpec::WaveformCalibEPNSpec() +{ + mTimer.Stop(); + mTimer.Reset(); +} + +WaveformCalibEPNSpec::WaveformCalibEPNSpec(const int verbosity) : mVerbosity(verbosity) +{ + mTimer.Stop(); + mTimer.Reset(); +} + +void WaveformCalibEPNSpec::init(o2::framework::InitContext& ic) +{ + mVerbosity = ic.options().get("verbosity-level"); +} + +void WaveformCalibEPNSpec::updateTimeDependentParams(ProcessingContext& pc) +{ + // we call these methods just to trigger finaliseCCDB callback + pc.inputs().get("wavecalibconfig"); +} + +void WaveformCalibEPNSpec::run(ProcessingContext& pc) +{ + updateTimeDependentParams(pc); + if (!mInitialized) { + mInitialized = true; + std::string loadedConfFiles = "Loaded ZDC configuration files:"; + // WaveformCalib configuration + auto interConfig = pc.inputs().get("wavecalibconfig"); + if (!interConfig) { + LOG(fatal) << "Missing WaveformCalibConfig calibration object"; + return; + } else { + loadedConfFiles += " WaveformCalibConfig"; + if (mVerbosity > DbgZero) { + LOG(info) << "Loaded WaveformCalibConfig configuration object"; + interConfig->print(); + } + } + + mWorker.setConfig(interConfig.get()); + + LOG(info) << loadedConfFiles; + mTimer.CpuTime(); + mTimer.Start(false); + } + + const auto ref = pc.inputs().getFirstValid(true); + auto creationTime = DataRefUtils::getHeader(ref)->creation; // approximate time in ms + WaveformCalibData& data = mWorker.getData(); +// data.setCreationTime(creationTime); + + auto bcrec = pc.inputs().get>("bcrec"); + auto energy = pc.inputs().get>("energy"); + auto tdc = pc.inputs().get>("tdc"); + auto info = pc.inputs().get>("info"); + auto wave = pc.inputs().get>("wave"); + + // Process reconstructed data + mWorker.process(bcrec, energy, tdc, info, wave); + + // Send intermediate calibration data and debug histograms + o2::framework::Output output("ZDC", "WAVECALIBDATA", 0, Lifetime::Timeframe); + pc.outputs().snapshot(output, mWorker.mData); +} + +void WaveformCalibEPNSpec::endOfStream(EndOfStreamContext& ec) +{ + mWorker.endOfRun(); + mTimer.Stop(); + LOGF(info, "ZDC EPN Waveform calibration total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1); +} + +framework::DataProcessorSpec getWaveformCalibEPNSpec() +{ + std::vector inputs; + inputs.emplace_back("bcrec", "ZDC", "BCREC", 0, Lifetime::Timeframe); + inputs.emplace_back("energy", "ZDC", "ENERGY", 0, Lifetime::Timeframe); + inputs.emplace_back("tdc", "ZDC", "TDCDATA", 0, Lifetime::Timeframe); + inputs.emplace_back("info", "ZDC", "INFO", 0, Lifetime::Timeframe); + inputs.emplace_back("wave", "ZDC", "WAVE", 0, Lifetime::Timeframe); + inputs.emplace_back("wavecalibconfig", "ZDC", "WAVECALIBCONFIG", 0, Lifetime::Condition, o2::framework::ccdbParamSpec(fmt::format("{}", o2::zdc::CCDBPathWaveformCalibConfig.data()))); + + std::vector outputs; + outputs.emplace_back("ZDC", "WAVECALIBDATA", 0, Lifetime::Timeframe); + return DataProcessorSpec{ + "zdc-waveformcalib-epn", + inputs, + outputs, + AlgorithmSpec{adaptFromTask()}, + o2::framework::Options{{"verbosity-level", o2::framework::VariantType::Int, 0, {"Verbosity level"}}}}; +} + +} // namespace zdc +} // namespace o2 diff --git a/Detectors/ZDC/calib/src/zdc-waveformcalib-epn-workflow.cxx b/Detectors/ZDC/calib/src/zdc-waveformcalib-epn-workflow.cxx new file mode 100644 index 0000000000000..a0d5320ea87ad --- /dev/null +++ b/Detectors/ZDC/calib/src/zdc-waveformcalib-epn-workflow.cxx @@ -0,0 +1,42 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#include "Framework/DataProcessorSpec.h" +#include "DetectorsRaw/HBFUtilsInitializer.h" +#include "ZDCCalib/WaveformCalibEPNSpec.h" + +using namespace o2::framework; + +// ------------------------------------------------------------------ +void customize(std::vector& policies) +{ + o2::raw::HBFUtilsInitializer::addNewTimeSliceCallback(policies); +} + +// we need to add workflow options before including Framework/runDataProcessing +void customize(std::vector& workflowOptions) +{ + // option allowing to set parameters + o2::raw::HBFUtilsInitializer::addConfigOption(workflowOptions); +} + +// ------------------------------------------------------------------ + +#include "Framework/runDataProcessing.h" + +WorkflowSpec defineDataProcessing(ConfigContext const& configcontext) +{ + WorkflowSpec specs; + specs.emplace_back(o2::zdc::getWaveformCalibEPNSpec()); + // configure dpl timer to inject correct firstTFOrbit: start from the 1st orbit of TF containing 1st sampled orbit + o2::raw::HBFUtilsInitializer hbfIni(configcontext, specs); + return specs; +} From 29860bef60c30dcda0406abb0f613668e1c2f855 Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Fri, 13 May 2022 17:03:06 +0200 Subject: [PATCH 13/40] Correct trailing spaces --- Detectors/ZDC/calib/src/WaveformCalibQueue.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx index fe45a22aba527..5c98bb7d260fd 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx @@ -162,7 +162,7 @@ int WaveformCalibQueue::hasData(int isig, const gsl::span& wave, WaveformCalibData& data) { From 155245394116619a026a98644fdb5c8375c2eb22 Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Fri, 13 May 2022 17:32:31 +0200 Subject: [PATCH 14/40] Add waveforms --- Detectors/ZDC/calib/src/WaveformCalibData.cxx | 50 ++++++++++++------- 1 file changed, 31 insertions(+), 19 deletions(-) diff --git a/Detectors/ZDC/calib/src/WaveformCalibData.cxx b/Detectors/ZDC/calib/src/WaveformCalibData.cxx index 5f353f0ad3c0d..cdb2743cfed59 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibData.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibData.cxx @@ -16,30 +16,42 @@ using namespace o2::zdc; void WaveformCalibData::print() const { - for (int i = 0; i < NH; i++) { - LOGF(info, "%d ", i); + for (int32_t ih = 0; ih < NH; ih++) { + LOGF(info, "WaveformCalibData [%llu : %llu]: entries=%d [%d:%d:%d]", mCTimeBeg, mCTimeEnd, mEntries[ih], mFirstValid[ih], mPeak, mLastValid[ih]); } } WaveformCalibData& WaveformCalibData::operator+=(const WaveformCalibData& other) { -// for (int32_t ih = 0; ih < NH; ih++) { -// for (int32_t i = 0; i < NPAR; i++) { -// for (int32_t j = 0; j < NPAR; j++) { -// mSum[ih][i][j] += other.mSum[ih][i][j]; -// } -// } -// } -// if (mCTimeBeg == 0 || other.mCTimeBeg < mCTimeBeg) { -// mCTimeBeg = other.mCTimeBeg; -// } -// if (other.mCTimeEnd > mCTimeEnd) { -// mCTimeEnd = other.mCTimeEnd; -// } -// //#ifdef O2_ZDC_DEBUG -// LOGF(info, "WaveformCalibData [%llu : %llu]: %s=%d %s=%d %s=%d %s=%d %s=%d", mCTimeBeg, mCTimeEnd, DN[0], getEntries(0), DN[1], getEntries(1), -// DN[2], getEntries(2), DN[3], getEntries(3), DN[4], getEntries(4)); -// //#endif + if (mN != other.mN) { + LOG(fatal) << "Mixing waveform with different configurations mN = " << mN << " != " << other.mN; + return *this; + } + if (mPeak != other.mPeak) { + LOG(fatal) << "Mixing waveform with different configurations mPeak = " << mPeak << " != " << other.mPeak; + return *this; + } + if (mCTimeBeg == 0 || other.mCTimeBeg < mCTimeBeg) { + mCTimeBeg = other.mCTimeBeg; + } + if (other.mCTimeEnd > mCTimeEnd) { + mCTimeEnd = other.mCTimeEnd; + } + for (int32_t ih = 0; ih < NH; ih++) { + if (mFirstValid[ih] > other.mFirstValid[ih]) { + mFirstValid[ih] = other.mFirstValid[ih]; + } + if (mLastValid[ih] > other.mLastValid[ih]) { + mLastValid[ih] = other.mLastValid[ih]; + } + mEntries[ih] = mEntries[ih] + other.mEntries[ih]; + for (int32_t i = mFirstValid[ih]; i <= mLastValid[ih]; i++) { + mWave[ih][i] = mWave[ih][i] + other.mWave[ih][i]; + } + } + //#ifdef O2_ZDC_DEBUG + print(); + //#endif return *this; } From 3ee31eb6115d3a8e2900a4a4496fd2f5cd5772e1 Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Wed, 18 May 2022 18:53:37 +0200 Subject: [PATCH 15/40] WIP --- Detectors/ZDC/calib/CMakeLists.txt | 2 ++ .../ZDC/calib/include/ZDCCalib/InterCalib.h | 4 +-- .../include/ZDCCalib/WaveformCalibConfig.h | 1 + .../include/ZDCCalib/WaveformCalibData.h | 2 +- .../calib/include/ZDCCalib/WaveformCalibEPN.h | 6 ---- Detectors/ZDC/calib/src/CalibParamZDC.cxx | 6 ++-- Detectors/ZDC/calib/src/WaveformCalibData.cxx | 33 +++++++++++++++++ Detectors/ZDC/calib/src/WaveformCalibEPN.cxx | 36 +++++-------------- .../calib/src/zdc-intercalib-epn-workflow.cxx | 5 +++ .../src/zdc-waveformcalib-epn-workflow.cxx | 5 +++ 10 files changed, 59 insertions(+), 41 deletions(-) diff --git a/Detectors/ZDC/calib/CMakeLists.txt b/Detectors/ZDC/calib/CMakeLists.txt index 3f02bc8d825cf..3a2ef444baa6d 100644 --- a/Detectors/ZDC/calib/CMakeLists.txt +++ b/Detectors/ZDC/calib/CMakeLists.txt @@ -17,6 +17,7 @@ o2_add_library(ZDCCalib src/InterCalibEPN.cxx src/InterCalibEPNSpec.cxx src/WaveformCalibConfig.cxx + src/WaveformCalib.cxx src/WaveformCalibEPN.cxx src/WaveformCalibEPNSpec.cxx src/WaveformCalibQueue.cxx @@ -46,6 +47,7 @@ o2_target_root_dictionary(ZDCCalib include/ZDCCalib/InterCalibEPN.h include/ZDCCalib/InterCalibEPNSpec.h include/ZDCCalib/WaveformCalibConfig.h + include/ZDCCalib/WaveformCalib.h include/ZDCCalib/WaveformCalibEPN.h include/ZDCCalib/WaveformCalibEPNSpec.h include/ZDCCalib/WaveformCalibQueue.h diff --git a/Detectors/ZDC/calib/include/ZDCCalib/InterCalib.h b/Detectors/ZDC/calib/include/ZDCCalib/InterCalib.h index b32711f9edc6d..54e51dbb30974 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/InterCalib.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/InterCalib.h @@ -25,8 +25,8 @@ #include "ZDCReconstruction/ZDCTowerParam.h" #include "ZDCCalib/InterCalibConfig.h" #include "CCDB/CcdbObjectInfo.h" -#ifndef ALICEO2_ZDC_INTERCALIB_H_ -#define ALICEO2_ZDC_INTERCALIB_H_ +#ifndef ALICEO2_ZDC_INTERCALIB_H +#define ALICEO2_ZDC_INTERCALIB_H namespace o2 { namespace zdc diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h index 78456c3be9ae9..bdd9781a1ed50 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h @@ -65,6 +65,7 @@ struct WaveformCalibConfig { int getFirst() const{ return ibeg; } + int getLast() const{ return iend; } diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h index a98a952b1f55b..0ee2bcaa63e6c 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h @@ -15,7 +15,6 @@ #include "ZDCBase/Constants.h" #include "ZDCCalib/WaveformCalibConfig.h" #include -#include /// \file WaveformCalibData.h /// \brief Waveform calibration intermediate data @@ -46,6 +45,7 @@ struct WaveformCalibData { void print() const; void setCreationTime(uint64_t ctime); void setN(int n); + int write(const std::string fn); ClassDefNV(WaveformCalibData, 1); }; diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h index 33e9a6a0fac65..196bc4a2ef1b4 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h @@ -9,13 +9,7 @@ // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. -#include #include -#include -#include -#include -#include -#include #include "ZDCBase/Constants.h" #include "DataFormatsZDC/RecEvent.h" #include "DataFormatsZDC/ZDCWaveform.h" diff --git a/Detectors/ZDC/calib/src/CalibParamZDC.cxx b/Detectors/ZDC/calib/src/CalibParamZDC.cxx index a9e2720b4db56..bf23926b60286 100644 --- a/Detectors/ZDC/calib/src/CalibParamZDC.cxx +++ b/Detectors/ZDC/calib/src/CalibParamZDC.cxx @@ -18,10 +18,8 @@ void o2::zdc::CalibParamZDC::print() { bool printed = false; if (debug_output >= 0) { - if (!printed) { - LOG(info) << "CalibParamZDC::print()"; - printed = true; - } + LOG(info) << "CalibParamZDC::print()"; + printed = true; if (debug_output >= 0) { printf(" debug_output=%d", debug_output); } diff --git a/Detectors/ZDC/calib/src/WaveformCalibData.cxx b/Detectors/ZDC/calib/src/WaveformCalibData.cxx index cdb2743cfed59..ecdab90679fd7 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibData.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibData.cxx @@ -9,6 +9,9 @@ // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. +#include +#include +#include #include "Framework/Logger.h" #include "ZDCCalib/WaveformCalibData.h" @@ -85,3 +88,33 @@ void WaveformCalibData::setN(int n) LOG(fatal) << "WaveformCalibData " << __func__ << " wrong stored b.c. setting " << n << " not in range [0:" << WaveformCalibConfig::NBT << "]"; } } + +int WaveformCalibData::write(const std::string fn) +{ + TDirectory* cwd = gDirectory; + TFile* f = new TFile(fn.data(), "recreate"); + if (f->IsZombie()) { + LOG(error) << "Cannot create file: " << fn; + return 1; + } + for (int32_t ih = 0; ih < NH; ih++) { + if (mEntries[ih] > 0) { + // For the moment we study only TDC channels + int isig = TDCSignal[ih]; + TString n = TString::Format("h%d", isig); + TString t = TString::Format("Waveform %d %s", isig, ChannelNames[isig].data()); + int nbx = mLastValid[ih] - mFirstValid[ih] + 1; + int min = mFirstValid[ih] - mPeak - 0.5; + int max = mLastValid[ih] - mPeak + 0.5; + TH1F h(n, t, nbx, min, max); + for (int ibx = 0; ibx < nbx; ibx++) { + h.SetBinContent(ibx + 1, mWave[ih][mFirstValid[ih] + ibx]); + } + h.SetEntries(mEntries[ih]); + h.Write("", TObject::kOverwrite); + } + } + f->Close(); + cwd->cd(); + return 0; +} diff --git a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx index 317d373ff71ac..d1b9be1337457 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx @@ -29,15 +29,20 @@ int WaveformCalibEPN::init() return -1; } + auto* cfg = mWaveformCalibConfig; + if (mVerbosity > DbgZero) { + mWaveformCalibConfig->print(); + } + // Inspect reconstruction parameters o2::zdc::CalibParamZDC& opt = const_cast(CalibParamZDC::Instance()); opt.print(); + if (opt.debug_output > 0) { setSaveDebugHistos(); } - auto* cfg = mWaveformCalibConfig; - mQueue.configure(mWaveformCalibConfig); + mQueue.configure(cfg); // number of bins mNBin = cfg->nbun * TSN; @@ -98,30 +103,5 @@ int WaveformCalibEPN::endOfRun() int WaveformCalibEPN::write(const std::string fn) { - TDirectory* cwd = gDirectory; - TFile* f = new TFile(fn.data(), "recreate"); - if (f->IsZombie()) { - LOG(error) << "Cannot create file: " << fn; - return 1; - } - for (int32_t ih = 0; ih < NH; ih++) { - if (mData.mEntries[ih] > 0) { - // For the moment we study only TDC channels - int isig = TDCSignal[ih]; - TString n = TString::Format("h%d", isig); - TString t = TString::Format("Waveform %d %s", isig, ChannelNames[isig].data()); - int nbx = mData.mLastValid[ih] - mData.mFirstValid[ih] + 1; - int min = mData.mFirstValid[ih] - mData.mPeak - 0.5; - int max = mData.mLastValid[ih] - mData.mPeak + 0.5; - TH1F h(n, t, nbx, min, max); - for (int ibx = 0; ibx < nbx; ibx++) { - h.SetBinContent(ibx + 1, mData.mWave[ih][mData.mFirstValid[ih] + ibx]); - } - h.SetEntries(mData.mEntries[ih]); - h.Write("", TObject::kOverwrite); - } - } - f->Close(); - cwd->cd(); - return 0; + return mData.write(fn); } diff --git a/Detectors/ZDC/calib/src/zdc-intercalib-epn-workflow.cxx b/Detectors/ZDC/calib/src/zdc-intercalib-epn-workflow.cxx index 059d50f345a27..9fab9a7b0ca18 100644 --- a/Detectors/ZDC/calib/src/zdc-intercalib-epn-workflow.cxx +++ b/Detectors/ZDC/calib/src/zdc-intercalib-epn-workflow.cxx @@ -10,6 +10,7 @@ // or submit itself to any jurisdiction. #include "Framework/DataProcessorSpec.h" +#include "CommonUtils/ConfigurableParam.h" #include "DetectorsRaw/HBFUtilsInitializer.h" #include "ZDCCalib/InterCalibEPNSpec.h" @@ -25,6 +26,8 @@ void customize(std::vector& policies) void customize(std::vector& workflowOptions) { // option allowing to set parameters + std::string keyvaluehelp("Semicolon separated key=value strings ..."); + workflowOptions.push_back(ConfigParamSpec{"configKeyValues", VariantType::String, "", {keyvaluehelp}}); o2::raw::HBFUtilsInitializer::addConfigOption(workflowOptions); } @@ -34,6 +37,8 @@ void customize(std::vector& workflowOptions) WorkflowSpec defineDataProcessing(ConfigContext const& configcontext) { + // Update the (declared) parameters if changed from the command line + o2::conf::ConfigurableParam::updateFromString(configcontext.options().get("configKeyValues")); WorkflowSpec specs; specs.emplace_back(o2::zdc::getInterCalibEPNSpec()); // configure dpl timer to inject correct firstTFOrbit: start from the 1st orbit of TF containing 1st sampled orbit diff --git a/Detectors/ZDC/calib/src/zdc-waveformcalib-epn-workflow.cxx b/Detectors/ZDC/calib/src/zdc-waveformcalib-epn-workflow.cxx index a0d5320ea87ad..bb3e66f6991e1 100644 --- a/Detectors/ZDC/calib/src/zdc-waveformcalib-epn-workflow.cxx +++ b/Detectors/ZDC/calib/src/zdc-waveformcalib-epn-workflow.cxx @@ -10,6 +10,7 @@ // or submit itself to any jurisdiction. #include "Framework/DataProcessorSpec.h" +#include "CommonUtils/ConfigurableParam.h" #include "DetectorsRaw/HBFUtilsInitializer.h" #include "ZDCCalib/WaveformCalibEPNSpec.h" @@ -25,6 +26,8 @@ void customize(std::vector& policies) void customize(std::vector& workflowOptions) { // option allowing to set parameters + std::string keyvaluehelp("Semicolon separated key=value strings ..."); + workflowOptions.push_back(ConfigParamSpec{"configKeyValues", VariantType::String, "", {keyvaluehelp}}); o2::raw::HBFUtilsInitializer::addConfigOption(workflowOptions); } @@ -34,6 +37,8 @@ void customize(std::vector& workflowOptions) WorkflowSpec defineDataProcessing(ConfigContext const& configcontext) { + // Update the (declared) parameters if changed from the command line + o2::conf::ConfigurableParam::updateFromString(configcontext.options().get("configKeyValues")); WorkflowSpec specs; specs.emplace_back(o2::zdc::getWaveformCalibEPNSpec()); // configure dpl timer to inject correct firstTFOrbit: start from the 1st orbit of TF containing 1st sampled orbit From 6a6664e086fee7852cccb2883e3547dc89e66eaf Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Wed, 18 May 2022 18:53:56 +0200 Subject: [PATCH 16/40] WIP --- .../calib/include/ZDCCalib/WaveformCalib.h | 71 ++++++ .../include/ZDCCalib/WaveformCalibSpec.h | 61 ++++++ Detectors/ZDC/calib/src/WaveformCalib.cxx | 126 +++++++++++ Detectors/ZDC/calib/src/WaveformCalibSpec.cxx | 204 ++++++++++++++++++ 4 files changed, 462 insertions(+) create mode 100644 Detectors/ZDC/calib/include/ZDCCalib/WaveformCalib.h create mode 100644 Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibSpec.h create mode 100644 Detectors/ZDC/calib/src/WaveformCalib.cxx create mode 100644 Detectors/ZDC/calib/src/WaveformCalibSpec.cxx diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalib.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalib.h new file mode 100644 index 0000000000000..c6a3211417ec1 --- /dev/null +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalib.h @@ -0,0 +1,71 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#include +#include +#include +#include +#include +#include +#include +#include "ZDCBase/Constants.h" +#include "ZDCCalib/WaveformCalibData.h" +#include "ZDCCalib/WaveformCalibConfig.h" +#include "CCDB/CcdbObjectInfo.h" +#ifndef ALICEO2_ZDC_WAVEFORMCALIB_H +#define ALICEO2_ZDC_WAVEFORMCALIB_H +namespace o2 +{ +namespace zdc +{ +class WaveformCalib +{ + using CcdbObjectInfo = o2::ccdb::CcdbObjectInfo; + + public: + WaveformCalib() = default; + int init(); + static constexpr int NH = WaveformCalibConfig::NH; + void clear(int ih = -1); + int process(const WaveformCalibData& data); // Calibration of RUN3 data - aggregator node + int endOfRun(); // Perform minimization + int write(const std::string fn = "ZDCWaveformCalib.root"); + + CcdbObjectInfo& getCcdbObjectInfo() { return mInfo; } + + void setWaveformCalibConfig(const WaveformCalibConfig* param) { mWaveformCalibConfig = param; }; + const WaveformCalibConfig* getWaveformCalibConfig() const { return mWaveformCalibConfig; }; + + void setVerbosity(int v) { mVerbosity = v; } + int getVerbosity() const { return mVerbosity; } + + void setSaveDebugHistos() { mSaveDebugHistos = true; } + void setDontSaveDebugHistos() { mSaveDebugHistos = false; } + + private: + WaveformCalibData mData; + bool mInitDone = false; + bool mSaveDebugHistos = false; + int32_t mVerbosity = DbgMinimal; + static std::mutex mMtx; /// mutex for critical section + double mPar[NH][NPAR] = {0}; + double mErr[NH][NPAR] = {0}; + const WaveformCalibConfig* mWaveformCalibConfig = nullptr; /// Configuration of intercalibration + const ZDCEnergyParam* mEnergyParam = nullptr; /// Energy calibration object + const ZDCTowerParam* mTowerParam = nullptr; /// Tower calibration object + ZDCTowerParam mTowerParamUpd; /// Updated tower calibration object + CcdbObjectInfo mInfo; /// CCDB Info + void assign(int ih, bool ismod); /// Assign updated calibration object +}; +} // namespace zdc +} // namespace o2 + +#endif diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibSpec.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibSpec.h new file mode 100644 index 0000000000000..977dda7773249 --- /dev/null +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibSpec.h @@ -0,0 +1,61 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// @file InterCalibSpec.h +/// @brief ZDC intercalibration +/// @author pietro.cortese@cern.ch + +#ifndef O2_ZDC_WAVEFORMCALIB_SPEC +#define O2_ZDC_WAVEFORMCALIB_SPEC + +#include +#include "Framework/Logger.h" +#include "Framework/DataProcessorSpec.h" +#include "Framework/DataAllocator.h" +#include "Framework/Task.h" +#include "CommonDataFormat/FlatHisto1D.h" +#include "CommonDataFormat/FlatHisto2D.h" +#include "DataFormatsZDC/WaveformCalibData.h" +#include "CommonUtils/NameConf.h" +#include "ZDCCalib/WaveformCalib.h" +#include "ZDCCalib/WaveformCalibConfig.h" +#include "DetectorsCalibration/Utils.h" +#include "CCDB/CcdbObjectInfo.h" + +namespace o2 +{ +namespace zdc +{ + +class WaveformCalibSpec : public o2::framework::Task +{ + public: + WaveformCalibSpec(); + WaveformCalibSpec(const int verbosity); + ~WaveformCalibSpec() override = default; + void init(o2::framework::InitContext& ic) final; + void updateTimeDependentParams(o2::framework::ProcessingContext& pc); + void run(o2::framework::ProcessingContext& pc) final; + void endOfStream(o2::framework::EndOfStreamContext& ec) final; + void sendOutput(o2::framework::DataAllocator& output); + + private: + int mVerbosity = DbgMinimal; // Verbosity level + WaveformCalib mWorker; // Intercalibration object + TStopwatch mTimer; +}; + +framework::DataProcessorSpec getWaveformCalibSpec(); + +} // namespace zdc +} // namespace o2 + +#endif diff --git a/Detectors/ZDC/calib/src/WaveformCalib.cxx b/Detectors/ZDC/calib/src/WaveformCalib.cxx new file mode 100644 index 0000000000000..5ce8c0f990283 --- /dev/null +++ b/Detectors/ZDC/calib/src/WaveformCalib.cxx @@ -0,0 +1,126 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#include +#include +#include +#include +#include +#include +#include +#include +#include "CommonUtils/MemFileHelper.h" +#include "ZDCCalib/WaveformCalib.h" +#include "ZDCReconstruction/ZDCEnergyParam.h" +#include "ZDCReconstruction/ZDCTowerParam.h" +#include "Framework/Logger.h" +#include "CCDB/CcdbApi.h" + +using namespace o2::zdc; + +int WaveformCalib::init() +{ + if (mWaveformCalibConfig == nullptr) { + LOG(fatal) << "o2::zdc::WaveformCalib: missing configuration object"; + return -1; + } + clear(); + mInitDone = true; + return 0; +} + +//______________________________________________________________________________ +// Update calibration object +int WaveformCalib::endOfRun() +{ + if (mVerbosity > DbgZero) { + LOGF(info, "Computing intercalibration coefficients"); + } + auto clName = o2::utils::MemFileHelper::getClassName(mTowerParamUpd); + mInfo.setObjectType(clName); + auto flName = o2::ccdb::CcdbApi::generateFileName(clName); + mInfo.setFileName(flName); + mInfo.setPath(CCDBPathTowerCalib); + std::map md; + md["config"] = mWaveformCalibConfig->desc; + mInfo.setMetaData(md); + uint64_t starting = mData.mCTimeBeg; + if (starting >= 10000) { + starting = starting - 10000; // start 10 seconds before + } + uint64_t stopping = mData.mCTimeEnd + 10000; // stop 10 seconds after + mInfo.setStartValidityTimestamp(starting); + mInfo.setEndValidityTimestamp(stopping); + + if (mSaveDebugHistos) { + write(); + } + return 0; +} + +void WaveformCalib::clear(int ih) +{ + mData.mSum[ii][i][j] = 0; +} + +int WaveformCalib::process(const WaveformCalibData& data) +{ + if (!mInitDone) { + init(); + } + mData += data; + return 0; +} + +int WaveformCalib::write(const std::string fn) +{ + TDirectory* cwd = gDirectory; + TFile* f = new TFile(fn.data(), "recreate"); + if (f->IsZombie()) { + LOG(error) << "Cannot create file: " << fn; + return 1; + } + for (int32_t ih = 0; ih < (2 * NH); ih++) { + if (mHUnc[ih]) { + auto p = mHUnc[ih]->createTH1F(WaveformCalib::mHUncN[ih]); + p->SetTitle(WaveformCalib::mHUncT[ih]); + p->Write("", TObject::kOverwrite); + } + } + for (int32_t ih = 0; ih < NH; ih++) { + if (mCUnc[ih]) { + auto p = mCUnc[ih]->createTH2F(WaveformCalib::mCUncN[ih]); + p->SetTitle(WaveformCalib::mCUncT[ih]); + p->Write("", TObject::kOverwrite); + } + } + // Only after replay of RUN2 data + for (int32_t ih = 0; ih < NH; ih++) { + if (mHCorr[ih]) { + mHCorr[ih]->Write("", TObject::kOverwrite); + } + } + for (int32_t ih = 0; ih < NH; ih++) { + if (mCCorr[ih]) { + mCCorr[ih]->Write("", TObject::kOverwrite); + } + } + // Minimization output + const char* mntit[NH] = {"mZNA", "mZPA", "mZNC", "mZPC", "mZEM"}; + for (int32_t ih = 0; ih < NH; ih++) { + if (mMn[ih]) { + mMn[ih]->Write(mntit[ih], TObject::kOverwrite); + } + } + f->Close(); + cwd->cd(); + return 0; +} diff --git a/Detectors/ZDC/calib/src/WaveformCalibSpec.cxx b/Detectors/ZDC/calib/src/WaveformCalibSpec.cxx new file mode 100644 index 0000000000000..21801d81a7cae --- /dev/null +++ b/Detectors/ZDC/calib/src/WaveformCalibSpec.cxx @@ -0,0 +1,204 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// @file WaveformCalibSpec.cxx +/// @brief ZDC reconstruction +/// @author pietro.cortese@cern.ch + +#include +#include +#include +#include "CCDB/BasicCCDBManager.h" +#include "CCDB/CCDBTimeStampUtils.h" +#include "CCDB/CcdbApi.h" +#include "Framework/Logger.h" +#include "Framework/ControlService.h" +#include "Framework/ConfigParamRegistry.h" +#include "Framework/CCDBParamSpec.h" +#include "DetectorsCommonDataFormats/DetID.h" +#include "DataFormatsZDC/BCData.h" +#include "DataFormatsZDC/ChannelData.h" +#include "DataFormatsZDC/OrbitData.h" +#include "DataFormatsZDC/RecEvent.h" +#include "ZDCBase/ModuleConfig.h" +#include "CommonUtils/NameConf.h" +#include "CommonUtils/MemFileHelper.h" +#include "CCDB/BasicCCDBManager.h" +#include "CCDB/CCDBTimeStampUtils.h" +#include "ZDCReconstruction/RecoConfigZDC.h" +#include "ZDCCalib/WaveformCalibSpec.h" + +using namespace o2::framework; + +namespace o2 +{ +namespace zdc +{ + +WaveformCalibSpec::WaveformCalibSpec() +{ + mTimer.Stop(); + mTimer.Reset(); +} + +WaveformCalibSpec::WaveformCalibSpec(const int verbosity) : mVerbosity(verbosity) +{ + mTimer.Stop(); + mTimer.Reset(); +} + +void WaveformCalibSpec::init(o2::framework::InitContext& ic) +{ + // int minEnt = std::max(300, ic.options().get("min-entries")); + // int nb = std::max(500, ic.options().get("nbins")); + // int slotL = ic.options().get("tf-per-slot"); + // int delay = ic.options().get("max-delay"); + mVerbosity = ic.options().get("verbosity-level"); + mWaveformCalib.setVerbosity(mVerbosity); + mTimer.CpuTime(); + mTimer.Start(false); +} + +void WaveformCalibSpec::updateTimeDependentParams(ProcessingContext& pc) +{ + // we call these methods just to trigger finaliseCCDB callback + std::string loadedConfFiles = "Loaded ZDC configuration files:"; + // Energy calibration + auto energyParam = pc.inputs().get("energycalib"); + if (!energyParam) { + LOG(fatal) << "Missing ZDCEnergyParam calibration object"; + return; + } else { + loadedConfFiles += " ZDCEnergyParam"; + if (mVerbosity > DbgMinimal) { + LOG(info) << "Loaded Energy calibration ZDCEnergyParam"; + energyParam->print(); + } + } + + // Tower calibration + auto towerParam = pc.inputs().get("towercalib"); + if (!towerParam) { + LOG(fatal) << "Missing ZDCTowerParam calibration object"; + return; + } else { + loadedConfFiles += " ZDCTowerParam"; + if (mVerbosity > DbgMinimal) { + LOG(info) << "Loaded Tower calibration ZDCTowerParam"; + towerParam->print(); + } + } + + // WaveformCalib configuration + auto interConfig = pc.inputs().get("intercalibconfig"); + if (!interConfig) { + LOG(fatal) << "Missing WaveformCalibConfig calibration WaveformCalibConfig"; + return; + } else { + loadedConfFiles += " WaveformCalibConfig"; + if (mVerbosity > DbgMinimal) { + LOG(info) << "Loaded WaveformCalib configuration object"; + interConfig->print(); + } + } + + LOG(info) << loadedConfFiles; + + mWaveformCalib.setEnergyParam(energyParam.get()); + mWaveformCalib.setTowerParam(towerParam.get()); + mWaveformCalib.setWaveformCalibConfig(interConfig.get()); +} + +void WaveformCalibSpec::run(ProcessingContext& pc) +{ + updateTimeDependentParams(pc); + auto data = pc.inputs().get("intercalibdata"); + mWaveformCalib.process(data); + for (int ih = 0; ih < (2 * WaveformCalibData::NH); ih++) { + o2::dataformats::FlatHisto1D histoView(pc.inputs().get>(fmt::format("inter_1dh{}", ih).data())); + mWaveformCalib.add(ih, histoView); + } + for (int ih = 0; ih < WaveformCalibData::NH; ih++) { + o2::dataformats::FlatHisto2D histoView(pc.inputs().get>(fmt::format("inter_2dh{}", ih).data())); + mWaveformCalib.add(ih, histoView); + } +} + +void WaveformCalibSpec::endOfStream(EndOfStreamContext& ec) +{ + mWaveformCalib.endOfRun(); + mTimer.Stop(); + sendOutput(ec.outputs()); + LOGF(info, "ZDC Waveformcalibration total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1); +} + +//________________________________________________________________ +void WaveformCalibSpec::sendOutput(o2::framework::DataAllocator& output) +{ + // 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& payload = mWaveformCalib.getTowerParamUpd(); + auto& info = mWaveformCalib.getCcdbObjectInfo(); + auto image = o2::ccdb::CcdbApi::createObjectImage(&payload, &info); + if (mVerbosity > DbgMinimal) { + payload.print(); + } + LOG(info) << "Sending object " << info.getPath() << "/" << info.getFileName() << " of size " << image->size() + << " bytes, valid for " << info.getStartValidityTimestamp() << " : " << info.getEndValidityTimestamp(); + output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, "ZDC_Waveformcalib", 0}, *image.get()); // vector + output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, "ZDC_Waveformcalib", 0}, info); // root-serialized + // TODO: reset the outputs once they are already sent (is it necessary?) + // mWaveformCalib.init(); +} + +framework::DataProcessorSpec getWaveformCalibSpec() +{ + using device = o2::zdc::WaveformCalibSpec; + using clbUtils = o2::calibration::Utils; + + std::vector inputs; + inputs.emplace_back("intercalibconfig", "ZDC", "INTERCALIBCONFIG", 0, Lifetime::Condition, o2::framework::ccdbParamSpec(fmt::format("{}", o2::zdc::CCDBPathWaveformCalibConfig.data()))); + inputs.emplace_back("energycalib", "ZDC", "ENERGYCALIB", 0, Lifetime::Condition, o2::framework::ccdbParamSpec(fmt::format("{}", o2::zdc::CCDBPathEnergyCalib.data()))); + inputs.emplace_back("towercalib", "ZDC", "TOWERCALIB", 0, Lifetime::Condition, o2::framework::ccdbParamSpec(fmt::format("{}", o2::zdc::CCDBPathTowerCalib.data()))); + inputs.emplace_back("intercalibdata", "ZDC", "INTERCALIBDATA", 0, Lifetime::Timeframe); + + char outputa[o2::header::gSizeDataDescriptionString]; + char outputd[o2::header::gSizeDataDescriptionString]; + for (int ih = 0; ih < (2 * WaveformCalibData::NH); ih++) { + snprintf(outputa, o2::header::gSizeDataDescriptionString, "inter_1dh%d", ih); + snprintf(outputd, o2::header::gSizeDataDescriptionString, "INTER_1DH%d", ih); + inputs.emplace_back(outputa, "ZDC", outputd, 0, Lifetime::Timeframe); + } + for (int ih = 0; ih < WaveformCalibData::NH; ih++) { + snprintf(outputa, o2::header::gSizeDataDescriptionString, "inter_2dh%d", ih); + snprintf(outputd, o2::header::gSizeDataDescriptionString, "INTER_2DH%d", ih); + inputs.emplace_back(outputa, "ZDC", outputd, 0, Lifetime::Timeframe); + } + + std::vector outputs; + outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBPayload, "ZDC_Waveformcalib"}, Lifetime::Sporadic); + outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper, "ZDC_Waveformcalib"}, Lifetime::Sporadic); + + return DataProcessorSpec{ + "zdc-calib-towers", + inputs, + outputs, + AlgorithmSpec{adaptFromTask()}, + Options{ + {"tf-per-slot", VariantType::Int, 5, {"number of TFs per calibration time slot"}}, + {"max-delay", VariantType::Int, 3, {"number of slots in past to consider"}}, + {"min-entries", VariantType::Int, 500, {"minimum number of entries to fit single time slot"}}, + {"verbosity-level", o2::framework::VariantType::Int, 1, {"Verbosity level"}}}}; +} + +} // namespace zdc +} // namespace o2 From f75f101ea657a62ebbf559aac48db7b92f623762 Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Thu, 19 May 2022 14:29:12 +0200 Subject: [PATCH 17/40] WIP --- .../ZDC/base/include/ZDCBase/Constants.h | 1 + Detectors/ZDC/calib/CMakeLists.txt | 7 ++ .../include/ZDCCalib/InterCalibWorkflow.h | 26 ----- .../calib/include/ZDCCalib/WaveformCalib.h | 23 ++-- .../include/ZDCCalib/WaveformCalibData.h | 1 + .../calib/include/ZDCCalib/WaveformCalibEPN.h | 25 +++-- .../include/ZDCCalib/WaveformCalibSpec.h | 3 +- Detectors/ZDC/calib/src/WaveformCalib.cxx | 61 +++-------- Detectors/ZDC/calib/src/WaveformCalibData.cxx | 16 +++ Detectors/ZDC/calib/src/WaveformCalibEPN.cxx | 10 +- .../ZDC/calib/src/WaveformCalibEPNSpec.cxx | 26 +++-- Detectors/ZDC/calib/src/WaveformCalibSpec.cxx | 103 +++++++----------- .../calib/src/zdc-waveformcalib-workflow.cxx | 47 ++++++++ 13 files changed, 168 insertions(+), 181 deletions(-) delete mode 100644 Detectors/ZDC/calib/include/ZDCCalib/InterCalibWorkflow.h create mode 100644 Detectors/ZDC/calib/src/zdc-waveformcalib-workflow.cxx diff --git a/Detectors/ZDC/base/include/ZDCBase/Constants.h b/Detectors/ZDC/base/include/ZDCBase/Constants.h index d82c277ce4b1f..fdd9c1bddf94b 100644 --- a/Detectors/ZDC/base/include/ZDCBase/Constants.h +++ b/Detectors/ZDC/base/include/ZDCBase/Constants.h @@ -251,6 +251,7 @@ const std::string CCDBPathTDCCorr = "ZDC/Calib/TDCCorr"; const std::string CCDBPathEnergyCalib = "ZDC/Calib/EnergyCalib"; const std::string CCDBPathTowerCalib = "ZDC/Calib/TowerCalib"; const std::string CCDBPathInterCalibConfig = "ZDC/Calib/InterCalibConfig"; +const std::string CCDBPathWaveformCalib = "ZDC/Calib/WaveformCalib"; const std::string CCDBPathWaveformCalibConfig = "ZDC/Calib/WaveformCalibConfig"; enum Ped { PedND = 0, diff --git a/Detectors/ZDC/calib/CMakeLists.txt b/Detectors/ZDC/calib/CMakeLists.txt index 3a2ef444baa6d..9f2ca786bcce4 100644 --- a/Detectors/ZDC/calib/CMakeLists.txt +++ b/Detectors/ZDC/calib/CMakeLists.txt @@ -18,6 +18,7 @@ o2_add_library(ZDCCalib src/InterCalibEPNSpec.cxx src/WaveformCalibConfig.cxx src/WaveformCalib.cxx + src/WaveformCalibSpec.cxx src/WaveformCalibEPN.cxx src/WaveformCalibEPNSpec.cxx src/WaveformCalibQueue.cxx @@ -48,6 +49,7 @@ o2_target_root_dictionary(ZDCCalib include/ZDCCalib/InterCalibEPNSpec.h include/ZDCCalib/WaveformCalibConfig.h include/ZDCCalib/WaveformCalib.h + include/ZDCCalib/WaveformCalibSpec.h include/ZDCCalib/WaveformCalibEPN.h include/ZDCCalib/WaveformCalibEPNSpec.h include/ZDCCalib/WaveformCalibQueue.h @@ -68,3 +70,8 @@ o2_add_executable(waveformcalib-epn-workflow COMPONENT_NAME zdc SOURCES src/zdc-waveformcalib-epn-workflow.cxx PUBLIC_LINK_LIBRARIES O2::ZDCWorkflow O2::ZDCCalib O2::DetectorsCalibration) + +o2_add_executable(waveformcalib-workflow + COMPONENT_NAME zdc + SOURCES src/zdc-waveformcalib-workflow.cxx + PUBLIC_LINK_LIBRARIES O2::ZDCWorkflow O2::ZDCCalib O2::DetectorsCalibration) diff --git a/Detectors/ZDC/calib/include/ZDCCalib/InterCalibWorkflow.h b/Detectors/ZDC/calib/include/ZDCCalib/InterCalibWorkflow.h deleted file mode 100644 index 6870ba306501d..0000000000000 --- a/Detectors/ZDC/calib/include/ZDCCalib/InterCalibWorkflow.h +++ /dev/null @@ -1,26 +0,0 @@ -// Copyright 2019-2020 CERN and copyright holders of ALICE O2. -// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. -// All rights not expressly granted are reserved. -// -// This software is distributed under the terms of the GNU General Public -// License v3 (GPL Version 3), copied verbatim in the file "COPYING". -// -// In applying this license CERN does not waive the privileges and immunities -// granted to it by virtue of its status as an Intergovernmental Organization -// or submit itself to any jurisdiction. - -#ifndef O2_ZDC_INTERCALIBWORKFLOW_H -#define O2_ZDC_INTERCALIBWORKFLOW_H - -/// @file InterCalibWorkflow.h - -#include "Framework/WorkflowSpec.h" - -namespace o2 -{ -namespace zdc -{ -framework::WorkflowSpec getInterCalibWorkflow(const int verbosity); -} // namespace zdc -} // namespace o2 -#endif diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalib.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalib.h index c6a3211417ec1..2d6839c6916a0 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalib.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalib.h @@ -34,15 +34,15 @@ class WaveformCalib WaveformCalib() = default; int init(); static constexpr int NH = WaveformCalibConfig::NH; - void clear(int ih = -1); - int process(const WaveformCalibData& data); // Calibration of RUN3 data - aggregator node - int endOfRun(); // Perform minimization + void clear(); + int process(const WaveformCalibData& data); // Calibration of RUN3 data - aggregator node + int endOfRun(); // Perform minimization int write(const std::string fn = "ZDCWaveformCalib.root"); CcdbObjectInfo& getCcdbObjectInfo() { return mInfo; } - void setWaveformCalibConfig(const WaveformCalibConfig* param) { mWaveformCalibConfig = param; }; - const WaveformCalibConfig* getWaveformCalibConfig() const { return mWaveformCalibConfig; }; + void setConfig(const WaveformCalibConfig* param) { mConfig = param; }; + const WaveformCalibConfig* getConfig() const { return mConfig; }; void setVerbosity(int v) { mVerbosity = v; } int getVerbosity() const { return mVerbosity; } @@ -50,20 +50,15 @@ class WaveformCalib void setSaveDebugHistos() { mSaveDebugHistos = true; } void setDontSaveDebugHistos() { mSaveDebugHistos = false; } + WaveformCalibData& getData() { return mData; } + private: WaveformCalibData mData; bool mInitDone = false; bool mSaveDebugHistos = false; int32_t mVerbosity = DbgMinimal; - static std::mutex mMtx; /// mutex for critical section - double mPar[NH][NPAR] = {0}; - double mErr[NH][NPAR] = {0}; - const WaveformCalibConfig* mWaveformCalibConfig = nullptr; /// Configuration of intercalibration - const ZDCEnergyParam* mEnergyParam = nullptr; /// Energy calibration object - const ZDCTowerParam* mTowerParam = nullptr; /// Tower calibration object - ZDCTowerParam mTowerParamUpd; /// Updated tower calibration object - CcdbObjectInfo mInfo; /// CCDB Info - void assign(int ih, bool ismod); /// Assign updated calibration object + const WaveformCalibConfig* mConfig = nullptr; /// Configuration of intercalibration + CcdbObjectInfo mInfo; /// CCDB Info }; } // namespace zdc } // namespace o2 diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h index 0ee2bcaa63e6c..40cf5a3b0d400 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h @@ -43,6 +43,7 @@ struct WaveformCalibData { WaveformCalibData& operator+=(const WaveformCalibData& other); int getEntries(int ih) const; void print() const; + void clear(); void setCreationTime(uint64_t ctime); void setN(int n); int write(const std::string fn); diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h index 196bc4a2ef1b4..59ab2b133db39 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h @@ -38,8 +38,8 @@ class WaveformCalibEPN const gsl::span& wave); int endOfRun(); int write(const std::string fn = "ZDCWaveformCalibEPN.root"); - void setConfig(const WaveformCalibConfig* param) { mWaveformCalibConfig = param; }; - const WaveformCalibConfig* getConfig() const { return mWaveformCalibConfig; }; + void setConfig(const WaveformCalibConfig* param) { mConfig = param; }; + const WaveformCalibConfig* getConfig() const { return mConfig; }; void setSaveDebugHistos() { mSaveDebugHistos = true; } void setDontSaveDebugHistos() { mSaveDebugHistos = false; } void setVerbosity(int val) { mVerbosity = val; } @@ -51,19 +51,20 @@ class WaveformCalibEPN bool mSaveDebugHistos = false; int32_t mNBin = 0; int32_t mVerbosity = DbgMinimal; - const WaveformCalibConfig* mWaveformCalibConfig = nullptr; /// Configuration of intercalibration + const WaveformCalibConfig* mConfig = nullptr; /// Configuration of intercalibration - int mFirst=0; - int mLast=0; - int mN=1; + int mFirst = 0; + int mLast = 0; + int mN = 1; - void configure(int ifirst, int ilast){ - if(ifirst>0 || ilast<0 || ilast 0 || ilast < 0 || ilast < ifirst) { + LOGF(fatal, "WaveformCalibEPN configure error with ifirst=%d ilast=%d", ifirst, ilast); } - mFirst=ifirst; - mLast=ilast; - mN=ilast-ifirst+1; + mFirst = ifirst; + mLast = ilast; + mN = ilast - ifirst + 1; } WaveformCalibQueue mQueue; diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibSpec.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibSpec.h index 977dda7773249..eb8525e912565 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibSpec.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibSpec.h @@ -23,8 +23,8 @@ #include "Framework/Task.h" #include "CommonDataFormat/FlatHisto1D.h" #include "CommonDataFormat/FlatHisto2D.h" -#include "DataFormatsZDC/WaveformCalibData.h" #include "CommonUtils/NameConf.h" +#include "ZDCCalib/WaveformCalibData.h" #include "ZDCCalib/WaveformCalib.h" #include "ZDCCalib/WaveformCalibConfig.h" #include "DetectorsCalibration/Utils.h" @@ -49,6 +49,7 @@ class WaveformCalibSpec : public o2::framework::Task private: int mVerbosity = DbgMinimal; // Verbosity level + bool mInitialized = false; // Connect once to CCDB during initialization WaveformCalib mWorker; // Intercalibration object TStopwatch mTimer; }; diff --git a/Detectors/ZDC/calib/src/WaveformCalib.cxx b/Detectors/ZDC/calib/src/WaveformCalib.cxx index 5ce8c0f990283..24b1fbf30d391 100644 --- a/Detectors/ZDC/calib/src/WaveformCalib.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalib.cxx @@ -28,7 +28,7 @@ using namespace o2::zdc; int WaveformCalib::init() { - if (mWaveformCalibConfig == nullptr) { + if (mConfig == nullptr) { LOG(fatal) << "o2::zdc::WaveformCalib: missing configuration object"; return -1; } @@ -44,13 +44,13 @@ int WaveformCalib::endOfRun() if (mVerbosity > DbgZero) { LOGF(info, "Computing intercalibration coefficients"); } - auto clName = o2::utils::MemFileHelper::getClassName(mTowerParamUpd); + auto clName = o2::utils::MemFileHelper::getClassName(mData); mInfo.setObjectType(clName); auto flName = o2::ccdb::CcdbApi::generateFileName(clName); mInfo.setFileName(flName); - mInfo.setPath(CCDBPathTowerCalib); + mInfo.setPath(CCDBPathWaveformCalib); std::map md; - md["config"] = mWaveformCalibConfig->desc; + md["config"] = mConfig->desc; mInfo.setMetaData(md); uint64_t starting = mData.mCTimeBeg; if (starting >= 10000) { @@ -66,9 +66,9 @@ int WaveformCalib::endOfRun() return 0; } -void WaveformCalib::clear(int ih) +void WaveformCalib::clear() { - mData.mSum[ii][i][j] = 0; + mData.clear(); } int WaveformCalib::process(const WaveformCalibData& data) @@ -76,51 +76,18 @@ int WaveformCalib::process(const WaveformCalibData& data) if (!mInitDone) { init(); } + // Add checks before addition + auto nbun = mConfig->nbun; + auto peak = -mConfig->ibeg; + if ((nbun != mData.mN) || (mData.mPeak != peak)) { + LOG(fatal) << "WaveformCalib::process adding inconsistent data mN cfg=" << nbun << " vs data=" << mData.mN << " mPeak cfg=" << peak << " vs data=" << mData.mPeak; + return -1; + } mData += data; return 0; } int WaveformCalib::write(const std::string fn) { - TDirectory* cwd = gDirectory; - TFile* f = new TFile(fn.data(), "recreate"); - if (f->IsZombie()) { - LOG(error) << "Cannot create file: " << fn; - return 1; - } - for (int32_t ih = 0; ih < (2 * NH); ih++) { - if (mHUnc[ih]) { - auto p = mHUnc[ih]->createTH1F(WaveformCalib::mHUncN[ih]); - p->SetTitle(WaveformCalib::mHUncT[ih]); - p->Write("", TObject::kOverwrite); - } - } - for (int32_t ih = 0; ih < NH; ih++) { - if (mCUnc[ih]) { - auto p = mCUnc[ih]->createTH2F(WaveformCalib::mCUncN[ih]); - p->SetTitle(WaveformCalib::mCUncT[ih]); - p->Write("", TObject::kOverwrite); - } - } - // Only after replay of RUN2 data - for (int32_t ih = 0; ih < NH; ih++) { - if (mHCorr[ih]) { - mHCorr[ih]->Write("", TObject::kOverwrite); - } - } - for (int32_t ih = 0; ih < NH; ih++) { - if (mCCorr[ih]) { - mCCorr[ih]->Write("", TObject::kOverwrite); - } - } - // Minimization output - const char* mntit[NH] = {"mZNA", "mZPA", "mZNC", "mZPC", "mZEM"}; - for (int32_t ih = 0; ih < NH; ih++) { - if (mMn[ih]) { - mMn[ih]->Write(mntit[ih], TObject::kOverwrite); - } - } - f->Close(); - cwd->cd(); - return 0; + return mData.write(fn); } diff --git a/Detectors/ZDC/calib/src/WaveformCalibData.cxx b/Detectors/ZDC/calib/src/WaveformCalibData.cxx index ecdab90679fd7..eb0396d706873 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibData.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibData.cxx @@ -118,3 +118,19 @@ int WaveformCalibData::write(const std::string fn) cwd->cd(); return 0; } + +void WaveformCalibData::clear() +{ + mCTimeBeg = 0; + mCTimeEnd = 0; + mN = 0; + mPeak = 0; + for (int32_t ih = 0; ih < NH; ih++) { + mEntries[ih]=0; + mFirstValid[ih] = -1; + mLastValid[ih] = -1; + for (int iw=0; iw DbgZero) { - mWaveformCalibConfig->print(); + mConfig->print(); } // Inspect reconstruction parameters @@ -90,8 +90,8 @@ int WaveformCalibEPN::endOfRun() LOGF(info, "WaveformCalibEPN::endOfRun ts (%llu:%llu)", mData.mCTimeBeg, mData.mCTimeEnd); for (int ih = 0; ih < NH; ih++) { LOGF(info, "Waveform %2d with %10d events and cuts AMP:(%g:%g) TDC:(%g:%g) Valid:[%d:%d:%d]", ih, mData.mEntries[ih], - mWaveformCalibConfig->cutLow[ih], mWaveformCalibConfig->cutHigh[ih], - mWaveformCalibConfig->cutTimeLow[ih], mWaveformCalibConfig->cutTimeHigh[ih], + mConfig->cutLow[ih], mConfig->cutHigh[ih], + mConfig->cutTimeLow[ih], mConfig->cutTimeHigh[ih], mData.mFirstValid[ih], mData.mPeak, mData.mLastValid[ih]); } } diff --git a/Detectors/ZDC/calib/src/WaveformCalibEPNSpec.cxx b/Detectors/ZDC/calib/src/WaveformCalibEPNSpec.cxx index 84ec93c0e75ad..21d7fdd4d6f59 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibEPNSpec.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibEPNSpec.cxx @@ -18,6 +18,7 @@ #include #include "CCDB/BasicCCDBManager.h" #include "CCDB/CCDBTimeStampUtils.h" +#include "CCDB/CcdbApi.h" #include "Framework/Logger.h" #include "Framework/ControlService.h" #include "Framework/ConfigParamRegistry.h" @@ -30,6 +31,7 @@ #include "DataFormatsZDC/RecEvent.h" #include "ZDCBase/ModuleConfig.h" #include "CommonUtils/NameConf.h" +#include "CommonUtils/MemFileHelper.h" #include "CCDB/BasicCCDBManager.h" #include "CCDB/CCDBTimeStampUtils.h" #include "ZDCCalib/WaveformCalibData.h" @@ -57,6 +59,9 @@ WaveformCalibEPNSpec::WaveformCalibEPNSpec(const int verbosity) : mVerbosity(ver void WaveformCalibEPNSpec::init(o2::framework::InitContext& ic) { mVerbosity = ic.options().get("verbosity-level"); + mWorker.setVerbosity(mVerbosity); + mTimer.CpuTime(); + mTimer.Start(false); } void WaveformCalibEPNSpec::updateTimeDependentParams(ProcessingContext& pc) @@ -71,21 +76,22 @@ void WaveformCalibEPNSpec::run(ProcessingContext& pc) if (!mInitialized) { mInitialized = true; std::string loadedConfFiles = "Loaded ZDC configuration files:"; + std::string ct = "WaveformCalibConfig"; + std::string cn = "wavecalibconfig"; // WaveformCalib configuration - auto interConfig = pc.inputs().get("wavecalibconfig"); - if (!interConfig) { - LOG(fatal) << "Missing WaveformCalibConfig calibration object"; + auto config = pc.inputs().get(cn); + if (!config) { + LOG(fatal) << "Missing calibration object: " << ct; return; } else { - loadedConfFiles += " WaveformCalibConfig"; + loadedConfFiles += " "; + loadedConfFiles += cn; if (mVerbosity > DbgZero) { - LOG(info) << "Loaded WaveformCalibConfig configuration object"; - interConfig->print(); + LOG(info) << "Loaded configuration object: " << ct; + config->print(); } + mWorker.setConfig(config.get()); } - - mWorker.setConfig(interConfig.get()); - LOG(info) << loadedConfFiles; mTimer.CpuTime(); mTimer.Start(false); @@ -105,7 +111,7 @@ void WaveformCalibEPNSpec::run(ProcessingContext& pc) // Process reconstructed data mWorker.process(bcrec, energy, tdc, info, wave); - // Send intermediate calibration data and debug histograms + // Send intermediate calibration data o2::framework::Output output("ZDC", "WAVECALIBDATA", 0, Lifetime::Timeframe); pc.outputs().snapshot(output, mWorker.mData); } diff --git a/Detectors/ZDC/calib/src/WaveformCalibSpec.cxx b/Detectors/ZDC/calib/src/WaveformCalibSpec.cxx index 21801d81a7cae..fc80e0b762017 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibSpec.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibSpec.cxx @@ -23,6 +23,7 @@ #include "Framework/ControlService.h" #include "Framework/ConfigParamRegistry.h" #include "Framework/CCDBParamSpec.h" +#include "Framework/DataRefUtils.h" #include "DetectorsCommonDataFormats/DetID.h" #include "DataFormatsZDC/BCData.h" #include "DataFormatsZDC/ChannelData.h" @@ -33,7 +34,7 @@ #include "CommonUtils/MemFileHelper.h" #include "CCDB/BasicCCDBManager.h" #include "CCDB/CCDBTimeStampUtils.h" -#include "ZDCReconstruction/RecoConfigZDC.h" +#include "ZDCCalib/WaveformCalibData.h" #include "ZDCCalib/WaveformCalibSpec.h" using namespace o2::framework; @@ -57,12 +58,8 @@ WaveformCalibSpec::WaveformCalibSpec(const int verbosity) : mVerbosity(verbosity void WaveformCalibSpec::init(o2::framework::InitContext& ic) { - // int minEnt = std::max(300, ic.options().get("min-entries")); - // int nb = std::max(500, ic.options().get("nbins")); - // int slotL = ic.options().get("tf-per-slot"); - // int delay = ic.options().get("max-delay"); mVerbosity = ic.options().get("verbosity-level"); - mWaveformCalib.setVerbosity(mVerbosity); + mWorker.setVerbosity(mVerbosity); mTimer.CpuTime(); mTimer.Start(false); } @@ -70,71 +67,43 @@ void WaveformCalibSpec::init(o2::framework::InitContext& ic) void WaveformCalibSpec::updateTimeDependentParams(ProcessingContext& pc) { // we call these methods just to trigger finaliseCCDB callback - std::string loadedConfFiles = "Loaded ZDC configuration files:"; - // Energy calibration - auto energyParam = pc.inputs().get("energycalib"); - if (!energyParam) { - LOG(fatal) << "Missing ZDCEnergyParam calibration object"; - return; - } else { - loadedConfFiles += " ZDCEnergyParam"; - if (mVerbosity > DbgMinimal) { - LOG(info) << "Loaded Energy calibration ZDCEnergyParam"; - energyParam->print(); - } - } - - // Tower calibration - auto towerParam = pc.inputs().get("towercalib"); - if (!towerParam) { - LOG(fatal) << "Missing ZDCTowerParam calibration object"; - return; - } else { - loadedConfFiles += " ZDCTowerParam"; - if (mVerbosity > DbgMinimal) { - LOG(info) << "Loaded Tower calibration ZDCTowerParam"; - towerParam->print(); - } - } - - // WaveformCalib configuration - auto interConfig = pc.inputs().get("intercalibconfig"); - if (!interConfig) { - LOG(fatal) << "Missing WaveformCalibConfig calibration WaveformCalibConfig"; - return; - } else { - loadedConfFiles += " WaveformCalibConfig"; - if (mVerbosity > DbgMinimal) { - LOG(info) << "Loaded WaveformCalib configuration object"; - interConfig->print(); - } - } - - LOG(info) << loadedConfFiles; - - mWaveformCalib.setEnergyParam(energyParam.get()); - mWaveformCalib.setTowerParam(towerParam.get()); - mWaveformCalib.setWaveformCalibConfig(interConfig.get()); + pc.inputs().get("wavecalibconfig"); } void WaveformCalibSpec::run(ProcessingContext& pc) { updateTimeDependentParams(pc); - auto data = pc.inputs().get("intercalibdata"); - mWaveformCalib.process(data); - for (int ih = 0; ih < (2 * WaveformCalibData::NH); ih++) { - o2::dataformats::FlatHisto1D histoView(pc.inputs().get>(fmt::format("inter_1dh{}", ih).data())); - mWaveformCalib.add(ih, histoView); - } - for (int ih = 0; ih < WaveformCalibData::NH; ih++) { - o2::dataformats::FlatHisto2D histoView(pc.inputs().get>(fmt::format("inter_2dh{}", ih).data())); - mWaveformCalib.add(ih, histoView); + if (!mInitialized) { + mInitialized = true; + std::string loadedConfFiles = "Loaded ZDC configuration files:"; + std::string ct = "WaveformCalibConfig"; + std::string cn = "wavecalibconfig"; + // WaveformCalib configuration + auto config = pc.inputs().get(cn); + if (!config) { + LOG(fatal) << "Missing calibration object: " << ct; + return; + } else { + loadedConfFiles += " "; + loadedConfFiles += cn; + if (mVerbosity > DbgZero) { + LOG(info) << "Loaded configuration object: " << ct; + config->print(); + } + mWorker.setConfig(config.get()); + } + LOG(info) << loadedConfFiles; + mTimer.CpuTime(); + mTimer.Start(false); } + + auto data = pc.inputs().get("waveformcalibdata"); + mWorker.process(data); } void WaveformCalibSpec::endOfStream(EndOfStreamContext& ec) { - mWaveformCalib.endOfRun(); + mWorker.endOfRun(); mTimer.Stop(); sendOutput(ec.outputs()); LOGF(info, "ZDC Waveformcalibration total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1); @@ -143,11 +112,12 @@ void WaveformCalibSpec::endOfStream(EndOfStreamContext& ec) //________________________________________________________________ void WaveformCalibSpec::sendOutput(o2::framework::DataAllocator& output) { + /* // 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& payload = mWaveformCalib.getTowerParamUpd(); - auto& info = mWaveformCalib.getCcdbObjectInfo(); + const auto& payload = mWorker.getTowerParamUpd(); + auto& info = mWorker.getCcdbObjectInfo(); auto image = o2::ccdb::CcdbApi::createObjectImage(&payload, &info); if (mVerbosity > DbgMinimal) { payload.print(); @@ -157,7 +127,8 @@ void WaveformCalibSpec::sendOutput(o2::framework::DataAllocator& output) output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, "ZDC_Waveformcalib", 0}, *image.get()); // vector output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, "ZDC_Waveformcalib", 0}, info); // root-serialized // TODO: reset the outputs once they are already sent (is it necessary?) - // mWaveformCalib.init(); + // mWorker.init(); + */ } framework::DataProcessorSpec getWaveformCalibSpec() @@ -185,8 +156,8 @@ framework::DataProcessorSpec getWaveformCalibSpec() } std::vector outputs; - outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBPayload, "ZDC_Waveformcalib"}, Lifetime::Sporadic); - outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper, "ZDC_Waveformcalib"}, Lifetime::Sporadic); + outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBPayload, "ZDCWaveformcalib"}, Lifetime::Sporadic); + outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper, "ZDCWaveformcalib"}, Lifetime::Sporadic); return DataProcessorSpec{ "zdc-calib-towers", diff --git a/Detectors/ZDC/calib/src/zdc-waveformcalib-workflow.cxx b/Detectors/ZDC/calib/src/zdc-waveformcalib-workflow.cxx new file mode 100644 index 0000000000000..ea7876023c62d --- /dev/null +++ b/Detectors/ZDC/calib/src/zdc-waveformcalib-workflow.cxx @@ -0,0 +1,47 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#include "Framework/DataProcessorSpec.h" +#include "CommonUtils/ConfigurableParam.h" +#include "DetectorsRaw/HBFUtilsInitializer.h" +#include "ZDCCalib/WaveformCalibSpec.h" + +using namespace o2::framework; + +// ------------------------------------------------------------------ +void customize(std::vector& policies) +{ + o2::raw::HBFUtilsInitializer::addNewTimeSliceCallback(policies); +} + +// we need to add workflow options before including Framework/runDataProcessing +void customize(std::vector& workflowOptions) +{ + // option allowing to set parameters + std::string keyvaluehelp("Semicolon separated key=value strings ..."); + workflowOptions.push_back(ConfigParamSpec{"configKeyValues", VariantType::String, "", {keyvaluehelp}}); + o2::raw::HBFUtilsInitializer::addConfigOption(workflowOptions); +} + +// ------------------------------------------------------------------ + +#include "Framework/runDataProcessing.h" + +WorkflowSpec defineDataProcessing(ConfigContext const& configcontext) +{ + // Update the (declared) parameters if changed from the command line + o2::conf::ConfigurableParam::updateFromString(configcontext.options().get("configKeyValues")); + WorkflowSpec specs; + specs.emplace_back(o2::zdc::getWaveformCalibSpec()); + // configure dpl timer to inject correct firstTFOrbit: start from the 1st orbit of TF containing 1st sampled orbit + o2::raw::HBFUtilsInitializer hbfIni(configcontext, specs); + return specs; +} From c383d17ba667b77d0444097e12b4160af589015d Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Thu, 19 May 2022 18:46:43 +0200 Subject: [PATCH 18/40] Full workflow --- .../calib/include/ZDCCalib/InterCalibEPN.h | 3 +- .../include/ZDCCalib/InterCalibEPNSpec.h | 6 +-- .../include/ZDCCalib/WaveformCalibQueue.h | 8 +-- Detectors/ZDC/calib/src/InterCalibEPNSpec.cxx | 17 +++--- Detectors/ZDC/calib/src/InterCalibSpec.cxx | 10 ++-- Detectors/ZDC/calib/src/WaveformCalib.cxx | 11 ++-- Detectors/ZDC/calib/src/WaveformCalibData.cxx | 14 +++-- .../ZDC/calib/src/WaveformCalibEPNSpec.cxx | 9 ++-- .../ZDC/calib/src/WaveformCalibQueue.cxx | 8 +-- Detectors/ZDC/calib/src/WaveformCalibSpec.cxx | 52 ++++++------------- Detectors/ZDC/calib/src/ZDCCalibLinkDef.h | 1 + 11 files changed, 65 insertions(+), 74 deletions(-) diff --git a/Detectors/ZDC/calib/include/ZDCCalib/InterCalibEPN.h b/Detectors/ZDC/calib/include/ZDCCalib/InterCalibEPN.h index 01fbfd49239d3..9f6e63b11923d 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/InterCalibEPN.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/InterCalibEPN.h @@ -55,8 +55,9 @@ class InterCalibEPN const InterCalibConfig* getInterCalibConfig() const { return mInterCalibConfig; }; void setSaveDebugHistos() { mSaveDebugHistos = true; } void setDontSaveDebugHistos() { mSaveDebugHistos = false; } - InterCalibData& getData() { return mData; } + void setVerbosity(int val) { mVerbosity = val; } InterCalibData mData; + InterCalibData& getData() { return mData; } std::array*, 2 * NH> mH{}; std::array*, NH> mC{}; diff --git a/Detectors/ZDC/calib/include/ZDCCalib/InterCalibEPNSpec.h b/Detectors/ZDC/calib/include/ZDCCalib/InterCalibEPNSpec.h index d6e545092350a..68a35aa48e666 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/InterCalibEPNSpec.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/InterCalibEPNSpec.h @@ -42,9 +42,9 @@ class InterCalibEPNSpec : public o2::framework::Task void endOfStream(o2::framework::EndOfStreamContext& ec) final; private: - int mVerbosity = 0; // Verbosity level - bool mInitialized = false; // Connect once to CCDB during initialization - InterCalibEPN mInterCalibEPN; // Intercalibration object + int mVerbosity = 0; // Verbosity level + bool mInitialized = false; // Connect once to CCDB during initialization + InterCalibEPN mWorker; // Intercalibration object TStopwatch mTimer; }; diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h index 382a519b27845..f0f14d735afc9 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h @@ -50,6 +50,10 @@ struct WaveformCalibQueue { const WaveformCalibConfig *mCfg = nullptr; + static int peak(int pk){ + return NTimeBinsPerBC * TSN * pk + NTimeBinsPerBC / 2 * TSN; + } + void configure(const WaveformCalibConfig *cfg) { mCfg = cfg; @@ -64,7 +68,7 @@ struct WaveformCalibQueue { mPk = -mFirst; mPPos = mPk * NIS + NIS/2; mNP = mN * NIS; - mPeak = NTimeBinsPerBC * TSN * mPk + NTimeBinsPerBC / 2 * TSN; + mPeak = peak(mPk); } std::deque mIR; @@ -77,7 +81,6 @@ struct WaveformCalibQueue { std::deque mNW; void clear() { - LOG(info) << __func__; mIR.clear(); mEntry.clear(); for (int ih = 0; ih < NH; ih++) { @@ -93,7 +96,6 @@ struct WaveformCalibQueue { } void pop() { - LOG(info) << __func__; mIR.pop_front(); mEntry.pop_front(); for (int ih = 0; ih < NH; ih++) { diff --git a/Detectors/ZDC/calib/src/InterCalibEPNSpec.cxx b/Detectors/ZDC/calib/src/InterCalibEPNSpec.cxx index 99d305d2c7031..868a8c1dc2063 100644 --- a/Detectors/ZDC/calib/src/InterCalibEPNSpec.cxx +++ b/Detectors/ZDC/calib/src/InterCalibEPNSpec.cxx @@ -59,6 +59,9 @@ InterCalibEPNSpec::InterCalibEPNSpec(const int verbosity) : mVerbosity(verbosity void InterCalibEPNSpec::init(o2::framework::InitContext& ic) { mVerbosity = ic.options().get("verbosity-level"); + mWorker.setVerbosity(mVerbosity); + mTimer.CpuTime(); + mTimer.Start(false); } void InterCalibEPNSpec::updateTimeDependentParams(ProcessingContext& pc) @@ -86,7 +89,7 @@ void InterCalibEPNSpec::run(ProcessingContext& pc) } } - mInterCalibEPN.setInterCalibConfig(interConfig.get()); + mWorker.setInterCalibConfig(interConfig.get()); LOG(info) << loadedConfFiles; mTimer.CpuTime(); @@ -95,7 +98,7 @@ void InterCalibEPNSpec::run(ProcessingContext& pc) const auto ref = pc.inputs().getFirstValid(true); auto creationTime = DataRefUtils::getHeader(ref)->creation; // approximate time in ms - mInterCalibEPN.getData().setCreationTime(creationTime); + mWorker.getData().setCreationTime(creationTime); auto bcrec = pc.inputs().get>("bcrec"); auto energy = pc.inputs().get>("energy"); @@ -103,27 +106,27 @@ void InterCalibEPNSpec::run(ProcessingContext& pc) auto info = pc.inputs().get>("info"); // Process reconstructed data - mInterCalibEPN.process(bcrec, energy, tdc, info); + mWorker.process(bcrec, energy, tdc, info); // Send intermediate calibration data and debug histograms o2::framework::Output output("ZDC", "INTERCALIBDATA", 0, Lifetime::Timeframe); - pc.outputs().snapshot(output, mInterCalibEPN.mData); + pc.outputs().snapshot(output, mWorker.mData); char outputd[o2::header::gSizeDataDescriptionString]; for (int ih = 0; ih < (2 * InterCalibData::NH); ih++) { snprintf(outputd, o2::header::gSizeDataDescriptionString, "INTER_1DH%d", ih); o2::framework::Output output("ZDC", outputd, 0, Lifetime::Timeframe); - pc.outputs().snapshot(output, mInterCalibEPN.mH[ih]->getBase()); + pc.outputs().snapshot(output, mWorker.mH[ih]->getBase()); } for (int ih = 0; ih < InterCalibData::NH; ih++) { snprintf(outputd, o2::header::gSizeDataDescriptionString, "INTER_2DH%d", ih); o2::framework::Output output("ZDC", outputd, 0, Lifetime::Timeframe); - pc.outputs().snapshot(output, mInterCalibEPN.mC[ih]->getBase()); + pc.outputs().snapshot(output, mWorker.mC[ih]->getBase()); } } void InterCalibEPNSpec::endOfStream(EndOfStreamContext& ec) { - mInterCalibEPN.endOfRun(); + mWorker.endOfRun(); mTimer.Stop(); LOGF(info, "ZDC EPN Intercalibration total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1); } diff --git a/Detectors/ZDC/calib/src/InterCalibSpec.cxx b/Detectors/ZDC/calib/src/InterCalibSpec.cxx index 3e0f02303f70f..a0f49f39a82f5 100644 --- a/Detectors/ZDC/calib/src/InterCalibSpec.cxx +++ b/Detectors/ZDC/calib/src/InterCalibSpec.cxx @@ -151,11 +151,11 @@ void InterCalibSpec::sendOutput(o2::framework::DataAllocator& output) const auto& payload = mInterCalib.getTowerParamUpd(); auto& info = mInterCalib.getCcdbObjectInfo(); auto image = o2::ccdb::CcdbApi::createObjectImage(&payload, &info); + LOG(info) << "Sending object " << info.getPath() << "/" << info.getFileName() << " of size " << image->size() + << " bytes, valid for " << info.getStartValidityTimestamp() << " : " << info.getEndValidityTimestamp(); if (mVerbosity > DbgMinimal) { payload.print(); } - LOG(info) << "Sending object " << info.getPath() << "/" << info.getFileName() << " of size " << image->size() - << " bytes, valid for " << info.getStartValidityTimestamp() << " : " << info.getEndValidityTimestamp(); output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, "ZDC_Intercalib", 0}, *image.get()); // vector output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, "ZDC_Intercalib", 0}, info); // root-serialized // TODO: reset the outputs once they are already sent (is it necessary?) @@ -195,11 +195,7 @@ framework::DataProcessorSpec getInterCalibSpec() inputs, outputs, AlgorithmSpec{adaptFromTask()}, - Options{ - {"tf-per-slot", VariantType::Int, 5, {"number of TFs per calibration time slot"}}, - {"max-delay", VariantType::Int, 3, {"number of slots in past to consider"}}, - {"min-entries", VariantType::Int, 500, {"minimum number of entries to fit single time slot"}}, - {"verbosity-level", o2::framework::VariantType::Int, 1, {"Verbosity level"}}}}; + Options{{"verbosity-level", o2::framework::VariantType::Int, 1, {"Verbosity level"}}}}; } } // namespace zdc diff --git a/Detectors/ZDC/calib/src/WaveformCalib.cxx b/Detectors/ZDC/calib/src/WaveformCalib.cxx index 24b1fbf30d391..4f49da2f8b368 100644 --- a/Detectors/ZDC/calib/src/WaveformCalib.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalib.cxx @@ -19,6 +19,7 @@ #include #include "CommonUtils/MemFileHelper.h" #include "ZDCCalib/WaveformCalib.h" +#include "ZDCCalib/WaveformCalibQueue.h" #include "ZDCReconstruction/ZDCEnergyParam.h" #include "ZDCReconstruction/ZDCTowerParam.h" #include "Framework/Logger.h" @@ -33,6 +34,8 @@ int WaveformCalib::init() return -1; } clear(); + mData.setN(mConfig->nbun); + mData.mPeak = WaveformCalibQueue::peak(-(mConfig->ibeg)); mInitDone = true; return 0; } @@ -42,7 +45,7 @@ int WaveformCalib::init() int WaveformCalib::endOfRun() { if (mVerbosity > DbgZero) { - LOGF(info, "Computing intercalibration coefficients"); + LOGF(info, "Finalizing WaveformCalibData object"); } auto clName = o2::utils::MemFileHelper::getClassName(mData); mInfo.setObjectType(clName); @@ -77,10 +80,8 @@ int WaveformCalib::process(const WaveformCalibData& data) init(); } // Add checks before addition - auto nbun = mConfig->nbun; - auto peak = -mConfig->ibeg; - if ((nbun != mData.mN) || (mData.mPeak != peak)) { - LOG(fatal) << "WaveformCalib::process adding inconsistent data mN cfg=" << nbun << " vs data=" << mData.mN << " mPeak cfg=" << peak << " vs data=" << mData.mPeak; + if ((mData.mN != data.mN) || (mData.mPeak != data.mPeak)) { + LOG(fatal) << "WaveformCalib::process adding inconsistent data mN cfg=" << mData.mN << " vs data=" << data.mN << " mPeak cfg=" << mData.mPeak << " vs data=" << data.mPeak; return -1; } mData += data; diff --git a/Detectors/ZDC/calib/src/WaveformCalibData.cxx b/Detectors/ZDC/calib/src/WaveformCalibData.cxx index eb0396d706873..2c05ca389ed26 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibData.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibData.cxx @@ -19,8 +19,11 @@ using namespace o2::zdc; void WaveformCalibData::print() const { + LOGF(info, "WaveformCalibData mN = %d/%d", mN, NBT); for (int32_t ih = 0; ih < NH; ih++) { - LOGF(info, "WaveformCalibData [%llu : %llu]: entries=%d [%d:%d:%d]", mCTimeBeg, mCTimeEnd, mEntries[ih], mFirstValid[ih], mPeak, mLastValid[ih]); + if (mEntries[ih] > 0) { + LOGF(info, "WaveformCalibData %2d [%llu : %llu]: entries=%d [%d:%d:%d]", ih, mCTimeBeg, mCTimeEnd, mEntries[ih], mFirstValid[ih], mPeak, mLastValid[ih]); + } } } @@ -52,9 +55,10 @@ WaveformCalibData& WaveformCalibData::operator+=(const WaveformCalibData& other) mWave[ih][i] = mWave[ih][i] + other.mWave[ih][i]; } } - //#ifdef O2_ZDC_DEBUG +#ifdef O2_ZDC_DEBUG + LOG(info) << __func__; print(); - //#endif +#endif return *this; } @@ -126,10 +130,10 @@ void WaveformCalibData::clear() mN = 0; mPeak = 0; for (int32_t ih = 0; ih < NH; ih++) { - mEntries[ih]=0; + mEntries[ih] = 0; mFirstValid[ih] = -1; mLastValid[ih] = -1; - for (int iw=0; iw DbgZero) { LOG(info) << "Loaded configuration object: " << ct; config->print(); @@ -100,7 +100,7 @@ void WaveformCalibEPNSpec::run(ProcessingContext& pc) const auto ref = pc.inputs().getFirstValid(true); auto creationTime = DataRefUtils::getHeader(ref)->creation; // approximate time in ms WaveformCalibData& data = mWorker.getData(); -// data.setCreationTime(creationTime); + data.setCreationTime(creationTime); auto bcrec = pc.inputs().get>("bcrec"); auto energy = pc.inputs().get>("energy"); @@ -125,6 +125,7 @@ void WaveformCalibEPNSpec::endOfStream(EndOfStreamContext& ec) framework::DataProcessorSpec getWaveformCalibEPNSpec() { + using device = o2::zdc::WaveformCalibEPNSpec; std::vector inputs; inputs.emplace_back("bcrec", "ZDC", "BCREC", 0, Lifetime::Timeframe); inputs.emplace_back("energy", "ZDC", "ENERGY", 0, Lifetime::Timeframe); @@ -139,8 +140,8 @@ framework::DataProcessorSpec getWaveformCalibEPNSpec() "zdc-waveformcalib-epn", inputs, outputs, - AlgorithmSpec{adaptFromTask()}, - o2::framework::Options{{"verbosity-level", o2::framework::VariantType::Int, 0, {"Verbosity level"}}}}; + AlgorithmSpec{adaptFromTask()}, + Options{{"verbosity-level", o2::framework::VariantType::Int, 0, {"Verbosity level"}}}}; } } // namespace zdc diff --git a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx index 5c98bb7d260fd..ddc0b767e7713 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx @@ -134,7 +134,7 @@ int WaveformCalibQueue::hasData(int isig, const gsl::span::infinity(); for (int ib = 0; ib < mN; ib++) { int ifound = false; - LOG(info) << "mNW[" << ib << "] = " << mNW[ib] << " mFirstW = " << mFirstW[ib]; + // LOG(info) << "mNW[" << ib << "] = " << mNW[ib] << " mFirstW = " << mFirstW[ib]; for (int iw = 0; iw < mNW[ib]; iw++) { auto& mywave = wave[iw + mFirstW[ib]]; if (mywave.ch() == isig) { @@ -157,7 +157,7 @@ int WaveformCalibQueue::hasData(int isig, const gsl::span::infinity(); for (int ib = 0; ib < mN; ib++) { int ifound = false; - LOG(info) << "mNW[" << ib << "] = " << mNW[ib] << " mFirstW = " << mFirstW[ib]; + // LOG(info) << "mNW[" << ib << "] = " << mNW[ib] << " mFirstW = " << mFirstW[ib]; for (int iw = 0; iw < mNW[ib]; iw++) { auto& mywave = wave[iw + mFirstW[ib]]; if (mywave.ch() == isig) { @@ -221,7 +221,7 @@ int WaveformCalibQueue::addData(int isig, const gsl::span DbgZero) { LOG(info) << "Loaded configuration object: " << ct; config->print(); @@ -98,6 +98,9 @@ void WaveformCalibSpec::run(ProcessingContext& pc) } auto data = pc.inputs().get("waveformcalibdata"); + if (mVerbosity >= DbgFull) { + data.print(); + } mWorker.process(data); } @@ -106,29 +109,27 @@ void WaveformCalibSpec::endOfStream(EndOfStreamContext& ec) mWorker.endOfRun(); mTimer.Stop(); sendOutput(ec.outputs()); - LOGF(info, "ZDC Waveformcalibration total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1); + LOGF(info, "ZDC Waveform calibration total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1); } //________________________________________________________________ void WaveformCalibSpec::sendOutput(o2::framework::DataAllocator& output) { - /* // 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& payload = mWorker.getTowerParamUpd(); + const auto& payload = mWorker.getData(); auto& info = mWorker.getCcdbObjectInfo(); - auto image = o2::ccdb::CcdbApi::createObjectImage(&payload, &info); + auto image = o2::ccdb::CcdbApi::createObjectImage(&payload, &info); + LOG(info) << "Sending object " << info.getPath() << "/" << info.getFileName() << " of size " << image->size() + << " bytes, valid for " << info.getStartValidityTimestamp() << " : " << info.getEndValidityTimestamp(); if (mVerbosity > DbgMinimal) { payload.print(); } - LOG(info) << "Sending object " << info.getPath() << "/" << info.getFileName() << " of size " << image->size() - << " bytes, valid for " << info.getStartValidityTimestamp() << " : " << info.getEndValidityTimestamp(); - output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, "ZDC_Waveformcalib", 0}, *image.get()); // vector - output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, "ZDC_Waveformcalib", 0}, info); // root-serialized + output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, "ZDCWaveformCalib", 0}, *image.get()); // vector + output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, "ZDCWaveformCalib", 0}, info); // root-serialized // TODO: reset the outputs once they are already sent (is it necessary?) // mWorker.init(); - */ } framework::DataProcessorSpec getWaveformCalibSpec() @@ -137,38 +138,19 @@ framework::DataProcessorSpec getWaveformCalibSpec() using clbUtils = o2::calibration::Utils; std::vector inputs; - inputs.emplace_back("intercalibconfig", "ZDC", "INTERCALIBCONFIG", 0, Lifetime::Condition, o2::framework::ccdbParamSpec(fmt::format("{}", o2::zdc::CCDBPathWaveformCalibConfig.data()))); - inputs.emplace_back("energycalib", "ZDC", "ENERGYCALIB", 0, Lifetime::Condition, o2::framework::ccdbParamSpec(fmt::format("{}", o2::zdc::CCDBPathEnergyCalib.data()))); - inputs.emplace_back("towercalib", "ZDC", "TOWERCALIB", 0, Lifetime::Condition, o2::framework::ccdbParamSpec(fmt::format("{}", o2::zdc::CCDBPathTowerCalib.data()))); - inputs.emplace_back("intercalibdata", "ZDC", "INTERCALIBDATA", 0, Lifetime::Timeframe); - - char outputa[o2::header::gSizeDataDescriptionString]; - char outputd[o2::header::gSizeDataDescriptionString]; - for (int ih = 0; ih < (2 * WaveformCalibData::NH); ih++) { - snprintf(outputa, o2::header::gSizeDataDescriptionString, "inter_1dh%d", ih); - snprintf(outputd, o2::header::gSizeDataDescriptionString, "INTER_1DH%d", ih); - inputs.emplace_back(outputa, "ZDC", outputd, 0, Lifetime::Timeframe); - } - for (int ih = 0; ih < WaveformCalibData::NH; ih++) { - snprintf(outputa, o2::header::gSizeDataDescriptionString, "inter_2dh%d", ih); - snprintf(outputd, o2::header::gSizeDataDescriptionString, "INTER_2DH%d", ih); - inputs.emplace_back(outputa, "ZDC", outputd, 0, Lifetime::Timeframe); - } + inputs.emplace_back("waveformcalibdata", "ZDC", "WAVECALIBDATA", 0, Lifetime::Timeframe); + inputs.emplace_back("wavecalibconfig", "ZDC", "WAVECALIBCONFIG", 0, Lifetime::Condition, o2::framework::ccdbParamSpec(fmt::format("{}", o2::zdc::CCDBPathWaveformCalibConfig.data()))); std::vector outputs; - outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBPayload, "ZDCWaveformcalib"}, Lifetime::Sporadic); - outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper, "ZDCWaveformcalib"}, Lifetime::Sporadic); + outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBPayload, "ZDCWaveformCalib"}, Lifetime::Sporadic); + outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper, "ZDCWaveformCalib"}, Lifetime::Sporadic); return DataProcessorSpec{ - "zdc-calib-towers", + "zdc-waveformcalib", inputs, outputs, AlgorithmSpec{adaptFromTask()}, - Options{ - {"tf-per-slot", VariantType::Int, 5, {"number of TFs per calibration time slot"}}, - {"max-delay", VariantType::Int, 3, {"number of slots in past to consider"}}, - {"min-entries", VariantType::Int, 500, {"minimum number of entries to fit single time slot"}}, - {"verbosity-level", o2::framework::VariantType::Int, 1, {"Verbosity level"}}}}; + Options{{"verbosity-level", o2::framework::VariantType::Int, 1, {"Verbosity level"}}}}; } } // namespace zdc diff --git a/Detectors/ZDC/calib/src/ZDCCalibLinkDef.h b/Detectors/ZDC/calib/src/ZDCCalibLinkDef.h index 779b4b4ec5f9c..8d154bb62eedf 100644 --- a/Detectors/ZDC/calib/src/ZDCCalibLinkDef.h +++ b/Detectors/ZDC/calib/src/ZDCCalibLinkDef.h @@ -18,5 +18,6 @@ #pragma link C++ class o2::zdc::CalibParamZDC + ; #pragma link C++ class o2::zdc::InterCalibConfig + ; #pragma link C++ class o2::zdc::WaveformCalibConfig + ; +#pragma link C++ class o2::zdc::WaveformCalibData + ; #endif From bea6b04571785a90fdd9d4d934b8692cc80a5a3d Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Thu, 19 May 2022 19:55:46 +0200 Subject: [PATCH 19/40] Fix whitespace --- .../calib/include/ZDCCalib/InterCalibSpec.h | 2 +- Detectors/ZDC/calib/src/InterCalibSpec.cxx | 22 +++++++++---------- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/Detectors/ZDC/calib/include/ZDCCalib/InterCalibSpec.h b/Detectors/ZDC/calib/include/ZDCCalib/InterCalibSpec.h index e6551ea86b726..5a26d24a8bcf1 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/InterCalibSpec.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/InterCalibSpec.h @@ -49,7 +49,7 @@ class InterCalibSpec : public o2::framework::Task private: int mVerbosity = DbgMinimal; // Verbosity level - InterCalib mInterCalib; // Intercalibration object + InterCalib mWorker; // Intercalibration object TStopwatch mTimer; }; diff --git a/Detectors/ZDC/calib/src/InterCalibSpec.cxx b/Detectors/ZDC/calib/src/InterCalibSpec.cxx index a0f49f39a82f5..ae4fed95383a4 100644 --- a/Detectors/ZDC/calib/src/InterCalibSpec.cxx +++ b/Detectors/ZDC/calib/src/InterCalibSpec.cxx @@ -64,7 +64,7 @@ void InterCalibSpec::init(o2::framework::InitContext& ic) // int slotL = ic.options().get("tf-per-slot"); // int delay = ic.options().get("max-delay"); mVerbosity = ic.options().get("verbosity-level"); - mInterCalib.setVerbosity(mVerbosity); + mWorker.setVerbosity(mVerbosity); mTimer.CpuTime(); mTimer.Start(false); } @@ -114,29 +114,29 @@ void InterCalibSpec::updateTimeDependentParams(ProcessingContext& pc) LOG(info) << loadedConfFiles; - mInterCalib.setEnergyParam(energyParam.get()); - mInterCalib.setTowerParam(towerParam.get()); - mInterCalib.setInterCalibConfig(interConfig.get()); + mWorker.setEnergyParam(energyParam.get()); + mWorker.setTowerParam(towerParam.get()); + mWorker.setInterCalibConfig(interConfig.get()); } void InterCalibSpec::run(ProcessingContext& pc) { updateTimeDependentParams(pc); auto data = pc.inputs().get("intercalibdata"); - mInterCalib.process(data); + mWorker.process(data); for (int ih = 0; ih < (2 * InterCalibData::NH); ih++) { o2::dataformats::FlatHisto1D histoView(pc.inputs().get>(fmt::format("inter_1dh{}", ih).data())); - mInterCalib.add(ih, histoView); + mWorker.add(ih, histoView); } for (int ih = 0; ih < InterCalibData::NH; ih++) { o2::dataformats::FlatHisto2D histoView(pc.inputs().get>(fmt::format("inter_2dh{}", ih).data())); - mInterCalib.add(ih, histoView); + mWorker.add(ih, histoView); } } void InterCalibSpec::endOfStream(EndOfStreamContext& ec) { - mInterCalib.endOfRun(); + mWorker.endOfRun(); mTimer.Stop(); sendOutput(ec.outputs()); LOGF(info, "ZDC Intercalibration total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1); @@ -148,8 +148,8 @@ void InterCalibSpec::sendOutput(o2::framework::DataAllocator& output) // 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& payload = mInterCalib.getTowerParamUpd(); - auto& info = mInterCalib.getCcdbObjectInfo(); + const auto& payload = mWorker.getTowerParamUpd(); + auto& info = mWorker.getCcdbObjectInfo(); auto image = o2::ccdb::CcdbApi::createObjectImage(&payload, &info); LOG(info) << "Sending object " << info.getPath() << "/" << info.getFileName() << " of size " << image->size() << " bytes, valid for " << info.getStartValidityTimestamp() << " : " << info.getEndValidityTimestamp(); @@ -159,7 +159,7 @@ void InterCalibSpec::sendOutput(o2::framework::DataAllocator& output) output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, "ZDC_Intercalib", 0}, *image.get()); // vector output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, "ZDC_Intercalib", 0}, info); // root-serialized // TODO: reset the outputs once they are already sent (is it necessary?) - // mInterCalib.init(); + // mWorker.init(); } framework::DataProcessorSpec getInterCalibSpec() From 0713c4ab9428b176979405f091343be28c4c118b Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Thu, 19 May 2022 19:57:14 +0200 Subject: [PATCH 20/40] Fix whitespace --- Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h index f0f14d735afc9..8d5cfecfabace 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h @@ -53,7 +53,7 @@ struct WaveformCalibQueue { static int peak(int pk){ return NTimeBinsPerBC * TSN * pk + NTimeBinsPerBC / 2 * TSN; } - + void configure(const WaveformCalibConfig *cfg) { mCfg = cfg; From 963e07ced32d2828ec156cbd6c1f3206c26f886b Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Thu, 19 May 2022 22:45:02 +0200 Subject: [PATCH 21/40] Room to analyze waveform for all channels --- .../calib/include/ZDCCalib/WaveformCalib.h | 1 - .../include/ZDCCalib/WaveformCalibConfig.h | 24 +++-- .../include/ZDCCalib/WaveformCalibData.h | 9 +- .../calib/include/ZDCCalib/WaveformCalibEPN.h | 1 - .../include/ZDCCalib/WaveformCalibQueue.h | 11 +-- .../ZDC/calib/src/WaveformCalibConfig.cxx | 91 +++++++++++-------- Detectors/ZDC/calib/src/WaveformCalibData.cxx | 67 +++++++------- Detectors/ZDC/calib/src/WaveformCalibEPN.cxx | 17 ++-- .../ZDC/calib/src/WaveformCalibQueue.cxx | 26 +++--- 9 files changed, 132 insertions(+), 115 deletions(-) diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalib.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalib.h index 2d6839c6916a0..f1cc45b5f15e2 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalib.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalib.h @@ -33,7 +33,6 @@ class WaveformCalib public: WaveformCalib() = default; int init(); - static constexpr int NH = WaveformCalibConfig::NH; void clear(); int process(const WaveformCalibData& data); // Calibration of RUN3 data - aggregator node int endOfRun(); // Perform minimization diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h index bdd9781a1ed50..3bcd278d6b311 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h @@ -12,6 +12,8 @@ #ifndef O2_ZDC_WAVEFORMCALIBCONFIG_H #define O2_ZDC_WAVEFORMCALIBCONFIG_H +#define O2_ZDC_WAVEFORMCALIB_DEBUG + #include "ZDCBase/Constants.h" #include #include @@ -26,8 +28,6 @@ namespace o2 namespace zdc { struct WaveformCalibConfig { - - static constexpr int NH = NTDCChannels; static constexpr int NBB = 3; static constexpr int NBA = 6; static constexpr int NBT = NBB + NBA + 1; @@ -35,11 +35,11 @@ struct WaveformCalibConfig { WaveformCalibConfig(); - double cutLow[NH]; /// Amplitude cut low - double cutHigh[NH]; /// Amplitude cut high - double cutTimeLow[NH]; /// TDC cut low - double cutTimeHigh[NH]; /// TDC cut high - double min_e[NH] = {0.}; + double cutLow[NChannels]; /// Amplitude cut low + double cutHigh[NChannels]; /// Amplitude cut high + double min_e[NChannels] = {0.}; /// Minimum entries to compute waveform + double cutTimeLow[NTDCChannels]; /// TDC cut low + double cutTimeHigh[NTDCChannels]; /// TDC cut high std::string desc = ""; int ibeg = -NBB; int iend = NBA; @@ -60,17 +60,21 @@ struct WaveformCalibConfig { void setCutHigh(int ih, double val); void setCuts(double low, double high); void setCuts(int ih, double low, double high); + void setTimeCuts(double low, double high); + void setTimeCuts(int itdc, double low, double high); void setDescription(std::string d) { desc = d; } - int getFirst() const{ + int getFirst() const + { return ibeg; } - int getLast() const{ + int getLast() const + { return iend; } - ClassDefNV(WaveformCalibConfig, 2); + ClassDefNV(WaveformCalibConfig, 1); }; } // namespace zdc } // namespace o2 diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h index 40cf5a3b0d400..4a5cfcbe0d4a7 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h @@ -26,7 +26,6 @@ namespace zdc { struct WaveformCalibData { - static constexpr int NH = WaveformCalibConfig::NH; static constexpr int NBB = WaveformCalibConfig::NBB; static constexpr int NBA = WaveformCalibConfig::NBA; static constexpr int NBT = WaveformCalibConfig::NBT; @@ -36,10 +35,10 @@ struct WaveformCalibData { uint64_t mCTimeEnd = 0; /// Time of processed time frame int mN = 0; /// Number of bunches in waveform int mPeak = 0; /// Peak position - std::array mFirstValid; - std::array mLastValid; - std::array mWave[NH] = {0}; - uint32_t mEntries[NH] = {0}; + std::array mFirstValid; + std::array mLastValid; + std::array mWave[NChannels] = {0}; + uint32_t mEntries[NChannels] = {0}; WaveformCalibData& operator+=(const WaveformCalibData& other); int getEntries(int ih) const; void print() const; diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h index 59ab2b133db39..85e54cff8f83e 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h @@ -29,7 +29,6 @@ class WaveformCalibEPN public: WaveformCalibEPN() = default; int init(); - static constexpr int NH = WaveformCalibConfig::NH; void clear(int ih = -1); int process(const gsl::span& bcrec, const gsl::span& energy, diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h index 8d5cfecfabace..2e3a03ffeae09 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h @@ -33,7 +33,6 @@ namespace zdc { struct WaveformCalibQueue { - static constexpr int NH = WaveformCalibConfig::NH; WaveformCalibQueue() = default; WaveformCalibQueue(WaveformCalibConfig *cfg) { @@ -73,7 +72,7 @@ struct WaveformCalibQueue { std::deque mIR; std::deque mEntry; - std::deque mHasInfos[NH]; + std::deque mHasInfos[NChannels]; std::deque mNTDC[NTDCChannels]; std::deque mTDCA[NTDCChannels]; std::deque mTDCP[NTDCChannels]; @@ -83,8 +82,8 @@ struct WaveformCalibQueue { { mIR.clear(); mEntry.clear(); - for (int ih = 0; ih < NH; ih++) { - mHasInfos[ih].clear(); + for (int isig = 0; isig < NChannels; isig++) { + mHasInfos[isig].clear(); } for (int itdc = 0; itdc < NTDCChannels; itdc++) { mNTDC[itdc].clear(); @@ -98,8 +97,8 @@ struct WaveformCalibQueue { { mIR.pop_front(); mEntry.pop_front(); - for (int ih = 0; ih < NH; ih++) { - mHasInfos[ih].pop_front(); + for (int isig = 0; isig < NChannels; isig++) { + mHasInfos[isig].pop_front(); } for (int itdc = 0; itdc < NTDCChannels; itdc++) { mNTDC[itdc].pop_front(); diff --git a/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx b/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx index 5403afc0d41e7..7919bcf29890b 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx @@ -15,11 +15,13 @@ using namespace o2::zdc; WaveformCalibConfig::WaveformCalibConfig() { - for (int ih = 0; ih < NH; ih++) { - cutLow[ih] = -std::numeric_limits::infinity(); - cutHigh[ih] = std::numeric_limits::infinity(); - cutTimeLow[ih] = -2.5; - cutTimeHigh[ih] = 2.5; + for (int isig = 0; isig < NTDCChannels; isig++) { + cutLow[isig] = -std::numeric_limits::infinity(); + cutHigh[isig] = std::numeric_limits::infinity(); + } + for (int itdc = 0; itdc < NTDCChannels; itdc++) { + cutTimeLow[itdc] = -2.5; + cutTimeHigh[itdc] = 2.5; } } @@ -43,89 +45,106 @@ void WaveformCalibConfig::restrictRange(int ib, int ie) void WaveformCalibConfig::print() const { LOG(info) << "WaveformCalibConfig range [" << ibeg << ":" << iend << "]"; - for (Int_t ih = 0; ih < NH; ih++) { - LOG(info) << ChannelNames[TDCSignal[ih]] << " limits = (" << cutLow[ih] << " : " << cutHigh[ih] << ") min_entries = " << min_e[ih]; + for (Int_t isig = 0; isig < NChannels; isig++) { + LOG(info) << ChannelNames[isig] << " limits A = (" << cutLow[isig] << " : " << cutHigh[isig] << ") min_entries = " << min_e[isig]; + } + for (Int_t itdc = 0; itdc < NTDCChannels; itdc++) { + LOG(info) << ChannelNames[TDCSignal[itdc]] << " T = (" << cutTimeLow[itdc] << " : " << cutTimeHigh[itdc] << ")"; } } void WaveformCalibConfig::setMinEntries(double val) { - for (int32_t ih = 0; ih < NH; ih++) { - min_e[ih] = val; + for (int32_t isig = 0; isig < NChannels; isig++) { + min_e[isig] = val; } } -void WaveformCalibConfig::setMinEntries(int ih, double val) +void WaveformCalibConfig::setMinEntries(int isig, double val) { - min_e[ih] = val; + min_e[isig] = val; } void WaveformCalibConfig::resetCuts() { - for (int32_t ih = 0; ih < NH; ih++) { - cutLow[ih] = -std::numeric_limits::infinity(); - cutHigh[ih] = std::numeric_limits::infinity(); + for (int32_t isig = 0; isig < NChannels; isig++) { + cutLow[isig] = -std::numeric_limits::infinity(); + cutHigh[isig] = std::numeric_limits::infinity(); } } void WaveformCalibConfig::resetCutLow() { - for (int32_t ih = 0; ih < NH; ih++) { - cutLow[ih] = -std::numeric_limits::infinity(); + for (int32_t isig = 0; isig < NChannels; isig++) { + cutLow[isig] = -std::numeric_limits::infinity(); } } void WaveformCalibConfig::resetCutHigh() { - for (int32_t ih = 0; ih < NH; ih++) { - cutHigh[ih] = std::numeric_limits::infinity(); + for (int32_t isig = 0; isig < NChannels; isig++) { + cutHigh[isig] = std::numeric_limits::infinity(); } } -void WaveformCalibConfig::resetCutLow(int ih) +void WaveformCalibConfig::resetCutLow(int isig) { - cutLow[ih] = -std::numeric_limits::infinity(); + cutLow[isig] = -std::numeric_limits::infinity(); } -void WaveformCalibConfig::resetCutHigh(int ih) +void WaveformCalibConfig::resetCutHigh(int isig) { - cutHigh[ih] = std::numeric_limits::infinity(); + cutHigh[isig] = std::numeric_limits::infinity(); } void WaveformCalibConfig::setCutLow(double val) { - for (int32_t ih = 0; ih < NH; ih++) { - cutLow[ih] = val; + for (int32_t isig = 0; isig < NChannels; isig++) { + cutLow[isig] = val; } } void WaveformCalibConfig::setCutHigh(double val) { - for (int32_t ih = 0; ih < NH; ih++) { - cutHigh[ih] = val; + for (int32_t isig = 0; isig < NChannels; isig++) { + cutHigh[isig] = val; } } -void WaveformCalibConfig::setCutLow(int ih, double val) +void WaveformCalibConfig::setCutLow(int isig, double val) { - cutLow[ih] = val; + cutLow[isig] = val; } -void WaveformCalibConfig::setCutHigh(int ih, double val) +void WaveformCalibConfig::setCutHigh(int isig, double val) { - cutHigh[ih] = val; + cutHigh[isig] = val; } void WaveformCalibConfig::setCuts(double low, double high) { - for (int32_t ih = 0; ih < NH; ih++) { - cutLow[ih] = low; - cutHigh[ih] = high; + for (int32_t isig = 0; isig < NChannels; isig++) { + cutLow[isig] = low; + cutHigh[isig] = high; + } +} + +void WaveformCalibConfig::setCuts(int isig, double low, double high) +{ + cutHigh[isig] = low; + cutLow[isig] = high; +} + +void WaveformCalibConfig::setTimeCuts(double low, double high) +{ + for (int32_t itdc = 0; itdc < NTDCChannels; itdc++) { + cutTimeLow[itdc] = low; + cutTimeHigh[itdc] = high; } } -void WaveformCalibConfig::setCuts(int ih, double low, double high) +void WaveformCalibConfig::setTimeCuts(int itdc, double low, double high) { - cutHigh[ih] = low; - cutLow[ih] = high; + cutTimeHigh[itdc] = low; + cutTimeLow[itdc] = high; } diff --git a/Detectors/ZDC/calib/src/WaveformCalibData.cxx b/Detectors/ZDC/calib/src/WaveformCalibData.cxx index 2c05ca389ed26..58a4a675ecbc3 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibData.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibData.cxx @@ -20,9 +20,9 @@ using namespace o2::zdc; void WaveformCalibData::print() const { LOGF(info, "WaveformCalibData mN = %d/%d", mN, NBT); - for (int32_t ih = 0; ih < NH; ih++) { - if (mEntries[ih] > 0) { - LOGF(info, "WaveformCalibData %2d [%llu : %llu]: entries=%d [%d:%d:%d]", ih, mCTimeBeg, mCTimeEnd, mEntries[ih], mFirstValid[ih], mPeak, mLastValid[ih]); + for (int32_t is = 0; is < NChannels; is++) { + if (mEntries[is] > 0) { + LOGF(info, "WaveformCalibData %2d %s [%llu : %llu]: entries=%d [%d:%d:%d]", is, ChannelNames[is].data(), mCTimeBeg, mCTimeEnd, mEntries[is], mFirstValid[is], mPeak, mLastValid[is]); } } } @@ -43,16 +43,18 @@ WaveformCalibData& WaveformCalibData::operator+=(const WaveformCalibData& other) if (other.mCTimeEnd > mCTimeEnd) { mCTimeEnd = other.mCTimeEnd; } - for (int32_t ih = 0; ih < NH; ih++) { - if (mFirstValid[ih] > other.mFirstValid[ih]) { - mFirstValid[ih] = other.mFirstValid[ih]; + for (int32_t is = 0; is < NChannels; is++) { + if(other.mEntries[is]>0){ + if (mFirstValid[is] > other.mFirstValid[is]) { + mFirstValid[is] = other.mFirstValid[is]; } - if (mLastValid[ih] > other.mLastValid[ih]) { - mLastValid[ih] = other.mLastValid[ih]; + if (mLastValid[is] > other.mLastValid[is]) { + mLastValid[is] = other.mLastValid[is]; + } + mEntries[is] = mEntries[is] + other.mEntries[is]; + for (int32_t i = mFirstValid[is]; i <= mLastValid[is]; i++) { + mWave[is][i] = mWave[is][i] + other.mWave[is][i]; } - mEntries[ih] = mEntries[ih] + other.mEntries[ih]; - for (int32_t i = mFirstValid[ih]; i <= mLastValid[ih]; i++) { - mWave[ih][i] = mWave[ih][i] + other.mWave[ih][i]; } } #ifdef O2_ZDC_DEBUG @@ -71,10 +73,10 @@ void WaveformCalibData::setCreationTime(uint64_t ctime) #endif } -int WaveformCalibData::getEntries(int ih) const +int WaveformCalibData::getEntries(int is) const { - if (ih < 0 || ih >= NH) { - LOGF(error, "WaveformCalibData::getEntries ih = %d is out of range", ih); + if (is < 0 || is >= NChannels) { + LOGF(error, "WaveformCalibData::getEntries channel index %d is out of range", is); return 0; } return 0; // TODO @@ -82,11 +84,11 @@ int WaveformCalibData::getEntries(int ih) const void WaveformCalibData::setN(int n) { - if (n >= 0 && n < WaveformCalibConfig::NBT) { + if (n >= 0 && n < NBT) { mN = n; - for (int ih = 0; ih < NH; ih++) { - mFirstValid[ih] = 0; - mLastValid[ih] = NH * NTimeBinsPerBC * TSN - 1; + for (int is = 0; is < NChannels; is++) { + mFirstValid[is] = 0; + mLastValid[is] = NBT * NTimeBinsPerBC * TSN - 1; } } else { LOG(fatal) << "WaveformCalibData " << __func__ << " wrong stored b.c. setting " << n << " not in range [0:" << WaveformCalibConfig::NBT << "]"; @@ -101,20 +103,19 @@ int WaveformCalibData::write(const std::string fn) LOG(error) << "Cannot create file: " << fn; return 1; } - for (int32_t ih = 0; ih < NH; ih++) { - if (mEntries[ih] > 0) { + for (int32_t is = 0; is < NChannels; is++) { + if (mEntries[is] > 0) { // For the moment we study only TDC channels - int isig = TDCSignal[ih]; - TString n = TString::Format("h%d", isig); - TString t = TString::Format("Waveform %d %s", isig, ChannelNames[isig].data()); - int nbx = mLastValid[ih] - mFirstValid[ih] + 1; - int min = mFirstValid[ih] - mPeak - 0.5; - int max = mLastValid[ih] - mPeak + 0.5; + TString n = TString::Format("h%d", is); + TString t = TString::Format("Waveform %d %s", is, ChannelNames[is].data()); + int nbx = mLastValid[is] - mFirstValid[is] + 1; + int min = mFirstValid[is] - mPeak - 0.5; + int max = mLastValid[is] - mPeak + 0.5; TH1F h(n, t, nbx, min, max); for (int ibx = 0; ibx < nbx; ibx++) { - h.SetBinContent(ibx + 1, mWave[ih][mFirstValid[ih] + ibx]); + h.SetBinContent(ibx + 1, mWave[is][mFirstValid[is] + ibx]); } - h.SetEntries(mEntries[ih]); + h.SetEntries(mEntries[is]); h.Write("", TObject::kOverwrite); } } @@ -129,12 +130,12 @@ void WaveformCalibData::clear() mCTimeEnd = 0; mN = 0; mPeak = 0; - for (int32_t ih = 0; ih < NH; ih++) { - mEntries[ih] = 0; - mFirstValid[ih] = -1; - mLastValid[ih] = -1; + for (int32_t is = 0; is < NChannels; is++) { + mEntries[is] = 0; + mFirstValid[is] = -1; + mLastValid[is] = -1; for (int iw = 0; iw < NW; iw++) { - mWave[ih][iw] = 0; + mWave[is][iw] = 0; } } } diff --git a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx index d83e68fe8bde4..ab9ec0867effa 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx @@ -71,11 +71,10 @@ int WaveformCalibEPN::process(const gsl::span& RecBC, uint32_t mask = mQueue.append(ev); if (mask != 0) { // Analyze signals that refer to the TDC channels that satisfy condition - // For the moment this is the same as for the TDCs - for (int itdc = 0; itdc < NTDCChannels; itdc++) { + for (int isig = 0; isig < NChannels; isig++) { + int itdc = SignalTDC[isig]; if ((mask & (0x1 << itdc)) != 0) { // Check which channels have consecutive data - int isig = TDCSignal[itdc]; mQueue.addData(isig, wave, mData); } } @@ -88,11 +87,13 @@ int WaveformCalibEPN::endOfRun() { if (mVerbosity > DbgZero) { LOGF(info, "WaveformCalibEPN::endOfRun ts (%llu:%llu)", mData.mCTimeBeg, mData.mCTimeEnd); - for (int ih = 0; ih < NH; ih++) { - LOGF(info, "Waveform %2d with %10d events and cuts AMP:(%g:%g) TDC:(%g:%g) Valid:[%d:%d:%d]", ih, mData.mEntries[ih], - mConfig->cutLow[ih], mConfig->cutHigh[ih], - mConfig->cutTimeLow[ih], mConfig->cutTimeHigh[ih], - mData.mFirstValid[ih], mData.mPeak, mData.mLastValid[ih]); + for (int is = 0; is < NChannels; is++) { + if (mData.mEntries[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(), + mData.mEntries[is], mConfig->cutLow[is], mConfig->cutHigh[is], + mConfig->cutTimeLow[is], mConfig->cutTimeHigh[is], + mData.mFirstValid[is], mData.mPeak, mData.mLastValid[is]); + } } } if (mSaveDebugHistos) { diff --git a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx index ddc0b767e7713..724a94cd4fd6d 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx @@ -87,25 +87,23 @@ void WaveformCalibQueue::appendEv(RecEventFlat& ev) mFirstW.push_back(firstw); mNW.push_back(nw); - for (int ih = 0; ih < NH; ih++) { - mHasInfos[ih].push_back(false); + for (int isig = 0; isig < NChannels; isig++) { + mHasInfos[isig].push_back(false); } if (ev.getNInfo() > 0) { // Need clean data (no messages) - // We are sure there is no pile-up in any channel (too restrictive?) auto& decodedInfo = ev.getDecodedInfo(); for (uint16_t info : decodedInfo) { uint8_t ch = (info >> 10) & 0x1f; uint16_t code = info & 0x03ff; - auto& last = mHasInfos[SignalTDC[ch]].back(); + auto& last = mHasInfos[ch].back(); last = true; } // if (mVerbosity > DbgMinimal) { // ev.print(); // } } - // NOTE: for the moment NH = NTDCChannels. If we want to extend it to all channels - // we will need to have a mask of affected channels (towers contributing to sum) + // TDC channels are used to select reconstructed waveforms for (int32_t itdc = 0; itdc < NTDCChannels; itdc++) { int ich = o2::zdc::TDCSignal[itdc]; int nhit = ev.NtdcV(itdc); @@ -193,14 +191,12 @@ int WaveformCalibQueue::addData(int isig, const gsl::span data.mFirstValid[ih]) { - data.mFirstValid[ih] = ipos; + if (ipos > data.mFirstValid[isig]) { + data.mFirstValid[isig] = ipos; } // We know that points are consecutive for (int ib = 0; ib < mN; ib++) { @@ -209,7 +205,7 @@ int WaveformCalibQueue::addData(int isig, const gsl::span= 0 && ipos < mNP) { - data.mWave[ih][ipos] += mywave.inter[ip]; + data.mWave[isig][ipos] += mywave.inter[ip]; } ipos++; } @@ -218,10 +214,10 @@ int WaveformCalibQueue::addData(int isig, const gsl::span Date: Fri, 20 May 2022 13:07:25 +0200 Subject: [PATCH 22/40] WIP --- .../ZDC/include/DataFormatsZDC/RecEventFlat.h | 10 +- .../ZDC/base/include/ZDCBase/ModuleConfig.h | 3 + Detectors/ZDC/base/src/ModuleConfig.cxx | 36 +++ .../include/ZDCCalib/WaveformCalibQueue.h | 9 + Detectors/ZDC/calib/src/WaveformCalib.cxx | 66 ++++-- Detectors/ZDC/calib/src/WaveformCalibEPN.cxx | 21 +- .../ZDC/calib/src/WaveformCalibQueue.cxx | 32 ++- .../include/ZDCReconstruction/DigiReco.h | 14 +- Detectors/ZDC/reconstruction/src/DigiReco.cxx | 224 +++++++++++++----- Detectors/ZDC/workflow/src/DigitRecoSpec.cxx | 12 +- 10 files changed, 321 insertions(+), 106 deletions(-) diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventFlat.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventFlat.h index cad0e7c19556a..5ac0b321a4a74 100644 --- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventFlat.h +++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventFlat.h @@ -64,7 +64,7 @@ struct RecEventFlat { // NOLINT: false positive in clang-tidy !! std::array isBeg{}; //! Beginning of sequence std::array isEnd{}; //! End of sequence BCRecData mCurB; //! Current BC - std::vector inter[NTDCChannels]; //! Interpolated samples + std::vector inter[NChannels]; //! Interpolated samples // Reconstruction messages std::array genericE{}; /// 0 Generic error @@ -102,11 +102,11 @@ struct RecEventFlat { // NOLINT: false positive in clang-tidy !! int next(); int at(int ientry); - void allocate(int itdc){ - if(inter[itdc].size()!=NIS){ - inter[itdc].resize(NIS); + void allocate(int isig){ + if(inter[isig].size()!=NIS){ + inter[isig].resize(NIS); for(int iis=0; iis #include +#include namespace o2 { @@ -54,6 +55,8 @@ struct ModuleConfig { void print() const; void check() const; + uint32_t getTriggerMask() const; + std::string getPrintTriggerMask() const; ClassDefNV(ModuleConfig, 1); }; diff --git a/Detectors/ZDC/base/src/ModuleConfig.cxx b/Detectors/ZDC/base/src/ModuleConfig.cxx index 5b9abdf1fd25f..291d76a14c51c 100644 --- a/Detectors/ZDC/base/src/ModuleConfig.cxx +++ b/Detectors/ZDC/base/src/ModuleConfig.cxx @@ -108,3 +108,39 @@ void Module::setChannel(int slot, int8_t chID, int16_t fID, bool read, bool trig trigChannelConf[slot].threshold = tT; } } + +//______________________________________________________________________________ +uint32_t ModuleConfig::getTriggerMask() const +{ + uint32_t triggermask = 0; + for (int im = 0; im < NModules; im++) { + for (int ic = 0; ic < NChPerModule; ic++) { + if (modules[im].trigChannel[ic]) { + uint32_t tmask = 0x1 << (im * NChPerModule + ic); + triggermask = triggermask | tmask; + } + } + } + return triggermask; +} + +std::string ModuleConfig::getPrintTriggerMask() const +{ + std::string printTriggerMask{}; + for (int im = 0; im < NModules; im++) { + if (im > 0) { + printTriggerMask += " "; + } + printTriggerMask += std::to_string(im); + printTriggerMask += "["; + for (int ic = 0; ic < NChPerModule; ic++) { + if (modules[im].trigChannel[ic]) { + printTriggerMask += "T"; + } else { + printTriggerMask += " "; + } + } + printTriggerMask += "]"; + } + return printTriggerMask; +} diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h index 2e3a03ffeae09..088174b262b5c 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h @@ -78,8 +78,12 @@ struct WaveformCalibQueue { std::deque mTDCP[NTDCChannels]; std::deque mFirstW; std::deque mNW; + void clear() { +#ifdef O2_ZDC_WAVEFORMCALIB_DEBUG + LOG(info) << "WaveformCalibConfig::" << __func__; +#endif mIR.clear(); mEntry.clear(); for (int isig = 0; isig < NChannels; isig++) { @@ -93,6 +97,7 @@ struct WaveformCalibQueue { mFirstW.clear(); mNW.clear(); } + void pop() { mIR.pop_front(); @@ -107,7 +112,11 @@ struct WaveformCalibQueue { } mFirstW.pop_front(); mNW.pop_front(); +#ifdef O2_ZDC_WAVEFORMCALIB_DEBUG + LOG(info) << "WaveformCalibConfig::" << __func__ << " remaining: " << mNW.size(); +#endif } + uint32_t append(RecEventFlat& ev); void appendEv(RecEventFlat& ev); int hasData(int isig, const gsl::span& wave); diff --git a/Detectors/ZDC/calib/src/WaveformCalib.cxx b/Detectors/ZDC/calib/src/WaveformCalib.cxx index 4f49da2f8b368..5e3729161e302 100644 --- a/Detectors/ZDC/calib/src/WaveformCalib.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalib.cxx @@ -11,18 +11,15 @@ #include #include -#include +#include #include #include #include -#include -#include -#include "CommonUtils/MemFileHelper.h" +#include "ZDCCalib/CalibParamZDC.h" #include "ZDCCalib/WaveformCalib.h" #include "ZDCCalib/WaveformCalibQueue.h" -#include "ZDCReconstruction/ZDCEnergyParam.h" -#include "ZDCReconstruction/ZDCTowerParam.h" #include "Framework/Logger.h" +#include "CommonUtils/MemFileHelper.h" #include "CCDB/CcdbApi.h" using namespace o2::zdc; @@ -33,6 +30,20 @@ int WaveformCalib::init() LOG(fatal) << "o2::zdc::WaveformCalib: missing configuration object"; return -1; } + + auto* cfg = mConfig; + if (mVerbosity > DbgZero) { + mConfig->print(); + } + + // Inspect reconstruction parameters + o2::zdc::CalibParamZDC& opt = const_cast(CalibParamZDC::Instance()); + opt.print(); + + if (opt.debug_output > 0) { + setSaveDebugHistos(); + } + clear(); mData.setN(mConfig->nbun); mData.mPeak = WaveformCalibQueue::peak(-(mConfig->ibeg)); @@ -41,7 +52,28 @@ int WaveformCalib::init() } //______________________________________________________________________________ -// Update calibration object +void WaveformCalib::clear() +{ + mData.clear(); +} + +//______________________________________________________________________________ +int WaveformCalib::process(const WaveformCalibData& data) +{ + if (!mInitDone) { + init(); + } + // Add checks before addition + if ((mData.mN != data.mN) || (mData.mPeak != data.mPeak)) { + LOG(fatal) << "WaveformCalib::process adding inconsistent data mN cfg=" << mData.mN << " vs data=" << data.mN << " mPeak cfg=" << mData.mPeak << " vs data=" << data.mPeak; + return -1; + } + mData += data; + return 0; +} + +//______________________________________________________________________________ +// Create calibration object int WaveformCalib::endOfRun() { if (mVerbosity > DbgZero) { @@ -69,25 +101,7 @@ int WaveformCalib::endOfRun() return 0; } -void WaveformCalib::clear() -{ - mData.clear(); -} - -int WaveformCalib::process(const WaveformCalibData& data) -{ - if (!mInitDone) { - init(); - } - // Add checks before addition - if ((mData.mN != data.mN) || (mData.mPeak != data.mPeak)) { - LOG(fatal) << "WaveformCalib::process adding inconsistent data mN cfg=" << mData.mN << " vs data=" << data.mN << " mPeak cfg=" << mData.mPeak << " vs data=" << data.mPeak; - return -1; - } - mData += data; - return 0; -} - +//______________________________________________________________________________ int WaveformCalib::write(const std::string fn) { return mData.write(fn); diff --git a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx index ab9ec0867effa..7f447ba295211 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx @@ -9,7 +9,6 @@ // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. -#include #include #include #include @@ -54,6 +53,7 @@ int WaveformCalibEPN::init() return 0; } +//______________________________________________________________________________ int WaveformCalibEPN::process(const gsl::span& RecBC, const gsl::span& Energy, const gsl::span& TDCData, @@ -69,7 +69,24 @@ int WaveformCalibEPN::process(const gsl::span& RecBC, std::vector ir; while (int ientry = ev.next()) { uint32_t mask = mQueue.append(ev); +#ifdef O2_ZDC_WAVEFORMCALIB_DEBUG + LOGF(info, "WaveformCalibEPN::%s mask=0x%04x %s %s %s %s %s %s %s %s %s %s", __func__, mask, + (mask & 0x001) ? ChannelNames[TDCSignal[0]] : " ", + (mask & 0x002) ? ChannelNames[TDCSignal[1]] : " ", + (mask & 0x004) ? ChannelNames[TDCSignal[2]] : " ", + (mask & 0x008) ? ChannelNames[TDCSignal[3]] : " ", + (mask & 0x010) ? ChannelNames[TDCSignal[4]] : " ", + (mask & 0x020) ? ChannelNames[TDCSignal[5]] : " ", + (mask & 0x040) ? ChannelNames[TDCSignal[6]] : " ", + (mask & 0x080) ? ChannelNames[TDCSignal[7]] : " ", + (mask & 0x100) ? ChannelNames[TDCSignal[8]] : " ", + (mask & 0x200) ? ChannelNames[TDCSignal[9]] : " "); +#endif if (mask != 0) { +#ifdef O2_ZDC_WAVEFORMCALIB_DEBUG + ev.print(); + ev.printDecodedMessages(); +#endif // Analyze signals that refer to the TDC channels that satisfy condition for (int isig = 0; isig < NChannels; isig++) { int itdc = SignalTDC[isig]; @@ -83,6 +100,7 @@ int WaveformCalibEPN::process(const gsl::span& RecBC, return 0; } +//______________________________________________________________________________ int WaveformCalibEPN::endOfRun() { if (mVerbosity > DbgZero) { @@ -102,6 +120,7 @@ int WaveformCalibEPN::endOfRun() return 0; } +//______________________________________________________________________________ int WaveformCalibEPN::write(const std::string fn) { return mData.write(fn); diff --git a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx index 724a94cd4fd6d..284f7b52b92b8 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx @@ -78,6 +78,9 @@ uint32_t WaveformCalibQueue::append(RecEventFlat& ev) void WaveformCalibQueue::appendEv(RecEventFlat& ev) { +#ifdef O2_ZDC_WAVEFORMCALIB_DEBUG + LOGF(info, "WaveformCalibQueue::%s %u.%04u", __func__, ev.ir.orbit, ev.ir.bc); +#endif mIR.push_back(ev.ir); mEntry.push_back(ev.getNextEntry() - 1); @@ -87,6 +90,7 @@ void WaveformCalibQueue::appendEv(RecEventFlat& ev) mFirstW.push_back(firstw); mNW.push_back(nw); + // Note: pile-up messages are computed only for the 10 TDCs for (int isig = 0; isig < NChannels; isig++) { mHasInfos[isig].push_back(false); } @@ -132,7 +136,9 @@ int WaveformCalibQueue::hasData(int isig, const gsl::span::infinity(); for (int ib = 0; ib < mN; ib++) { int ifound = false; - // LOG(info) << "mNW[" << ib << "] = " << mNW[ib] << " mFirstW = " << mFirstW[ib]; +#ifdef O2_ZDC_WAVEFORMCALIB_DEBUG + LOG(info) << "WaveformCalibQueue::" << __func__ << " mNW[" << ib << "] = " << mNW[ib] << " mFirstW = " << mFirstW[ib]; +#endif for (int iw = 0; iw < mNW[ib]; iw++) { auto& mywave = wave[iw + mFirstW[ib]]; if (mywave.ch() == isig) { @@ -155,7 +161,9 @@ int WaveformCalibQueue::hasData(int isig, const gsl::span::infinity(); + bool hasInfos = false; for (int ib = 0; ib < mN; ib++) { - int ifound = false; + bool ifound = false; // LOG(info) << "mNW[" << ib << "] = " << mNW[ib] << " mFirstW = " << mFirstW[ib]; for (int iw = 0; iw < mNW[ib]; iw++) { + // Signal shouldn't have info messages. We check also corresponding TDC signal for pile-up information + // TODO: relax this condition to avoid to check pedestal messages since pedestal is subtracted + // when converting waveform calibration object into SimConfig object + if(mHasInfos[isig][iw] || mHasInfos[TDCSignal[SignalTDC[isig]]][iw]){ + LOG(info) << "isig="<getTriggerMask(); + prepareInterpolation(); if (mTreeDbg) { @@ -257,7 +259,7 @@ void DigiReco::init() if (mModuleConfig->modules[im].channelID[ic] == ich && mModuleConfig->modules[im].readChannel[ic]) { ropt.amod[ich] = im; ropt.ach[ich] = ic; - // Fill mask to identify TDC channels + // Fill mask to identify all channels mChMask[ich] = (0x1 << (4 * im + ic)); goto next_ich; } @@ -357,7 +359,7 @@ void DigiReco::prepareInterpolation() int DigiReco::process(const gsl::span& orbitdata, const gsl::span& bcdata, const gsl::span& chdata) { -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG LOG(info) << "________________________________________________________________________________"; LOG(info) << __func__; #endif @@ -405,13 +407,13 @@ int DigiReco::process(const gsl::span& orbitdata, cons } // Probably this is not necessary - // for(int itdc=0; itdc& orbitdata, cons // Low pass filtering if (mLowPassFilter) { + // N.B. At the moment low pass filtering is performed only on TDC + // signals and not on the rest of the signals lowPassFilter(); } else { // Copy samples @@ -452,10 +456,29 @@ int DigiReco::process(const gsl::span& orbitdata, cons } } + if(mFullInterpolation){ + // Copy remaining channels + for (int isig = 0; isig < NChannels; isig++) { + int isig_tdc = TDCSignal[SignalTDC[isig]]; + if (isig == isig_tdc) { + // Already copied + continue; + } + for (int ibc = 0; ibc < mNBC; ibc++) { + auto ref_c = mReco[ibc].ref[isig]; + if (ref_c != ZDCRefInitVal) { + for (int is = 0; is < NTimeBinsPerBC; is++) { + mReco[ibc].data[isig][is] = mChData[ref_c].data[is]; + } + } + } + } + } + // Find consecutive bunch crossings by taking into account just the presence // of bunch crossing data and then perform signal interpolation in the identified ranges. // With this definition of "consecutive" bunch crossings gaps in the sample data - // may be present , therefore in the reconstruction method we take into account for signals + // may be present, therefore in the reconstruction method we take into account for signals // that do not span the entire range int seq_beg = 0; int seq_end = 0; @@ -486,6 +509,10 @@ int DigiReco::process(const gsl::span& orbitdata, cons // Look for another bunch seq_end = ibc; } +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG + // Here in order to avoid mixing information + mBCData[ibc].print(mTriggerMask); +#endif } // Apply pile-up correction for TDCs to get corrected TDC amplitudes and values @@ -527,7 +554,7 @@ void DigiReco::lowPassFilter() // First attempt to low pass filtering uses the average of three consecutive samples // ringing noise has T~6 ns w.r.t. a sampling period of ~ 2 ns // one should get smoothing of the noise -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG LOG(info) << "________________________________________________________________________________"; LOG(info) << __func__; #endif @@ -598,7 +625,7 @@ void DigiReco::lowPassFilter() void DigiReco::reconstructTDC(int ibeg, int iend) { -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG LOG(info) << "________________________________________________________________________________"; LOG(info) << __func__ << "(" << ibeg << ", " << iend << ")"; #endif @@ -642,11 +669,47 @@ void DigiReco::reconstructTDC(int ibeg, int iend) // The following TDC processing stage findSignals(..) assumes that time shift // due to pile-up has been corrected because main-main is assumed to be // in position 0 + // In case we do full interpolation, we process also the channels that are not + // considered in TDC list + if (mFullInterpolation) { + for (int isig = 0; isig < NChannels; isig++) { + int isig_tdc = TDCSignal[SignalTDC[isig]]; + if (isig == isig_tdc) { + // Already computed + continue; + } + // Check if channel has valid data for consecutive bunches in current bunch range + // N.B. there are events recorded from ibeg-iend but we are not sure if it is the + // case for every channel + int istart = -1, istop = -1; + // Loop allows for gaps in the data sequence for each TDC channel + for (int ibun = ibeg; ibun <= iend; ibun++) { + if (mBCData[ibun].channels & mChMask[isig]) { // Channel has data for this event + if (istart < 0) { + istart = ibun; + } + istop = ibun; + } else { // No data from channel + // A gap is detected + if (istart >= 0 && (istop - istart) > 0) { + // Need data for at least two consecutive bunch crossings + fullInterpolation(isig, istart, istop); + } + istart = -1; + istop = -1; + } + } + // Check if there are consecutive bunch crossings at the end of group + if (istart >= 0 && (istop - istart) > 0) { + fullInterpolation(isig, istart, istop); + } + } + } } // reconstructTDC int DigiReco::reconstruct(int ibeg, int iend) { -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG LOG(info) << "________________________________________________________________________________"; LOG(info) << __func__ << "(" << ibeg << ", " << iend << "): " << mReco[ibeg].ir.orbit << "." << mReco[ibeg].ir.bc << " - " << mReco[iend].ir.orbit << "." << mReco[iend].ir.bc; #endif @@ -660,7 +723,7 @@ int DigiReco::reconstruct(int ibeg, int iend) } return 0; } -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG for (int ibun = ibeg; ibun <= iend; ibun++) { printf("%d CH Mask: 0x%08x TDC data for:", ibun, mBCData[ibun].channels); for (int itdc = 0; itdc < NTDCChannels; itdc++) { @@ -723,7 +786,7 @@ int DigiReco::reconstruct(int ibeg, int iend) mt.w = mBCData[ibun].moduleTriggers[mRopt->amod[ich]]; hasAuto0[bcd] = mt.f.Auto_0; hasAutoM[bcd] = mt.f.Auto_m; -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG printf("%2d %s bcd = %d ibun = %d ibeg = %d ref = %3u %s %s %s\n", ich, ChannelNames[ich].data(), bcd, ibun, ibeg, ref[bcd], hasHit[bcd] ? "H" : "-", hasAuto0[bcd] ? "A0" : "--", hasAutoM[bcd] ? "AM" : "--"); @@ -880,7 +943,7 @@ void DigiReco::updateOffsets(int ibun) if (mSource[ich] == PedND) { LOGF(error, "Missing pedestal for ch %2d %s orbit %u ", ich, ChannelNames[ich], mOffsetOrbit); } -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG LOGF(info, "Pedestal for ch %2d %s orbit %u %s: %f", ich, ChannelNames[ich], mOffsetOrbit, mSource[ich] == PedOr ? "OR" : (mSource[ich] == PedQC ? "QC" : "??"), mOffset[ich]); #endif } @@ -888,7 +951,7 @@ void DigiReco::updateOffsets(int ibun) void DigiReco::processTrigger(int itdc, int ibeg, int iend) { -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG LOG(info) << __func__ << "(itdc=" << itdc << "[" << ChannelNames[TDCSignal[itdc]] << "], " << ibeg << ", " << iend << "): " << mReco[ibeg].ir.orbit << "." << mReco[ibeg].ir.bc << " - " << mReco[iend].ir.orbit << "." << mReco[iend].ir.bc; #endif // Extracting TDC information for TDC number itdc, in consecutive bunches from ibeg to iend @@ -899,7 +962,7 @@ void DigiReco::processTrigger(int itdc, int ibeg, int iend) int is1 = 0, is2 = 1; uint8_t isfired = 0; -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG int16_t m[3] = {0}; int16_t s[3] = {0}; #endif @@ -907,7 +970,7 @@ void DigiReco::processTrigger(int itdc, int ibeg, int iend) for (;;) { // Shift data isfired = isfired << 1; -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG for (int i = 2; i > 0; i--) { m[i] = m[i - 1]; s[i] = s[i - 1]; @@ -933,7 +996,7 @@ void DigiReco::processTrigger(int itdc, int ibeg, int iend) } int diff = mChData[ref_m].data[s1] - mChData[ref_s].data[s2]; // Triple trigger condition -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG m[0] = mChData[ref_m].data[s1]; s[0] = mChData[ref_s].data[s2]; #endif @@ -943,7 +1006,7 @@ void DigiReco::processTrigger(int itdc, int ibeg, int iend) // Fired bit is assigned to the second sample, i.e. to the one that can identify the // signal peak position mReco[b2].fired[itdc] |= mMask[s2]; -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG if (mTriggerCondition == 0x7) { printf("0x7 TDC %d[%s] Fired @ %u.%u.s%02u (%5d-%5d)=%5d>%2d && (%5d-%5d)=%5d>%2d && (s%02d:%-5d-s%02d:%-5d)=%5d>%2d\n", itdc, ChannelNames[TDCSignal[itdc]].data(), mReco[b2].ir.orbit, mReco[b2].ir.bc, s2, @@ -979,7 +1042,7 @@ void DigiReco::processTrigger(int itdc, int ibeg, int iend) void DigiReco::processTriggerExtended(int itdc, int ibeg, int iend) { auto isig = TDCSignal[itdc]; -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG LOG(info) << __func__ << "(itdc=" << itdc << "[" << ChannelNames[isig] << "], " << ibeg << ", " << iend << "): " << mReco[ibeg].ir.orbit << "." << mReco[ibeg].ir.bc << " - " << mReco[iend].ir.orbit << "." << mReco[iend].ir.bc; #endif // Extends search zone at the beginning of sequence. Need pedestal information. @@ -1001,7 +1064,7 @@ void DigiReco::processTriggerExtended(int itdc, int ibeg, int iend) int is1 = -shift, is2 = 0; uint8_t isfired = 0; -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG int16_t m[3] = {0}; int16_t s[3] = {0}; #endif @@ -1010,7 +1073,7 @@ void DigiReco::processTriggerExtended(int itdc, int ibeg, int iend) for (;;) { // Shift data isfired = isfired << 1; -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG for (int i = 2; i > 0; i--) { m[i] = m[i - 1]; s[i] = s[i - 1]; @@ -1028,7 +1091,7 @@ void DigiReco::processTriggerExtended(int itdc, int ibeg, int iend) return; } diff = mOffset[isig] - mChData[ref_s].data[s2]; -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG m[0] = mOffset[isig]; s[0] = mChData[ref_s].data[s2]; #endif @@ -1047,7 +1110,7 @@ void DigiReco::processTriggerExtended(int itdc, int ibeg, int iend) return; } diff = mChData[ref_m].data[s1] - mChData[ref_s].data[s2]; -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG m[0] = mChData[ref_m].data[s1]; s[0] = mChData[ref_s].data[s2]; #endif @@ -1059,7 +1122,7 @@ void DigiReco::processTriggerExtended(int itdc, int ibeg, int iend) // Fired bit is assigned to the second sample, i.e. to the one that can identify the // signal peak position mReco[b2].fired[itdc] |= mMask[s2]; -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG if (mTriggerCondition == 0x7) { printf("0x7E TDC %d[%s] Fired @ %u.%u.s%02u (%5d-%5d)=%5d>%2d && (%5d-%5d)=%5d>%5d && (s%02d:%-5d-s%02d:%-5d)=%-5d>%2d\n", itdc, ChannelNames[TDCSignal[itdc]].data(), mReco[b2].ir.orbit, mReco[b2].ir.bc, s2, @@ -1091,11 +1154,11 @@ void DigiReco::processTriggerExtended(int itdc, int ibeg, int iend) } // processTrigger // Interpolation for single point -O2_ZDC_DIGIRECO_FLT DigiReco::getPoint(int itdc, int ibeg, int iend, int i) +O2_ZDC_DIGIRECO_FLT DigiReco::getPoint(int isig, int ibeg, int iend, int i) { constexpr int nsbun = TSN * NTimeBinsPerBC; // Total number of interpolated points per bunch crossing if (i >= mNtot || i < 0) { - LOG(fatal) << "Error addressing TDC itdc=" << itdc << " i=" << i << " mNtot=" << mNtot; + LOG(fatal) << "Error addressing isig=" << isig << " i=" << i << " mNtot=" << mNtot; return std::numeric_limits::infinity(); } // Constant extrapolation at the beginning and at the end of the array @@ -1107,7 +1170,6 @@ O2_ZDC_DIGIRECO_FLT DigiReco::getPoint(int itdc, int ibeg, int iend, int i) return mLastSample; } else { // Identification of the point to be assigned - int isig = TDCSignal[itdc]; int ibun = ibeg + i / nsbun; // Interpolation between acquired points (N.B. from 0 to mNint) i = i - TSNH; @@ -1150,7 +1212,7 @@ O2_ZDC_DIGIRECO_FLT DigiReco::getPoint(int itdc, int ibeg, int iend, int i) } } -void DigiReco::setPoint(int itdc, int ibeg, int iend, int i) +void DigiReco::setPoint(int isig, int ibeg, int iend, int i) { // This function needs to be used only if mFullInterpolation is true otherwise the // vectors are not allocated @@ -1160,30 +1222,74 @@ void DigiReco::setPoint(int itdc, int ibeg, int iend, int i) } constexpr int nsbun = TSN * NTimeBinsPerBC; // Total number of interpolated points per bunch crossing if (i >= mNtot || i < 0) { - LOG(fatal) << "Error addressing TDC itdc=" << itdc << " i=" << i << " mNtot=" << mNtot; + LOG(fatal) << "Error addressing signal isig=" << isig << " i=" << i << " mNtot=" << mNtot; return; } // Constant extrapolation at the beginning and at the end of the array if (i < TSNH) { // Assign value of first sample - mReco[ibeg].inter[itdc][i] = mFirstSample; + mReco[ibeg].inter[isig][i] = mFirstSample; } else if (i >= mIlast) { // Assign value of last sample int isam = i % nsbun; - mReco[iend].inter[itdc][isam] = mLastSample; + mReco[iend].inter[isig][isam] = mLastSample; } else { // Identification of the point to be assigned int ibun = ibeg + i / nsbun; int isam = i % nsbun; - mReco[ibun].inter[itdc][isam] = getPoint(itdc, ibeg, iend, i); + mReco[ibun].inter[isig][isam] = getPoint(isig, ibeg, iend, i); } } // setPoint +void DigiReco::fullInterpolation(int isig, int ibeg, int iend) +{ + // Interpolation of signal isig, in consecutive bunches from ibeg to iend + // This function works for all signals and does not evaluate trigger + // You need to call interpolate(int itdc... for the TDC signals +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG + LOG(info) << __func__ << "(isig=" << isig << "[" << ChannelNames[isig] << "], " << ibeg << ", " << iend << "): " << mReco[ibeg].ir.orbit << "." << mReco[ibeg].ir.bc << " - " << mReco[iend].ir.orbit << "." << mReco[iend].ir.bc; +#endif + + // TODO: get data from preceding time frame in case there are bunches + // with signal at the beginning of the first orbit of a time frame + + constexpr int MaxTimeBin = NTimeBinsPerBC - 1; //< number of samples per BC + + // Set data members for interpolation of the current channel + mNbun = iend - ibeg + 1; // Number of adjacent bunches + mNsam = mNbun * NTimeBinsPerBC; // Number of acquired samples + mNtot = mNsam * TSN; // Total number of points in the interpolated arrays + mNint = (mNbun * NTimeBinsPerBC - 1) * TSN; // Total points in the interpolation region (-1) + mIlast = mNtot - TSNH; // Index of last acquired sample + + // At this level there should be no need to check if the channel is connected + // since a fatal should have been raised already + for (int ibun = ibeg; ibun <= iend; ibun++) { + auto ref = mReco[ibun].ref[isig]; + if (ref == ZDCRefInitVal) { + LOG(fatal) << "Missing information for bunch crossing"; + } + } + + mFirstSample = mReco[ibeg].data[isig][0]; + mLastSample = mReco[iend].data[isig][MaxTimeBin]; + + // Allocate and fill array of interpolated points + for (int ibun = ibeg; ibun <= iend; ibun++) { + mReco[ibun].allocate(isig); + } + for (int i = 0; i < mNtot; i++) { + setPoint(isig, ibeg, iend, i); + } +} + void DigiReco::interpolate(int itdc, int ibeg, int iend) { - // Interpolation of signal for TDC number itdc, in consecutive bunches from ibeg to iend -#ifdef O2_ZDC_DEBUG - LOG(info) << __func__ << "(itdc=" << itdc << "[" << ChannelNames[TDCSignal[itdc]] << "], " << ibeg << ", " << iend << "): " << mReco[ibeg].ir.orbit << "." << mReco[ibeg].ir.bc << " - " << mReco[iend].ir.orbit << "." << mReco[iend].ir.bc; + // Interpolation of TDC channel itdc, in consecutive bunches from ibeg to iend + int isig = TDCSignal[itdc]; + +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG + LOG(info) << __func__ << "(itdc=" << itdc << "[" << ChannelNames[isig] << "], " << ibeg << ", " << iend << "): " << mReco[ibeg].ir.orbit << "." << mReco[ibeg].ir.bc << " - " << mReco[iend].ir.orbit << "." << mReco[iend].ir.bc; #endif // TODO: get data from preceding time frame in case there are bunches @@ -1191,6 +1297,7 @@ void DigiReco::interpolate(int itdc, int ibeg, int iend) constexpr int MaxTimeBin = NTimeBinsPerBC - 1; //< number of samples per BC constexpr int nsbun = TSN * NTimeBinsPerBC; // Total number of interpolated points per bunch crossing + // Set data members for interpolation of the current TDC mNbun = iend - ibeg + 1; // Number of adjacent bunches mNsam = mNbun * NTimeBinsPerBC; // Number of acquired samples @@ -1200,11 +1307,7 @@ void DigiReco::interpolate(int itdc, int ibeg, int iend) constexpr int nsp = 5; // Number of points to be searched - int imod = mRopt->tmod[itdc]; // Module corresponding to TDC channel - // int ich = mRopt->tch[itdc]; // Hardware channel corresponding to TDC channel - int isig = TDCSignal[itdc]; // Signal corresponding to TDC - - // At this level there should be no need to check if the TDC channel is connected + // At this level there should be no need to check if the channel is connected // since a fatal should have been raised already for (int ibun = ibeg; ibun <= iend; ibun++) { auto ref = mReco[ibun].ref[isig]; @@ -1213,23 +1316,22 @@ void DigiReco::interpolate(int itdc, int ibeg, int iend) } } - auto ref_beg = mReco[ibeg].ref[isig]; - auto ref_end = mReco[iend].ref[isig]; + // auto ref_beg = mReco[ibeg].ref[isig]; + // auto ref_end = mReco[iend].ref[isig]; + // mFirstSample = mChData[ref_beg].data[0]; // Original points + // mLastSample = mChData[ref_end].data[MaxTimeBin]; // Original points mFirstSample = mReco[ibeg].data[isig][0]; mLastSample = mReco[iend].data[isig][MaxTimeBin]; - // mFirstSample = mChData[ref_beg].data[0]; // Original points - // mLastSample = mChData[ref_end].data[MaxTimeBin]; // Original points // mFullInterpolation turns on full interpolation for debugging // otherwise the interpolation is performed only around actual signal - // TODO: extend full interpolation to all channels if (mFullInterpolation) { for (int ibun = ibeg; ibun <= iend; ibun++) { - mReco[ibun].allocate(itdc); + mReco[ibun].allocate(isig); } for (int i = 0; i < mNtot; i++) { - setPoint(itdc, ibeg, iend, i); + setPoint(isig, ibeg, iend, i); } } @@ -1375,10 +1477,10 @@ void DigiReco::interpolate(int itdc, int ibeg, int iend) O2_ZDC_DIGIRECO_FLT myval; if (mFullInterpolation) { // Already interpolated - myval = mReco[ib_cur].inter[itdc][mysam]; + myval = mReco[ib_cur].inter[isig][mysam]; } else { // Perform interpolation for the searched point - myval = getPoint(itdc, ibeg, iend, isam); + myval = getPoint(isig, ibeg, iend, isam); } // Get local minimum of waveform if (myval < amp) { @@ -1474,7 +1576,7 @@ void DigiReco::assignTDC(int ibun, int ibeg, int iend, int itdc, int tdc, float } else { rec.tdcPedMissing[isig] = true; } -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG LOG(info) << __func__ << " itdc=" << itdc << " " << ChannelNames[isig] << " @ ibun=" << ibun << " " << mReco[ibun].ir.orbit << "." << mReco[ibun].ir.bc << " " << " tdc=" << tdc << " -> " << TDCValCorr << " shift=" << tdc_shift[itdc] << " -> TDCVal=" << TDCVal << "=" << TDCVal * o2::zdc::FTDCVal << " mSource[" << isig << "] = " << unsigned(mSource[isig]) << " = " << mOffset[isig] @@ -1487,7 +1589,7 @@ void DigiReco::assignTDC(int ibun, int ibeg, int iend, int itdc, int tdc, float void DigiReco::findSignals(int ibeg, int iend) { // N.B. findSignals is called after pile-up correction on TDCs -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG LOG(info) << __func__ << "(" << ibeg << ", " << iend << "): " << mReco[ibeg].ir.orbit << "." << mReco[ibeg].ir.bc << " - " << mReco[iend].ir.orbit << "." << mReco[iend].ir.bc; #endif // Identify TDC signals @@ -1495,7 +1597,7 @@ void DigiReco::findSignals(int ibeg, int iend) updateOffsets(ibun); // Get orbit pedestals or QC fallback auto& rec = mReco[ibun]; for (int itdc = 0; itdc < NTDCChannels; itdc++) { -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG bool msg = false; if (rec.fired[itdc] != 0x0) { msg = true; @@ -1507,7 +1609,7 @@ void DigiReco::findSignals(int ibeg, int iend) #endif rec.pattern[itdc] = 0; for (int32_t i = 0; i < rec.ntdc[itdc]; i++) { -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG msg = true; printf(" %d TDC A=%5.0f @ T=%5.0f", i, rec.TDCAmp[itdc][i], rec.TDCVal[itdc][i]); #endif @@ -1516,7 +1618,7 @@ void DigiReco::findSignals(int ibeg, int iend) if (std::abs(rec.TDCVal[itdc][i]) < mRopt->tdc_search[itdc]) { rec.pattern[itdc] = 1; } -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG if (rec.pattern[itdc] == 1) { printf(" in_r"); } else { @@ -1524,14 +1626,14 @@ void DigiReco::findSignals(int ibeg, int iend) } #endif } -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG if (msg) { printf("\n"); } #endif } -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG printf("%d %u.%-4u TDC PATTERN: ", ibun, mReco[ibun].ir.orbit, mReco[ibun].ir.bc); for (int itdc = 0; itdc < NTDCChannels; itdc++) { printf("%d", rec.pattern[itdc]); @@ -1613,7 +1715,7 @@ void DigiReco::correctTDCPile() // In case TDC correction parameters are missing (e.g. mTDCCorr==0) then // pile-up is flagged but not corrected for -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG LOG(info) << "________________________________________________________________________________"; LOG(info) << __func__; #endif @@ -1694,7 +1796,7 @@ int DigiReco::correctTDCSignal(int itdc, int16_t TDCVal, float TDCAmp, float& fT fTDCAmp = TDCAmp; if (mTDCCorr == nullptr) { -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG printf("%21s itdc=%d TDC=%d AMP=%d MISSING mTDCCorr\n", __func__, itdc, TDCVal, TDCAmp); #endif return 1; @@ -1755,7 +1857,7 @@ int DigiReco::correctTDCSignal(int itdc, int16_t TDCVal, float TDCAmp, float& fT } } } else { -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG printf("%21s itdc=%d TDC=%d AMP=%d LONELY BUNCH\n", __func__, itdc, TDCVal, TDCAmp); #endif return 1; @@ -1774,7 +1876,7 @@ int DigiReco::correctTDCBackground(int ibc, int itdc, std::deque& t // therefore we refer just to TDC hit in position [0] float TDCValUnc = rec->TDCVal[itdc][0]; float TDCAmpUnc = rec->TDCAmp[itdc][0]; -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG auto TDCValUncBck = rec->TDCVal[itdc][0]; auto TDCAmpUncBck = rec->TDCAmp[itdc][0]; #endif @@ -1941,7 +2043,7 @@ int DigiReco::correctTDCBackground(int ibc, int itdc, std::deque& t } // Loop on signal bucket position (ibuks) rec->TDCVal[itdc][0] = TDCValBest; rec->TDCAmp[itdc][0] = TDCAmpBest; -#ifdef O2_ZDC_DEBUG +#ifdef ALICEO2_ZDC_DIGI_RECO_DEBUG if (rec->TDCVal[itdc][0] != TDCValUnc || rec->TDCAmp[itdc][0] != TDCAmpUnc) { printf("%21s ibc=%d itdc=%d sn = %d", __func__, ibc, itdc, TDCSigBest); printf(" TDC=%f -> %f", TDCValUncBck, rec->TDCVal[itdc][0]); diff --git a/Detectors/ZDC/workflow/src/DigitRecoSpec.cxx b/Detectors/ZDC/workflow/src/DigitRecoSpec.cxx index 13bcbb4ccafda..a1bd65fab4838 100644 --- a/Detectors/ZDC/workflow/src/DigitRecoSpec.cxx +++ b/Detectors/ZDC/workflow/src/DigitRecoSpec.cxx @@ -195,16 +195,16 @@ void DigitRecoSpec::run(ProcessingContext& pc) nt++; recEvent.addTDC(it, reca.TDCVal[it][ih], reca.TDCAmp[it][ih], reca.isBeg[it], reca.isEnd[it]); } - // Add waveform information - if (fullinter) { - // For the moment only TDC channels are interpolated - if (reca.inter[it].size() == NIS) { + } + // Add waveform information + if (fullinter) { + for (int32_t isig = 0; isig < o2::zdc::NChannels; isig++) { + if (reca.inter[isig].size() == NIS) { if (toAddBC) { recEvent.addBC(reca); toAddBC = false; } - auto isig = TDCSignal[it]; - recEvent.addWaveform(isig, reca.inter[it]); + recEvent.addWaveform(isig, reca.inter[isig]); ntw++; } } From 0cb1cda056d158f463f0740121848bc0d7d6fd38 Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Fri, 20 May 2022 15:05:54 +0200 Subject: [PATCH 23/40] WIP --- .../include/ZDCCalib/WaveformCalibQueue.h | 36 ++++++------ Detectors/ZDC/calib/src/WaveformCalibData.cxx | 23 ++++---- Detectors/ZDC/calib/src/WaveformCalibEPN.cxx | 1 + .../ZDC/calib/src/WaveformCalibQueue.cxx | 55 ++++++++++++++++--- 4 files changed, 78 insertions(+), 37 deletions(-) diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h index 088174b262b5c..4d2fa45fbb466 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h @@ -34,26 +34,27 @@ namespace zdc struct WaveformCalibQueue { WaveformCalibQueue() = default; - WaveformCalibQueue(WaveformCalibConfig *cfg) + WaveformCalibQueue(WaveformCalibConfig* cfg) { configure(cfg); } - int mFirst = 0; - int mLast = 0; - int mPk = 0; - int mN = 1; + int mFirst = 0; // First bunch of waveform w.r.t. signal peak + int mLast = 0; // Last bunch of waveform w.r.t. signal peak + int mPk = 0; // Bunch position of peak w.r.t. first bunch + int mN = 1; // Number of bunches in waveform int mPPos = 0; int mNP = 0; int mPeak = 0; - const WaveformCalibConfig *mCfg = nullptr; + const WaveformCalibConfig* mCfg = nullptr; - static int peak(int pk){ + static int peak(int pk) + { return NTimeBinsPerBC * TSN * pk + NTimeBinsPerBC / 2 * TSN; } - void configure(const WaveformCalibConfig *cfg) + void configure(const WaveformCalibConfig* cfg) { mCfg = cfg; int ifirst = mCfg->getFirst(); @@ -65,19 +66,19 @@ struct WaveformCalibQueue { mLast = ilast; mN = ilast - ifirst + 1; mPk = -mFirst; - mPPos = mPk * NIS + NIS/2; + mPPos = mPk * NIS + NIS / 2; mNP = mN * NIS; mPeak = peak(mPk); } - std::deque mIR; - std::deque mEntry; - std::deque mHasInfos[NChannels]; - std::deque mNTDC[NTDCChannels]; - std::deque mTDCA[NTDCChannels]; - std::deque mTDCP[NTDCChannels]; - std::deque mFirstW; - std::deque mNW; + std::deque mEntry; // Position of event + std::deque mIR; // IR of event + std::deque mHasInfos[NChannels]; // Channel has info messages + std::deque mNTDC[NTDCChannels]; // Number of TDCs in event + std::deque mTDCA[NTDCChannels]; // Peak amplitude + std::deque mTDCP[NTDCChannels]; // Peak position + std::deque mFirstW; // Position of first waveform in event + std::deque mNW; // Number of waveforms in event void clear() { @@ -121,6 +122,7 @@ struct WaveformCalibQueue { void appendEv(RecEventFlat& ev); int hasData(int isig, const gsl::span& wave); int addData(int isig, const gsl::span& wave, WaveformCalibData& data); + void print(); }; } // namespace zdc diff --git a/Detectors/ZDC/calib/src/WaveformCalibData.cxx b/Detectors/ZDC/calib/src/WaveformCalibData.cxx index 58a4a675ecbc3..64dc06b466469 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibData.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibData.cxx @@ -44,17 +44,17 @@ WaveformCalibData& WaveformCalibData::operator+=(const WaveformCalibData& other) mCTimeEnd = other.mCTimeEnd; } for (int32_t is = 0; is < NChannels; is++) { - if(other.mEntries[is]>0){ - if (mFirstValid[is] > other.mFirstValid[is]) { - mFirstValid[is] = other.mFirstValid[is]; - } - if (mLastValid[is] > other.mLastValid[is]) { - mLastValid[is] = other.mLastValid[is]; - } - mEntries[is] = mEntries[is] + other.mEntries[is]; - for (int32_t i = mFirstValid[is]; i <= mLastValid[is]; i++) { - mWave[is][i] = mWave[is][i] + other.mWave[is][i]; - } + if (other.mEntries[is] > 0) { + if (other.mFirstValid[is] > mFirstValid[is]) { + mFirstValid[is] = other.mFirstValid[is]; + } + if (other.mLastValid[is] < mLastValid[is]) { + mLastValid[is] = other.mLastValid[is]; + } + mEntries[is] = mEntries[is] + other.mEntries[is]; + for (int32_t i = mFirstValid[is]; i <= mLastValid[is]; i++) { + mWave[is][i] = mWave[is][i] + other.mWave[is][i]; + } } } #ifdef O2_ZDC_DEBUG @@ -105,7 +105,6 @@ int WaveformCalibData::write(const std::string fn) } for (int32_t is = 0; is < NChannels; is++) { if (mEntries[is] > 0) { - // For the moment we study only TDC channels TString n = TString::Format("h%d", is); TString t = TString::Format("Waveform %d %s", is, ChannelNames[is].data()); int nbx = mLastValid[is] - mFirstValid[is] + 1; diff --git a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx index 7f447ba295211..aeac367264128 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx @@ -86,6 +86,7 @@ int WaveformCalibEPN::process(const gsl::span& RecBC, #ifdef O2_ZDC_WAVEFORMCALIB_DEBUG ev.print(); ev.printDecodedMessages(); + mQueue.print(); #endif // Analyze signals that refer to the TDC channels that satisfy condition for (int isig = 0; isig < NChannels; isig++) { diff --git a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx index 284f7b52b92b8..31b900a2415ef 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx @@ -79,7 +79,7 @@ uint32_t WaveformCalibQueue::append(RecEventFlat& ev) void WaveformCalibQueue::appendEv(RecEventFlat& ev) { #ifdef O2_ZDC_WAVEFORMCALIB_DEBUG - LOGF(info, "WaveformCalibQueue::%s %u.%04u", __func__, ev.ir.orbit, ev.ir.bc); + LOGF(info, "WaveformCalibQueue::%s %u.%04u", __func__, ev.ir.orbit, ev.ir.bc); #endif mIR.push_back(ev.ir); mEntry.push_back(ev.getNextEntry() - 1); @@ -178,15 +178,17 @@ int WaveformCalibQueue::addData(int isig, const gsl::span 0) { + printf(" %2d=%6u", j, mNTDC[j][i]); + } + } + printf("\n"); + printf("mTDCA:"); + for (int j = 0; j < NTDCChannels; j++) { + if (mNTDC[j][i] > 0) { + printf(" %2d=%6.1f", j, mTDCA[j][i]); + } + } + printf("\n"); + printf("mTDCP:"); + for (int j = 0; j < NTDCChannels; j++) { + if (mNTDC[j][i] > 0) { + printf(" %2d=%6.1f", j, mTDCP[j][i]); + } + } + printf("\n"); + } +} + } // namespace zdc } // namespace o2 From 5e5dc2ada7d9c461bae8c84f12db56de1c8366be Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Fri, 20 May 2022 20:18:21 +0200 Subject: [PATCH 24/40] WIP --- .../include/ZDCCalib/WaveformCalibQueue.h | 20 +++--------- Detectors/ZDC/calib/src/WaveformCalibEPN.cxx | 4 +++ .../ZDC/calib/src/WaveformCalibQueue.cxx | 31 ++++++++++++++++++- 3 files changed, 38 insertions(+), 17 deletions(-) diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h index 4d2fa45fbb466..03bb1715f3a40 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h @@ -46,6 +46,8 @@ struct WaveformCalibQueue { int mPPos = 0; int mNP = 0; int mPeak = 0; + int mTimeLow[NChannels]; /// Cut on position difference low + int mTimeHigh[NChannels]; /// Cut on position difference high const WaveformCalibConfig* mCfg = nullptr; @@ -54,22 +56,7 @@ struct WaveformCalibQueue { return NTimeBinsPerBC * TSN * pk + NTimeBinsPerBC / 2 * TSN; } - void configure(const WaveformCalibConfig* cfg) - { - mCfg = cfg; - int ifirst = mCfg->getFirst(); - int ilast = mCfg->getLast(); - if (ifirst > 0 || ilast < 0 || ilast < ifirst) { - LOGF(fatal, "WaveformCalibQueue configure error with ifirst=%d ilast=%d", ifirst, ilast); - } - mFirst = ifirst; - mLast = ilast; - mN = ilast - ifirst + 1; - mPk = -mFirst; - mPPos = mPk * NIS + NIS / 2; - mNP = mN * NIS; - mPeak = peak(mPk); - } + void configure(const WaveformCalibConfig* cfg); std::deque mEntry; // Position of event std::deque mIR; // IR of event @@ -123,6 +110,7 @@ struct WaveformCalibQueue { int hasData(int isig, const gsl::span& wave); int addData(int isig, const gsl::span& wave, WaveformCalibData& data); void print(); + void printConf(); }; } // namespace zdc diff --git a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx index aeac367264128..c81bdf70f6d74 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx @@ -42,6 +42,10 @@ int WaveformCalibEPN::init() } mQueue.configure(cfg); + if (mVerbosity > DbgZero) { + mQueue.printConf(); + } + mQueue.printConf(); // number of bins mNBin = cfg->nbun * TSN; diff --git a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx index 31b900a2415ef..5ccee175430a0 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx @@ -17,6 +17,27 @@ namespace o2 namespace zdc { +void WaveformCalibQueue::configure(const WaveformCalibConfig* cfg) +{ + mCfg = cfg; + int ifirst = mCfg->getFirst(); + int ilast = mCfg->getLast(); + if (ifirst > 0 || ilast < 0 || ilast < ifirst) { + LOGF(fatal, "WaveformCalibQueue configure error with ifirst=%d ilast=%d", ifirst, ilast); + } + mFirst = ifirst; + mLast = ilast; + mN = ilast - ifirst + 1; + mPk = -mFirst; + mPPos = mPk * NIS + NIS / 2; + mNP = mN * NIS; + mPeak = peak(mPk); + for (int32_t isig = 0; isig < NChannels; isig++) { + mTimeLow[isig] = std::nearbyint(cfg->cutTimeLow[SignalTDC[isig]] / FTDCVal); + mTimeHigh[isig] = std::nearbyint(cfg->cutTimeHigh[SignalTDC[isig]] / FTDCVal); + } +} + // appends an event to the queue with the request that there are at most // mN consecutive bunches // The TDC conditions are checked and returned in output @@ -248,7 +269,6 @@ int WaveformCalibQueue::addData(int isig, const gsl::span Date: Mon, 23 May 2022 18:40:53 +0200 Subject: [PATCH 25/40] Indroduced cuts on tower signals --- .../include/ZDCCalib/WaveformCalibConfig.h | 2 +- .../include/ZDCCalib/WaveformCalibQueue.h | 11 ++++---- Detectors/ZDC/calib/src/WaveformCalibEPN.cxx | 1 - .../ZDC/calib/src/WaveformCalibQueue.cxx | 27 +++++++++++++++---- 4 files changed, 28 insertions(+), 13 deletions(-) diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h index 3bcd278d6b311..1b704373bc5a7 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h @@ -12,7 +12,7 @@ #ifndef O2_ZDC_WAVEFORMCALIBCONFIG_H #define O2_ZDC_WAVEFORMCALIBCONFIG_H -#define O2_ZDC_WAVEFORMCALIB_DEBUG +//#define O2_ZDC_WAVEFORMCALIB_DEBUG #include "ZDCBase/Constants.h" #include diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h index 03bb1715f3a40..0dea50388ca33 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h @@ -39,13 +39,12 @@ struct WaveformCalibQueue { configure(cfg); } - int mFirst = 0; // First bunch of waveform w.r.t. signal peak - int mLast = 0; // Last bunch of waveform w.r.t. signal peak + int mFirst = 0; // First bunch of waveform w.r.t. bunch of signal peak + int mLast = 0; // Last bunch of waveform w.r.t. bunch of signal peak int mPk = 0; // Bunch position of peak w.r.t. first bunch int mN = 1; // Number of bunches in waveform - int mPPos = 0; - int mNP = 0; - int mPeak = 0; + int mPeak = 0; // Peak position (interpolated samples) w.r.t. first point + 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 @@ -53,7 +52,7 @@ struct WaveformCalibQueue { static int peak(int pk) { - return NTimeBinsPerBC * TSN * pk + NTimeBinsPerBC / 2 * TSN; + return NIS * pk + NIS / 2; } void configure(const WaveformCalibConfig* cfg); diff --git a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx index c81bdf70f6d74..e7636984631ff 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx @@ -45,7 +45,6 @@ int WaveformCalibEPN::init() if (mVerbosity > DbgZero) { mQueue.printConf(); } - mQueue.printConf(); // number of bins mNBin = cfg->nbun * TSN; diff --git a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx index 5ccee175430a0..ce166169ef796 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx @@ -29,9 +29,8 @@ void WaveformCalibQueue::configure(const WaveformCalibConfig* cfg) mLast = ilast; mN = ilast - ifirst + 1; mPk = -mFirst; - mPPos = mPk * NIS + NIS / 2; - mNP = mN * NIS; mPeak = peak(mPk); + mNP = mN * NIS; for (int32_t isig = 0; isig < NChannels; isig++) { mTimeLow[isig] = std::nearbyint(cfg->cutTimeLow[SignalTDC[isig]] / FTDCVal); mTimeHigh[isig] = std::nearbyint(cfg->cutTimeHigh[SignalTDC[isig]] / FTDCVal); @@ -196,6 +195,7 @@ int WaveformCalibQueue::addData(int isig, const gsl::span::infinity(); + float max = -std::numeric_limits::infinity(); bool hasInfos = false; for (int ib = 0; ib < mN; ib++) { bool ifound = false; @@ -219,6 +219,9 @@ int WaveformCalibQueue::addData(int isig, const gsl::span max) { + max = mywave.inter[ip]; + } } } } @@ -234,7 +237,21 @@ int WaveformCalibQueue::addData(int isig, const gsl::spancutLow[isig] || amp > mCfg->cutHigh[isig]) { + // No warning messages for amplitude cuts on towers + 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]); + return -1; + } + } int ipos = mPeak - ppos; data.mEntries[isig]++; // Restrict validity range because of signal jitter @@ -306,9 +323,9 @@ void WaveformCalibQueue::print() void WaveformCalibQueue::printConf() { LOG(info) << "WaveformCalibQueue::" << __func__; - LOGF(info, "mFirst=%d mLast=%d mPk=%d mN=%d mPPos=%d mNP=%d mPeak=%d\n", mFirst, mLast, mPk, mN, mPPos, mNP, mPeak); + LOGF(info, "mFirst=%d mLast=%d mPk=%d mN=%d mPeak=%d/mNP=%d", mFirst, mLast, mPk, mN, mPeak, mNP); for (int isig = 0; isig < NChannels; isig++) { - LOGF(info, "ch%02d pos [%d:%d]", mTimeLow[isig], mTimeHigh[isig]); + LOGF(info, "ch%02d pos [%d:%d]", isig, mTimeLow[isig], mTimeHigh[isig]); } } From 2676d9c0d149923fdd7b04f1b727ba2642ea2b6c Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Tue, 24 May 2022 09:06:28 +0200 Subject: [PATCH 26/40] Split WaveformCalibData into two classes --- .../ZDC/include/DataFormatsZDC/RecEventFlat.h | 12 +- .../include/ZDCCalib/WaveformCalibData.h | 44 ++++++- .../include/ZDCCalib/WaveformCalibQueue.h | 12 +- Detectors/ZDC/calib/src/WaveformCalibData.cxx | 122 +++++++++++++----- Detectors/ZDC/calib/src/WaveformCalibEPN.cxx | 6 +- .../ZDC/calib/src/WaveformCalibQueue.cxx | 15 +-- Detectors/ZDC/calib/src/ZDCCalibLinkDef.h | 1 + .../ZDC/macro/CreateWaveformCalibConfig.C | 2 +- Detectors/ZDC/reconstruction/src/DigiReco.cxx | 2 +- 9 files changed, 156 insertions(+), 60 deletions(-) diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventFlat.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventFlat.h index 5ac0b321a4a74..5617ccc42a181 100644 --- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventFlat.h +++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/RecEventFlat.h @@ -102,16 +102,18 @@ struct RecEventFlat { // NOLINT: false positive in clang-tidy !! int next(); int at(int ientry); - void allocate(int isig){ - if(inter[isig].size()!=NIS){ + void allocate(int isig) + { + if (inter[isig].size() != NIS) { inter[isig].resize(NIS); - for(int iis=0; iis mData = {0}; + + WaveformCalibChData& operator+=(const WaveformCalibChData& other); + int getEntries() const; + int getFirstValid() const; + int getLastValid() const; + void clear(); + void setN(int n); + ClassDefNV(WaveformCalibChData, 1); +}; + struct WaveformCalibData { static constexpr int NBB = WaveformCalibConfig::NBB; static constexpr int NBA = WaveformCalibConfig::NBA; @@ -35,12 +53,28 @@ struct WaveformCalibData { uint64_t mCTimeEnd = 0; /// Time of processed time frame int mN = 0; /// Number of bunches in waveform int mPeak = 0; /// Peak position - std::array mFirstValid; - std::array mLastValid; - std::array mWave[NChannels] = {0}; - uint32_t mEntries[NChannels] = {0}; + + std::array mWave; WaveformCalibData& operator+=(const WaveformCalibData& other); - int getEntries(int ih) const; + inline void setFirstValid(int isig, int ipos) + { + if (ipos > mWave[isig].mFirstValid) { + mWave[isig].mFirstValid = ipos; + } + } + inline void setLastValid(int isig, int ipos) + { + if (ipos < mWave[isig].mLastValid) { + mWave[isig].mLastValid = ipos; + } + } + inline void addEntry(int isig) + { + mWave[isig].mEntries++; + } + int getEntries(int is) const; + int getFirstValid(int is) const; + int getLastValid(int is) const; void print() const; void clear(); void setCreationTime(uint64_t ctime); diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h index 0dea50388ca33..a18f23fab7ea8 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibQueue.h @@ -39,12 +39,12 @@ struct WaveformCalibQueue { configure(cfg); } - int mFirst = 0; // First bunch of waveform w.r.t. bunch of signal peak - int mLast = 0; // Last bunch of waveform w.r.t. bunch of signal peak - int mPk = 0; // Bunch position of peak w.r.t. first bunch - int mN = 1; // Number of bunches in waveform - int mPeak = 0; // Peak position (interpolated samples) w.r.t. first point - int mNP = 0; // Number of interpolated points in waveform + int mFirst = 0; // First bunch of waveform w.r.t. bunch of signal peak + int mLast = 0; // Last bunch of waveform w.r.t. bunch of signal peak + int mPk = 0; // Bunch position of peak w.r.t. first bunch + int mN = 1; // Number of bunches in waveform + int mPeak = 0; // Peak position (interpolated samples) w.r.t. first point + 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 diff --git a/Detectors/ZDC/calib/src/WaveformCalibData.cxx b/Detectors/ZDC/calib/src/WaveformCalibData.cxx index 64dc06b466469..16cab85324dec 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibData.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibData.cxx @@ -17,16 +17,18 @@ using namespace o2::zdc; +//______________________________________________________________________________ void WaveformCalibData::print() const { - LOGF(info, "WaveformCalibData mN = %d/%d", mN, NBT); + LOGF(info, "WaveformCalibData mN = %d/%d [%llu : %llu]", mN, NBT, mCTimeBeg, mCTimeEnd); for (int32_t is = 0; is < NChannels; is++) { - if (mEntries[is] > 0) { - LOGF(info, "WaveformCalibData %2d %s [%llu : %llu]: entries=%d [%d:%d:%d]", is, ChannelNames[is].data(), mCTimeBeg, mCTimeEnd, mEntries[is], mFirstValid[is], mPeak, mLastValid[is]); + if (getEntries(is) > 0) { + LOGF(info, "WaveformCalibData %2d %s: entries=%d [%d:%d:%d]", is, ChannelNames[is].data(), getEntries(is), getFirstValid(is), mPeak, getLastValid(is)); } } } +//______________________________________________________________________________ WaveformCalibData& WaveformCalibData::operator+=(const WaveformCalibData& other) { if (mN != other.mN) { @@ -44,18 +46,7 @@ WaveformCalibData& WaveformCalibData::operator+=(const WaveformCalibData& other) mCTimeEnd = other.mCTimeEnd; } for (int32_t is = 0; is < NChannels; is++) { - if (other.mEntries[is] > 0) { - if (other.mFirstValid[is] > mFirstValid[is]) { - mFirstValid[is] = other.mFirstValid[is]; - } - if (other.mLastValid[is] < mLastValid[is]) { - mLastValid[is] = other.mLastValid[is]; - } - mEntries[is] = mEntries[is] + other.mEntries[is]; - for (int32_t i = mFirstValid[is]; i <= mLastValid[is]; i++) { - mWave[is][i] = mWave[is][i] + other.mWave[is][i]; - } - } + mWave[is] += other.mWave[is]; } #ifdef O2_ZDC_DEBUG LOG(info) << __func__; @@ -64,6 +55,24 @@ WaveformCalibData& WaveformCalibData::operator+=(const WaveformCalibData& other) return *this; } +WaveformCalibChData& WaveformCalibChData::operator+=(const WaveformCalibChData& other) +{ + if (other.mEntries > 0) { + if (other.mFirstValid > mFirstValid) { + mFirstValid = other.mFirstValid; + } + if (other.mLastValid < mLastValid) { + mLastValid = other.mLastValid; + } + mEntries = mEntries + other.mEntries; + for (int32_t i = mFirstValid; i <= mLastValid; i++) { + mData[i] = mData[i] + other.mData[i]; + } + } + return *this; +} + +//______________________________________________________________________________ void WaveformCalibData::setCreationTime(uint64_t ctime) { mCTimeBeg = ctime; @@ -73,28 +82,75 @@ void WaveformCalibData::setCreationTime(uint64_t ctime) #endif } +//______________________________________________________________________________ int WaveformCalibData::getEntries(int is) const { if (is < 0 || is >= NChannels) { LOGF(error, "WaveformCalibData::getEntries channel index %d is out of range", is); return 0; } - return 0; // TODO + return mWave[is].getEntries(); +} + +int WaveformCalibChData::getEntries() const +{ + return mEntries; +} + +//______________________________________________________________________________ +int WaveformCalibData::getFirstValid(int is) const +{ + if (is < 0 || is >= NChannels) { + LOGF(error, "WaveformCalibData::getFirstValid channel index %d is out of range", is); + return 0; + } + return mWave[is].getFirstValid(); +} + +int WaveformCalibChData::getFirstValid() const +{ + return mFirstValid; +} + +//______________________________________________________________________________ +int WaveformCalibData::getLastValid(int is) const +{ + if (is < 0 || is >= NChannels) { + LOGF(error, "WaveformCalibData::getLastValid channel index %d is out of range", is); + return 0; + } + return mWave[is].getLastValid(); +} + +int WaveformCalibChData::getLastValid() const +{ + return mLastValid; } +//______________________________________________________________________________ void WaveformCalibData::setN(int n) { if (n >= 0 && n < NBT) { mN = n; for (int is = 0; is < NChannels; is++) { - mFirstValid[is] = 0; - mLastValid[is] = NBT * NTimeBinsPerBC * TSN - 1; + mWave[is].setN(n); } } else { LOG(fatal) << "WaveformCalibData " << __func__ << " wrong stored b.c. setting " << n << " not in range [0:" << WaveformCalibConfig::NBT << "]"; } } +void WaveformCalibChData::setN(int n) +{ + 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:" << WaveformCalibConfig::NBT << "]"; + } +} + +//______________________________________________________________________________ int WaveformCalibData::write(const std::string fn) { TDirectory* cwd = gDirectory; @@ -104,17 +160,17 @@ int WaveformCalibData::write(const std::string fn) return 1; } for (int32_t is = 0; is < NChannels; is++) { - if (mEntries[is] > 0) { + if (mWave[is].mEntries > 0) { TString n = TString::Format("h%d", is); TString t = TString::Format("Waveform %d %s", is, ChannelNames[is].data()); - int nbx = mLastValid[is] - mFirstValid[is] + 1; - int min = mFirstValid[is] - mPeak - 0.5; - int max = mLastValid[is] - mPeak + 0.5; + int nbx = mWave[is].mLastValid - mWave[is].mFirstValid + 1; + int min = mWave[is].mFirstValid - mPeak - 0.5; + int max = mWave[is].mLastValid - mPeak + 0.5; TH1F h(n, t, nbx, min, max); for (int ibx = 0; ibx < nbx; ibx++) { - h.SetBinContent(ibx + 1, mWave[is][mFirstValid[is] + ibx]); + h.SetBinContent(ibx + 1, mWave[is].mData[mWave[is].mFirstValid + ibx]); } - h.SetEntries(mEntries[is]); + h.SetEntries(mWave[is].mEntries); h.Write("", TObject::kOverwrite); } } @@ -123,6 +179,7 @@ int WaveformCalibData::write(const std::string fn) return 0; } +//______________________________________________________________________________ void WaveformCalibData::clear() { mCTimeBeg = 0; @@ -130,11 +187,16 @@ void WaveformCalibData::clear() mN = 0; mPeak = 0; for (int32_t is = 0; is < NChannels; is++) { - mEntries[is] = 0; - mFirstValid[is] = -1; - mLastValid[is] = -1; - for (int iw = 0; iw < NW; iw++) { - mWave[is][iw] = 0; - } + mWave[is].clear(); + } +} + +void WaveformCalibChData::clear() +{ + mEntries = 0; + mFirstValid = -1; + mLastValid = -1; + for (int iw = 0; iw < NW; iw++) { + mData[iw] = 0; } } diff --git a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx index e7636984631ff..1cf58cebe1f0a 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx @@ -110,11 +110,11 @@ int WaveformCalibEPN::endOfRun() if (mVerbosity > DbgZero) { LOGF(info, "WaveformCalibEPN::endOfRun ts (%llu:%llu)", mData.mCTimeBeg, mData.mCTimeEnd); for (int is = 0; is < NChannels; is++) { - if (mData.mEntries[is] > 0) { + 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(), - mData.mEntries[is], mConfig->cutLow[is], mConfig->cutHigh[is], + mData.getEntries(is), mConfig->cutLow[is], mConfig->cutHigh[is], mConfig->cutTimeLow[is], mConfig->cutTimeHigh[is], - mData.mFirstValid[is], mData.mPeak, mData.mLastValid[is]); + mData.getFirstValid(is), mData.mPeak, mData.getLastValid(is)); } } } diff --git a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx index ce166169ef796..e019b5f386018 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibQueue.cxx @@ -253,11 +253,9 @@ int WaveformCalibQueue::addData(int isig, const gsl::span data.mFirstValid[isig]) { - data.mFirstValid[isig] = ipos; - } + data.setFirstValid(isig, ipos); // We know that points are consecutive for (int ib = 0; ib < mN; ib++) { for (int iw = 0; iw < mNW[ib]; iw++) { @@ -265,7 +263,8 @@ int WaveformCalibQueue::addData(int isig, const gsl::span= 0 && ipos < mNP) { - data.mWave[isig][ipos] += mywave.inter[ip]; + // We don't use incapsulation because this section is called too many times + data.mWave[isig].mData[ipos] += mywave.inter[ip]; } ipos++; } @@ -274,11 +273,9 @@ int WaveformCalibQueue::addData(int isig, const gsl::span& orbitdata, cons } } - if(mFullInterpolation){ + if (mFullInterpolation) { // Copy remaining channels for (int isig = 0; isig < NChannels; isig++) { int isig_tdc = TDCSignal[SignalTDC[isig]]; From 108451654d0044caadf1a782a6bbf5682ab97ef3 Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Tue, 24 May 2022 10:25:07 +0200 Subject: [PATCH 27/40] Improve printout --- Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h | 6 +++--- Detectors/ZDC/calib/src/WaveformCalibEPNSpec.cxx | 4 ---- Detectors/ZDC/calib/src/WaveformCalibSpec.cxx | 6 +----- Detectors/ZDC/calib/src/ZDCCalibLinkDef.h | 1 + 4 files changed, 5 insertions(+), 12 deletions(-) diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h index 9866bf5ec03b8..81587d9892877 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h @@ -29,9 +29,9 @@ struct WaveformCalibChData { static constexpr int NBT = WaveformCalibConfig::NBT; static constexpr int NW = WaveformCalibConfig::NW; - int mFirstValid = 0; - int mLastValid = 0; - uint32_t mEntries = 0; + int mFirstValid = 0; /// First bin with valid data + int mLastValid = 0; /// Last bin with valid data + uint32_t mEntries = 0; /// Number of waveforms added std::array mData = {0}; WaveformCalibChData& operator+=(const WaveformCalibChData& other); diff --git a/Detectors/ZDC/calib/src/WaveformCalibEPNSpec.cxx b/Detectors/ZDC/calib/src/WaveformCalibEPNSpec.cxx index 8d63212591d62..38a931e36bcc3 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibEPNSpec.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibEPNSpec.cxx @@ -86,10 +86,6 @@ void WaveformCalibEPNSpec::run(ProcessingContext& pc) } else { loadedConfFiles += " "; loadedConfFiles += ct; - if (mVerbosity > DbgZero) { - LOG(info) << "Loaded configuration object: " << ct; - config->print(); - } mWorker.setConfig(config.get()); } LOG(info) << loadedConfFiles; diff --git a/Detectors/ZDC/calib/src/WaveformCalibSpec.cxx b/Detectors/ZDC/calib/src/WaveformCalibSpec.cxx index 81914038a6605..7da1619dd1541 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibSpec.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibSpec.cxx @@ -86,10 +86,6 @@ void WaveformCalibSpec::run(ProcessingContext& pc) } else { loadedConfFiles += " "; loadedConfFiles += ct; - if (mVerbosity > DbgZero) { - LOG(info) << "Loaded configuration object: " << ct; - config->print(); - } mWorker.setConfig(config.get()); } LOG(info) << loadedConfFiles; @@ -123,7 +119,7 @@ void WaveformCalibSpec::sendOutput(o2::framework::DataAllocator& output) auto image = o2::ccdb::CcdbApi::createObjectImage(&payload, &info); LOG(info) << "Sending object " << info.getPath() << "/" << info.getFileName() << " of size " << image->size() << " bytes, valid for " << info.getStartValidityTimestamp() << " : " << info.getEndValidityTimestamp(); - if (mVerbosity > DbgMinimal) { + if (mVerbosity > DbgZero) { payload.print(); } output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, "ZDCWaveformCalib", 0}, *image.get()); // vector diff --git a/Detectors/ZDC/calib/src/ZDCCalibLinkDef.h b/Detectors/ZDC/calib/src/ZDCCalibLinkDef.h index a0cea1feccb62..0b701c2816f7b 100644 --- a/Detectors/ZDC/calib/src/ZDCCalibLinkDef.h +++ b/Detectors/ZDC/calib/src/ZDCCalibLinkDef.h @@ -16,6 +16,7 @@ #pragma link off all functions; #pragma link C++ class o2::zdc::CalibParamZDC + ; +#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::zdc::CalibParamZDC> + ; #pragma link C++ class o2::zdc::InterCalibConfig + ; #pragma link C++ class o2::zdc::WaveformCalibConfig + ; #pragma link C++ class o2::zdc::WaveformCalibChData + ; From 6938be1d3310e7e50fa0cf389ac7c31ecdc02924 Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Tue, 24 May 2022 12:13:52 +0200 Subject: [PATCH 28/40] Moving InterCalibData.h and InterCalibData.cxx to ZDCCalib --- DataFormats/Detectors/ZDC/CMakeLists.txt | 5 ++--- .../Detectors/ZDC/include/DataFormatsZDC/OrbitData.h | 6 +++--- DataFormats/Detectors/ZDC/src/DataFormatsZDCLinkDef.h | 1 - Detectors/ZDC/calib/CMakeLists.txt | 2 ++ Detectors/ZDC/calib/include/ZDCCalib/InterCalib.h | 2 +- .../ZDC/calib/include/ZDCCalib}/InterCalibData.h | 0 Detectors/ZDC/calib/include/ZDCCalib/InterCalibEPN.h | 2 +- Detectors/ZDC/calib/include/ZDCCalib/InterCalibEPNSpec.h | 2 +- Detectors/ZDC/calib/include/ZDCCalib/InterCalibSpec.h | 2 +- Detectors/ZDC/calib/src/InterCalib.cxx | 2 +- .../ZDC => Detectors/ZDC/calib}/src/InterCalibData.cxx | 2 +- Detectors/ZDC/calib/src/InterCalibEPN.cxx | 2 +- Detectors/ZDC/calib/src/ZDCCalibLinkDef.h | 1 + 13 files changed, 15 insertions(+), 14 deletions(-) rename {DataFormats/Detectors/ZDC/include/DataFormatsZDC => Detectors/ZDC/calib/include/ZDCCalib}/InterCalibData.h (100%) rename {DataFormats/Detectors/ZDC => Detectors/ZDC/calib}/src/InterCalibData.cxx (97%) diff --git a/DataFormats/Detectors/ZDC/CMakeLists.txt b/DataFormats/Detectors/ZDC/CMakeLists.txt index f03f491708646..2e69c27e74c0a 100644 --- a/DataFormats/Detectors/ZDC/CMakeLists.txt +++ b/DataFormats/Detectors/ZDC/CMakeLists.txt @@ -12,7 +12,7 @@ o2_add_library(DataFormatsZDC SOURCES src/ChannelData.cxx src/BCData.cxx src/BCRecData.cxx src/RecEvent.cxx src/RecEventAux.cxx src/RawEventData.cxx src/OrbitRawData.cxx src/OrbitRecData.cxx src/OrbitData.cxx src/ZDCTDCData.cxx src/ZDCEnergy.cxx src/ZDCWaveform.cxx - src/CTF.cxx src/RecEventFlat.cxx src/InterCalibData.cxx + src/CTF.cxx src/RecEventFlat.cxx PUBLIC_LINK_LIBRARIES O2::CommonConstants O2::CommonDataFormat O2::DetectorsCalibration O2::ZDCBase ROOT::MathCore FairRoot::Base O2::SimulationDataFormat @@ -25,5 +25,4 @@ o2_target_root_dictionary(DataFormatsZDC include/DataFormatsZDC/RecEvent.h include/DataFormatsZDC/RecEventAux.h include/DataFormatsZDC/RecEventFlat.h include/DataFormatsZDC/OrbitRawData.h include/DataFormatsZDC/ZDCTDCData.h include/DataFormatsZDC/BCRecData.h include/DataFormatsZDC/ZDCEnergy.h include/DataFormatsZDC/ZDCWaveform.h - include/DataFormatsZDC/OrbitRecData.h include/DataFormatsZDC/RawEventData.h - include/DataFormatsZDC/InterCalibData.h) + include/DataFormatsZDC/OrbitRecData.h include/DataFormatsZDC/RawEventData.h) diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/OrbitData.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/OrbitData.h index 9c35d400608fa..9d1efc5ed12c7 100644 --- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/OrbitData.h +++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/OrbitData.h @@ -9,15 +9,15 @@ // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. -#ifndef _ZDC_PEDESTAL_DATA_H_ -#define _ZDC_PEDESTAL_DATA_H_ +#ifndef _ZDC_ORBIT_DATA_H_ +#define _ZDC_ORBIT_DATA_H_ #include "CommonDataFormat/InteractionRecord.h" #include "ZDCBase/Constants.h" #include #include -/// \file Pedestal.h +/// \file OrbitData.h /// \brief Class to describe pedestal data accumulated over the orbit /// \author ruben.shahoyan@cern.ch diff --git a/DataFormats/Detectors/ZDC/src/DataFormatsZDCLinkDef.h b/DataFormats/Detectors/ZDC/src/DataFormatsZDCLinkDef.h index 20b73474060c2..6e272dbc8a118 100644 --- a/DataFormats/Detectors/ZDC/src/DataFormatsZDCLinkDef.h +++ b/DataFormats/Detectors/ZDC/src/DataFormatsZDCLinkDef.h @@ -33,7 +33,6 @@ #pragma link C++ class o2::zdc::ZDCEnergy + ; #pragma link C++ class o2::zdc::ZDCTDCData + ; #pragma link C++ class o2::zdc::ZDCWaveform + ; -#pragma link C++ class o2::zdc::InterCalibData + ; #pragma link C++ class std::vector < o2::zdc::ChannelData> + ; #pragma link C++ class std::vector < o2::zdc::BCData> + ; #pragma link C++ class std::vector < o2::zdc::OrbitData> + ; diff --git a/Detectors/ZDC/calib/CMakeLists.txt b/Detectors/ZDC/calib/CMakeLists.txt index 9f2ca786bcce4..e9655c625f68f 100644 --- a/Detectors/ZDC/calib/CMakeLists.txt +++ b/Detectors/ZDC/calib/CMakeLists.txt @@ -11,6 +11,7 @@ o2_add_library(ZDCCalib SOURCES + src/InterCalibData.cxx src/InterCalib.cxx src/InterCalibConfig.cxx src/InterCalibSpec.cxx @@ -42,6 +43,7 @@ o2_add_library(ZDCCalib o2_target_root_dictionary(ZDCCalib HEADERS + include/ZDCCalib/InterCalibData.h include/ZDCCalib/InterCalib.h include/ZDCCalib/InterCalibConfig.h include/ZDCCalib/InterCalibSpec.h diff --git a/Detectors/ZDC/calib/include/ZDCCalib/InterCalib.h b/Detectors/ZDC/calib/include/ZDCCalib/InterCalib.h index 54e51dbb30974..dc90cb6ff2acb 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/InterCalib.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/InterCalib.h @@ -20,9 +20,9 @@ #include "CommonDataFormat/FlatHisto1D.h" #include "CommonDataFormat/FlatHisto2D.h" #include "DataFormatsZDC/RecEvent.h" -#include "DataFormatsZDC/InterCalibData.h" #include "ZDCReconstruction/ZDCEnergyParam.h" #include "ZDCReconstruction/ZDCTowerParam.h" +#include "ZDCCalib/InterCalibData.h" #include "ZDCCalib/InterCalibConfig.h" #include "CCDB/CcdbObjectInfo.h" #ifndef ALICEO2_ZDC_INTERCALIB_H diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/InterCalibData.h b/Detectors/ZDC/calib/include/ZDCCalib/InterCalibData.h similarity index 100% rename from DataFormats/Detectors/ZDC/include/DataFormatsZDC/InterCalibData.h rename to Detectors/ZDC/calib/include/ZDCCalib/InterCalibData.h diff --git a/Detectors/ZDC/calib/include/ZDCCalib/InterCalibEPN.h b/Detectors/ZDC/calib/include/ZDCCalib/InterCalibEPN.h index 9f6e63b11923d..38e68d86ab504 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/InterCalibEPN.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/InterCalibEPN.h @@ -20,9 +20,9 @@ #include "CommonDataFormat/FlatHisto1D.h" #include "CommonDataFormat/FlatHisto2D.h" #include "DataFormatsZDC/RecEvent.h" -#include "DataFormatsZDC/InterCalibData.h" #include "ZDCReconstruction/ZDCEnergyParam.h" #include "ZDCReconstruction/ZDCTowerParam.h" +#include "ZDCCalib/InterCalibData.h" #include "ZDCCalib/InterCalibConfig.h" #ifndef ALICEO2_ZDC_INTERCALIBEPN_H_ #define ALICEO2_ZDC_INTERCALIBEPN_H_ diff --git a/Detectors/ZDC/calib/include/ZDCCalib/InterCalibEPNSpec.h b/Detectors/ZDC/calib/include/ZDCCalib/InterCalibEPNSpec.h index 68a35aa48e666..264d5cdfe3fdb 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/InterCalibEPNSpec.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/InterCalibEPNSpec.h @@ -21,7 +21,7 @@ #include "Framework/DataProcessorSpec.h" #include "Framework/Task.h" #include "CommonUtils/NameConf.h" -#include "DataFormatsZDC/InterCalibData.h" +#include "ZDCCalib/InterCalibData.h" #include "ZDCCalib/InterCalibEPN.h" #include "ZDCCalib/InterCalibConfig.h" diff --git a/Detectors/ZDC/calib/include/ZDCCalib/InterCalibSpec.h b/Detectors/ZDC/calib/include/ZDCCalib/InterCalibSpec.h index 5a26d24a8bcf1..14e4186803c61 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/InterCalibSpec.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/InterCalibSpec.h @@ -23,8 +23,8 @@ #include "Framework/Task.h" #include "CommonDataFormat/FlatHisto1D.h" #include "CommonDataFormat/FlatHisto2D.h" -#include "DataFormatsZDC/InterCalibData.h" #include "CommonUtils/NameConf.h" +#include "ZDCCalib/InterCalibData.h" #include "ZDCCalib/InterCalib.h" #include "ZDCCalib/InterCalibConfig.h" #include "DetectorsCalibration/Utils.h" diff --git a/Detectors/ZDC/calib/src/InterCalib.cxx b/Detectors/ZDC/calib/src/InterCalib.cxx index f8eafb0250dc3..c93713f2ab4e3 100644 --- a/Detectors/ZDC/calib/src/InterCalib.cxx +++ b/Detectors/ZDC/calib/src/InterCalib.cxx @@ -18,10 +18,10 @@ #include #include #include "CommonUtils/MemFileHelper.h" +#include "ZDCCalib/InterCalibData.h" #include "ZDCCalib/InterCalib.h" #include "ZDCReconstruction/ZDCEnergyParam.h" #include "ZDCReconstruction/ZDCTowerParam.h" -#include "DataFormatsZDC/InterCalibData.h" #include "Framework/Logger.h" #include "CCDB/CcdbApi.h" diff --git a/DataFormats/Detectors/ZDC/src/InterCalibData.cxx b/Detectors/ZDC/calib/src/InterCalibData.cxx similarity index 97% rename from DataFormats/Detectors/ZDC/src/InterCalibData.cxx rename to Detectors/ZDC/calib/src/InterCalibData.cxx index 9504c64b93239..bf56dcad23bd7 100644 --- a/DataFormats/Detectors/ZDC/src/InterCalibData.cxx +++ b/Detectors/ZDC/calib/src/InterCalibData.cxx @@ -10,7 +10,7 @@ // or submit itself to any jurisdiction. #include "Framework/Logger.h" -#include "DataFormatsZDC/InterCalibData.h" +#include "ZDCCalib/InterCalibData.h" using namespace o2::zdc; diff --git a/Detectors/ZDC/calib/src/InterCalibEPN.cxx b/Detectors/ZDC/calib/src/InterCalibEPN.cxx index b6436c1bf964f..2e5d3fd39631f 100644 --- a/Detectors/ZDC/calib/src/InterCalibEPN.cxx +++ b/Detectors/ZDC/calib/src/InterCalibEPN.cxx @@ -17,11 +17,11 @@ #include #include #include +#include "ZDCCalib/InterCalibData.h" #include "ZDCCalib/InterCalibEPN.h" #include "ZDCCalib/InterCalib.h" #include "ZDCReconstruction/ZDCEnergyParam.h" #include "ZDCReconstruction/ZDCTowerParam.h" -#include "DataFormatsZDC/InterCalibData.h" #include "Framework/Logger.h" using namespace o2::zdc; diff --git a/Detectors/ZDC/calib/src/ZDCCalibLinkDef.h b/Detectors/ZDC/calib/src/ZDCCalibLinkDef.h index 0b701c2816f7b..94929ac9591aa 100644 --- a/Detectors/ZDC/calib/src/ZDCCalibLinkDef.h +++ b/Detectors/ZDC/calib/src/ZDCCalibLinkDef.h @@ -17,6 +17,7 @@ #pragma link C++ class o2::zdc::CalibParamZDC + ; #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::zdc::CalibParamZDC> + ; +#pragma link C++ class o2::zdc::InterCalibData + ; #pragma link C++ class o2::zdc::InterCalibConfig + ; #pragma link C++ class o2::zdc::WaveformCalibConfig + ; #pragma link C++ class o2::zdc::WaveformCalibChData + ; From 3382acb6a9381a44bd2923ac6d18e612b625f0e9 Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Tue, 24 May 2022 15:09:07 +0200 Subject: [PATCH 29/40] Simplified class to store WaveformCalib output --- Detectors/ZDC/calib/CMakeLists.txt | 2 ++ Detectors/ZDC/calib/include/ZDCCalib/WaveformCalib.h | 2 +- Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h | 2 +- Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h | 2 +- Detectors/ZDC/calib/src/WaveformCalib.cxx | 6 +++--- Detectors/ZDC/calib/src/WaveformCalibData.cxx | 2 +- Detectors/ZDC/calib/src/WaveformCalibEPN.cxx | 6 +++--- Detectors/ZDC/calib/src/WaveformCalibSpec.cxx | 7 +++++-- Detectors/ZDC/calib/src/ZDCCalibLinkDef.h | 2 ++ Detectors/ZDC/macro/CMakeLists.txt | 6 ++++++ 10 files changed, 25 insertions(+), 12 deletions(-) diff --git a/Detectors/ZDC/calib/CMakeLists.txt b/Detectors/ZDC/calib/CMakeLists.txt index e9655c625f68f..ceb66931164fc 100644 --- a/Detectors/ZDC/calib/CMakeLists.txt +++ b/Detectors/ZDC/calib/CMakeLists.txt @@ -24,6 +24,7 @@ o2_add_library(ZDCCalib src/WaveformCalibEPNSpec.cxx src/WaveformCalibQueue.cxx src/WaveformCalibData.cxx + src/WaveformCalibParam.cxx src/CalibParamZDC.cxx PUBLIC_LINK_LIBRARIES O2::CCDB @@ -56,6 +57,7 @@ o2_target_root_dictionary(ZDCCalib include/ZDCCalib/WaveformCalibEPNSpec.h include/ZDCCalib/WaveformCalibQueue.h include/ZDCCalib/WaveformCalibData.h + include/ZDCCalib/WaveformCalibParam.h include/ZDCCalib/CalibParamZDC.h) o2_add_executable(intercalib-workflow diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalib.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalib.h index f1cc45b5f15e2..b7f749c4b7bf7 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalib.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalib.h @@ -36,7 +36,7 @@ class WaveformCalib void clear(); int process(const WaveformCalibData& data); // Calibration of RUN3 data - aggregator node int endOfRun(); // Perform minimization - int write(const std::string fn = "ZDCWaveformCalib.root"); + int saveDebugHistos(const std::string fn = "ZDCWaveformCalib.root"); CcdbObjectInfo& getCcdbObjectInfo() { return mInfo; } diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h index 81587d9892877..8735551aa8a18 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h @@ -79,7 +79,7 @@ struct WaveformCalibData { void clear(); void setCreationTime(uint64_t ctime); void setN(int n); - int write(const std::string fn); + int saveDebugHistos(const std::string fn); ClassDefNV(WaveformCalibData, 1); }; diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h index 85e54cff8f83e..b759d94ff781a 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibEPN.h @@ -36,7 +36,7 @@ class WaveformCalibEPN const gsl::span& info, const gsl::span& wave); int endOfRun(); - int write(const std::string fn = "ZDCWaveformCalibEPN.root"); + int saveDebugHistos(const std::string fn = "ZDCWaveformCalibEPN.root"); void setConfig(const WaveformCalibConfig* param) { mConfig = param; }; const WaveformCalibConfig* getConfig() const { return mConfig; }; void setSaveDebugHistos() { mSaveDebugHistos = true; } diff --git a/Detectors/ZDC/calib/src/WaveformCalib.cxx b/Detectors/ZDC/calib/src/WaveformCalib.cxx index 5e3729161e302..23464aae2ee2c 100644 --- a/Detectors/ZDC/calib/src/WaveformCalib.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalib.cxx @@ -96,13 +96,13 @@ int WaveformCalib::endOfRun() mInfo.setEndValidityTimestamp(stopping); if (mSaveDebugHistos) { - write(); + saveDebugHistos(); } return 0; } //______________________________________________________________________________ -int WaveformCalib::write(const std::string fn) +int WaveformCalib::saveDebugHistos(const std::string fn) { - return mData.write(fn); + return mData.saveDebugHistos(fn); } diff --git a/Detectors/ZDC/calib/src/WaveformCalibData.cxx b/Detectors/ZDC/calib/src/WaveformCalibData.cxx index 16cab85324dec..734f4c6729101 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibData.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibData.cxx @@ -151,7 +151,7 @@ void WaveformCalibChData::setN(int n) } //______________________________________________________________________________ -int WaveformCalibData::write(const std::string fn) +int WaveformCalibData::saveDebugHistos(const std::string fn) { TDirectory* cwd = gDirectory; TFile* f = new TFile(fn.data(), "recreate"); diff --git a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx index 1cf58cebe1f0a..3179670579bfb 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibEPN.cxx @@ -119,13 +119,13 @@ int WaveformCalibEPN::endOfRun() } } if (mSaveDebugHistos) { - write(); + saveDebugHistos(); } return 0; } //______________________________________________________________________________ -int WaveformCalibEPN::write(const std::string fn) +int WaveformCalibEPN::saveDebugHistos(const std::string fn) { - return mData.write(fn); + return mData.saveDebugHistos(fn); } diff --git a/Detectors/ZDC/calib/src/WaveformCalibSpec.cxx b/Detectors/ZDC/calib/src/WaveformCalibSpec.cxx index 7da1619dd1541..92e5e09063092 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibSpec.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibSpec.cxx @@ -34,6 +34,7 @@ #include "CommonUtils/MemFileHelper.h" #include "CCDB/BasicCCDBManager.h" #include "CCDB/CCDBTimeStampUtils.h" +#include "ZDCCalib/WaveformCalibParam.h" #include "ZDCCalib/WaveformCalibData.h" #include "ZDCCalib/WaveformCalibSpec.h" @@ -114,9 +115,11 @@ void WaveformCalibSpec::sendOutput(o2::framework::DataAllocator& output) // 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& payload = mWorker.getData(); + const auto& data = mWorker.getData(); + WaveformCalibParam payload; + payload.assign(data); auto& info = mWorker.getCcdbObjectInfo(); - auto image = o2::ccdb::CcdbApi::createObjectImage(&payload, &info); + auto image = o2::ccdb::CcdbApi::createObjectImage(&payload, &info); LOG(info) << "Sending object " << info.getPath() << "/" << info.getFileName() << " of size " << image->size() << " bytes, valid for " << info.getStartValidityTimestamp() << " : " << info.getEndValidityTimestamp(); if (mVerbosity > DbgZero) { diff --git a/Detectors/ZDC/calib/src/ZDCCalibLinkDef.h b/Detectors/ZDC/calib/src/ZDCCalibLinkDef.h index 94929ac9591aa..aaa5c0cba21c5 100644 --- a/Detectors/ZDC/calib/src/ZDCCalibLinkDef.h +++ b/Detectors/ZDC/calib/src/ZDCCalibLinkDef.h @@ -22,5 +22,7 @@ #pragma link C++ class o2::zdc::WaveformCalibConfig + ; #pragma link C++ class o2::zdc::WaveformCalibChData + ; #pragma link C++ class o2::zdc::WaveformCalibData + ; +#pragma link C++ class o2::zdc::WaveformCalibChParam + ; +#pragma link C++ class o2::zdc::WaveformCalibParam + ; #endif diff --git a/Detectors/ZDC/macro/CMakeLists.txt b/Detectors/ZDC/macro/CMakeLists.txt index 7f2338d624e7b..cb61687c2705f 100644 --- a/Detectors/ZDC/macro/CMakeLists.txt +++ b/Detectors/ZDC/macro/CMakeLists.txt @@ -64,3 +64,9 @@ o2_add_test_root_macro(CreateWaveformCalibConfig.C O2::SimulationDataFormat O2::CCDB O2::ZDCCalib LABELS zdc) + +o2_add_test_root_macro(CreateWaveformCalibParam.C + PUBLIC_LINK_LIBRARIES O2::ZDCBase O2::ZDCReconstruction + O2::SimulationDataFormat O2::CCDB + O2::ZDCCalib + LABELS zdc) From 46489327d8a8e02ff6c75ed3d528a3d09ac2bf84 Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Tue, 24 May 2022 15:10:31 +0200 Subject: [PATCH 30/40] Simplified class to store WaveformCalib output --- .../include/ZDCCalib/WaveformCalibParam.h | 51 ++++++++++ .../ZDC/calib/src/WaveformCalibParam.cxx | 47 ++++++++++ .../ZDC/macro/CreateWaveformCalibParam.C | 92 +++++++++++++++++++ 3 files changed, 190 insertions(+) create mode 100644 Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibParam.h create mode 100644 Detectors/ZDC/calib/src/WaveformCalibParam.cxx create mode 100644 Detectors/ZDC/macro/CreateWaveformCalibParam.C diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibParam.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibParam.h new file mode 100644 index 0000000000000..1a99047d562b4 --- /dev/null +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibParam.h @@ -0,0 +1,51 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#ifndef ZDC_WAVEFORMCALIB_PARAM_H +#define ZDC_WAVEFORMCALIB_PARAM_H + +#include "GPUCommonRtypes.h" +#include "ZDCBase/Constants.h" +#include "ZDCCalib/WaveformCalibData.h" +#include +#include + +/// \file WaveformCalibParam.h +/// \brief Waveform calibration data +/// \author pietro.cortese@cern.ch + +namespace o2 +{ +namespace zdc +{ + +struct WaveformCalibChParam { + std::vector shape; + int ampMinID = 0; + void print() const; + ClassDefNV(WaveformCalibChParam, 1); +}; + +struct WaveformCalibParam { + + std::array channels; // configuration per channel + + void assign(const WaveformCalibData &data); + + void print() const; + + ClassDefNV(WaveformCalibParam, 1); +}; + +} // namespace zdc +} // namespace o2 + +#endif diff --git a/Detectors/ZDC/calib/src/WaveformCalibParam.cxx b/Detectors/ZDC/calib/src/WaveformCalibParam.cxx new file mode 100644 index 0000000000000..eaeb05fa8e968 --- /dev/null +++ b/Detectors/ZDC/calib/src/WaveformCalibParam.cxx @@ -0,0 +1,47 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#include "ZDCCalib/WaveformCalibParam.h" + +using namespace o2::zdc; + +void WaveformCalibParam::assign(const WaveformCalibData& data) +{ + for (int isig = 0; isig < NChannels; isig++) { + float entries = data.getEntries(isig); + int peak = data.mPeak; + if (entries > 0) { + int ifirst = data.getFirstValid(isig); + int ilast = data.getLastValid(isig); + channels[isig].ampMinID = peak - ifirst; + for (int ip = ifirst; ip <= ilast; ip++) { + channels[isig].shape.push_back(data.mWave[isig].mData[ip] / entries); + } + } + } +} + +void WaveformCalibChParam::print() const +{ + if (shape.size() > 0) { + printf("Shape min at bin %d/%d\n", ampMinID, shape.size()); + } else { + printf("No data\n", ampMinID, shape.size()); + } +} + +void WaveformCalibParam::print() const +{ + for (int i = 0; i < NChannels; i++) { + printf("%s ", channelName(i)); + channels[i].print(); + } +} diff --git a/Detectors/ZDC/macro/CreateWaveformCalibParam.C b/Detectors/ZDC/macro/CreateWaveformCalibParam.C new file mode 100644 index 0000000000000..33660dbd0b467 --- /dev/null +++ b/Detectors/ZDC/macro/CreateWaveformCalibParam.C @@ -0,0 +1,92 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#if !defined(__CLING__) || defined(__ROOTCLING__) + +#include "Framework/Logger.h" +#include "CCDB/CcdbApi.h" +#include +#include +#include +#include + +#endif + +#include "ZDCBase/Constants.h" +#include "ZDCCalib/WaveformCalibParam.h" + +using namespace o2::zdc; +using namespace std; + +void CreateWaveformCalibParam(long tmin = 0, long tmax = -1, std::string ccdbHost = "", std::string sourceDataPath = "signal_shapes.root") +{ + + TFile sourceData(sourceDataPath.c_str()); + if (!sourceData.IsOpen() || sourceData.IsZombie()) { + LOG(fatal) << "Failed to open input file " << sourceDataPath; + } + + // Source of line shapes, pedestal and noise for each channel + // Missing histos for: towers 1-4 of all calorimeters, zem1, all towers of zpc + std::string ShapeName[o2::zdc::NChannels] = { + "znatc", "znatc", "znatc", "znatc", "znatc", "znatc", // ZNAC, ZNA1, ZNA2, ZNA3, ZNA4, ZNAS (shape not used) + "zpatc", "zpatc", "zpatc", "zpatc", "zpatc", "zpatc", // ZPAC, ZPA1, ZPA2, ZPA3, ZPA4, ZPAS (shape not used) + "zem2", "zem2", // ZEM1, ZEM2 + "znctc", "znctc", "znctc", "znctc", "znctc", "znctc", // ZNCC, ZNC1, ZNC2, ZNC3, ZNC4, ZNCS (shape not used) + "zpatc", "zpatc", "zpatc", "zpatc", "zpatc", "zpatc" // ZPCC, ZPC1, ZPC2, ZPC3, ZPC4, ZPCS (shape not used) + }; + + o2::zdc::WaveformCalibParam conf; + + for (int ic = 0; ic < o2::zdc::NChannels; ic++) { + auto& channel = conf.channels[ic]; + std::string histoShapeName = "hw_" + ShapeName[ic]; + TH1* histoShape = (TH1*)sourceData.GetObjectUnchecked(histoShapeName.c_str()); + if (!histoShape) { + LOG(fatal) << "Failed to extract the shape histogram " << histoShapeName; + } + int nb = histoShape->GetNbinsX(); + channel.shape.resize(nb); + // we need min amplitude and its bin + double ampMin = histoShape->GetBinContent(1); + channel.ampMinID = 0; + for (int i = 0; i < nb; i++) { + channel.shape[i] = histoShape->GetBinContent(i + 1); + if (channel.shape[i] < ampMin) { + ampMin = channel.shape[i]; + channel.ampMinID = i; + } + } + if (ampMin == 0.) { + LOG(fatal) << "Amplitude minimum =0 for histo " << histoShapeName; + } + } + + conf.print(); + + o2::ccdb::CcdbApi api; + map metadata; // can be empty + if (ccdbHost.size() == 0 || ccdbHost == "external") { + ccdbHost = "http://alice-ccdb.cern.ch:8080"; + } else if (ccdbHost == "internal") { + ccdbHost = "http://o2-ccdb.internal/"; + } else if (ccdbHost == "test") { + ccdbHost = "http://ccdb-test.cern.ch:8080"; + } else if (ccdbHost == "local") { + ccdbHost = "http://localhost:8080"; + } + api.init(ccdbHost.c_str()); + LOG(info) << "CCDB server: " << api.getURL(); + // store abitrary user object in strongly typed manner + api.storeAsTFileAny(&conf, CCDBPathWaveformCalib, metadata, tmin, tmax); + + // return conf; +} From aada04cc5eb1f6f13751d80c042c4b77f267bf3b Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Tue, 24 May 2022 15:14:35 +0200 Subject: [PATCH 31/40] Simplified class to store WaveformCalib output --- Detectors/ZDC/macro/CMakeLists.txt | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/Detectors/ZDC/macro/CMakeLists.txt b/Detectors/ZDC/macro/CMakeLists.txt index cb61687c2705f..928d115b233fd 100644 --- a/Detectors/ZDC/macro/CMakeLists.txt +++ b/Detectors/ZDC/macro/CMakeLists.txt @@ -70,3 +70,9 @@ o2_add_test_root_macro(CreateWaveformCalibParam.C O2::SimulationDataFormat O2::CCDB O2::ZDCCalib LABELS zdc) + +o2_add_test_root_macro(InspectCCDBFile.C + PUBLIC_LINK_LIBRARIES O2::ZDCBase O2::ZDCReconstruction + O2::SimulationDataFormat O2::CCDB + O2::ZDCCalib + LABELS zdc) From fa06c3bae39b8ecf7132dabca5edee195c03417d Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Tue, 24 May 2022 15:14:43 +0200 Subject: [PATCH 32/40] Simplified class to store WaveformCalib output --- Detectors/ZDC/macro/InspectCCDBFile.C | 88 +++++++++++++++++++++++++++ 1 file changed, 88 insertions(+) create mode 100644 Detectors/ZDC/macro/InspectCCDBFile.C diff --git a/Detectors/ZDC/macro/InspectCCDBFile.C b/Detectors/ZDC/macro/InspectCCDBFile.C new file mode 100644 index 0000000000000..fbbf6c28882bd --- /dev/null +++ b/Detectors/ZDC/macro/InspectCCDBFile.C @@ -0,0 +1,88 @@ +#include "TObject.h" +#include "TString.h" +#include "TSystem.h" +#include "TKey.h" +#include "TDirectory.h" +#include "ZDCBase/ModuleConfig.h" +#include "ZDCBase/Constants.h" +#include "ZDCSimulation/SimCondition.h" +#include "ZDCReconstruction/RecoConfigZDC.h" +#include "ZDCReconstruction/ZDCTDCCorr.h" +#include "ZDCReconstruction/ZDCTDCParam.h" +#include "ZDCReconstruction/ZDCEnergyParam.h" +#include "ZDCReconstruction/ZDCTowerParam.h" +#include "ZDCCalib/InterCalibConfig.h" +#include "ZDCCalib/WaveformCalibConfig.h" +#include "ZDCCalib/WaveformCalibParam.h" + +void InspectCCDBFile(){ + TString dn=gDirectory->GetName(); + auto p_und = dn.First('_'); + auto p_dot = dn.Last('.'); + if(p_und >= 0 && p_dot > 0 && p_dot > p_und){ + TSubString dat = dn(p_und+1,p_dot-p_und-1); + TString data = dat; + if(data.IsDec()){ + auto val = data.Atoll(); + val = val/1000; + gSystem->Exec(TString::Format("date -d \"@%lld\"",val)); + } + } + TIter nextkey( gDirectory->GetListOfKeys() ); + TKey *key; + while ( (key = (TKey*)nextkey())) { + TString cn = key->GetClassName(); + if(cn.EqualTo("o2::zdc::ModuleConfig")){ + o2::zdc::ModuleConfig *ob=(o2::zdc::ModuleConfig *)key->ReadObj(); + printf("%s %s %d %s @ %s\n","OBJ",key->GetName(),key->GetCycle(),key->GetTitle(),o2::zdc::CCDBPathConfigModule.data()); + ob->print(); + }else if(cn.EqualTo("o2::zdc::SimCondition")){ + o2::zdc::SimCondition *ob=(o2::zdc::SimCondition *)key->ReadObj(); + printf("%s %s %d %s @ %s\n","OBJ",key->GetName(),key->GetCycle(),key->GetTitle(),o2::zdc::CCDBPathConfigSim.data()); + ob->print(); + }else if(cn.EqualTo("o2::zdc::RecoConfigZDC")){ + o2::zdc::RecoConfigZDC *ob=(o2::zdc::RecoConfigZDC *)key->ReadObj(); + printf("%s %s %d %s @ %s\n","OBJ",key->GetName(),key->GetCycle(),key->GetTitle(),o2::zdc::CCDBPathRecoConfigZDC.data()); + ob->print(); + }else if(cn.EqualTo("o2::zdc::ZDCTDCCorr")){ + o2::zdc::ZDCTDCCorr *ob=(o2::zdc::ZDCTDCCorr *)key->ReadObj(); + printf("%s %s %d %s @ %s\n","OBJ",key->GetName(),key->GetCycle(),key->GetTitle(),o2::zdc::CCDBPathTDCCorr.data()); + ob->print(); + }else if(cn.EqualTo("o2::zdc::ZDCTDCParam")){ + o2::zdc::ZDCTDCParam *ob=(o2::zdc::ZDCTDCParam *)key->ReadObj(); + printf("%s %s %d %s @ %s\n","OBJ",key->GetName(),key->GetCycle(),key->GetTitle(),o2::zdc::CCDBPathTDCCalib.data()); + ob->print(); + }else if(cn.EqualTo("o2::zdc::ZDCEnergyParam")){ + o2::zdc::ZDCEnergyParam *ob=(o2::zdc::ZDCEnergyParam *)key->ReadObj(); + printf("%s %s %d %s @ %s\n","OBJ",key->GetName(),key->GetCycle(),key->GetTitle(),o2::zdc::CCDBPathEnergyCalib.data()); + ob->print(); + }else if(cn.EqualTo("o2::zdc::ZDCTowerParam")){ + o2::zdc::ZDCTowerParam *ob=(o2::zdc::ZDCTowerParam *)key->ReadObj(); + printf("%s %s %d %s @ %s\n","OBJ",key->GetName(),key->GetCycle(),key->GetTitle(),o2::zdc::CCDBPathTowerCalib.data()); + ob->print(); + }else if(cn.EqualTo("o2::zdc::InterCalibConfig")){ + o2::zdc::InterCalibConfig *ob=(o2::zdc::InterCalibConfig *)key->ReadObj(); + printf("%s %s %d %s @ %s\n","OBJ",key->GetName(),key->GetCycle(),key->GetTitle(),o2::zdc::CCDBPathInterCalibConfig.data()); + ob->print(); + }else if(cn.EqualTo("o2::zdc::WaveformCalibConfig")){ + o2::zdc::WaveformCalibConfig *ob=(o2::zdc::WaveformCalibConfig *)key->ReadObj(); + printf("%s %s %d %s @ %s\n","OBJ",key->GetName(),key->GetCycle(),key->GetTitle(),o2::zdc::CCDBPathWaveformCalibConfig.data()); + ob->print(); + }else if(cn.EqualTo("o2::zdc::WaveformCalibParam")){ + o2::zdc::WaveformCalibParam *ob=(o2::zdc::WaveformCalibParam *)key->ReadObj(); + printf("%s %s %d %s @ %s\n","OBJ",key->GetName(),key->GetCycle(),key->GetTitle(),o2::zdc::CCDBPathWaveformCalib.data()); + ob->print(); + //ob->saveDebugHistos("InspectCCDBFile_WaveformCalibParam.root"); + }else{ + printf("%s %s %d %s\n",key->GetClassName(),key->GetName(),key->GetCycle(),key->GetTitle()); + } + } + +// TObject *ob = (TObject*)gDirectory->Get("ccdb_object"); +// if(ob == nullptr){ +// printf("Object not found\n"); +// return; +// } +// printf("%s %d\n", ob->Class_Name(), ob->Class_Version()); + +} From 9e14bb0937d2cd3016295725d38e7f5dd4b703a1 Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Tue, 24 May 2022 15:20:59 +0200 Subject: [PATCH 33/40] Fix whitespace --- Detectors/ZDC/macro/InspectCCDBFile.C | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Detectors/ZDC/macro/InspectCCDBFile.C b/Detectors/ZDC/macro/InspectCCDBFile.C index fbbf6c28882bd..6b16148030e6b 100644 --- a/Detectors/ZDC/macro/InspectCCDBFile.C +++ b/Detectors/ZDC/macro/InspectCCDBFile.C @@ -77,7 +77,7 @@ void InspectCCDBFile(){ printf("%s %s %d %s\n",key->GetClassName(),key->GetName(),key->GetCycle(),key->GetTitle()); } } - + // TObject *ob = (TObject*)gDirectory->Get("ccdb_object"); // if(ob == nullptr){ // printf("Object not found\n"); From 8af8bdbde7e95020def72ecd887fbb13dcf5a289 Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Tue, 24 May 2022 16:04:43 +0200 Subject: [PATCH 34/40] Saving histograms from calibration object --- .../include/ZDCCalib/WaveformCalibParam.h | 8 +- .../ZDC/calib/src/WaveformCalibParam.cxx | 58 ++++++++-- Detectors/ZDC/macro/InspectCCDBFile.C | 103 +++++++++--------- 3 files changed, 103 insertions(+), 66 deletions(-) diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibParam.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibParam.h index 1a99047d562b4..12e019b696271 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibParam.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibParam.h @@ -12,11 +12,10 @@ #ifndef ZDC_WAVEFORMCALIB_PARAM_H #define ZDC_WAVEFORMCALIB_PARAM_H -#include "GPUCommonRtypes.h" #include "ZDCBase/Constants.h" +#include #include "ZDCCalib/WaveformCalibData.h" #include -#include /// \file WaveformCalibParam.h /// \brief Waveform calibration data @@ -28,7 +27,8 @@ namespace zdc { struct WaveformCalibChParam { - std::vector shape; + using Histo = std::vector; + Histo shape; int ampMinID = 0; void print() const; ClassDefNV(WaveformCalibChParam, 1); @@ -39,7 +39,7 @@ struct WaveformCalibParam { std::array channels; // configuration per channel void assign(const WaveformCalibData &data); - + int saveDebugHistos(const std::string fn) const; void print() const; ClassDefNV(WaveformCalibParam, 1); diff --git a/Detectors/ZDC/calib/src/WaveformCalibParam.cxx b/Detectors/ZDC/calib/src/WaveformCalibParam.cxx index eaeb05fa8e968..37e411a235e8c 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibParam.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibParam.cxx @@ -9,10 +9,31 @@ // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. +#include +#include +#include +#include "Framework/Logger.h" #include "ZDCCalib/WaveformCalibParam.h" using namespace o2::zdc; +void WaveformCalibChParam::print() const +{ + if (shape.size() > 0) { + printf("Shape min at bin %d/%d\n", ampMinID, shape.size()); + } else { + printf("No data\n", ampMinID, shape.size()); + } +} + +void WaveformCalibParam::print() const +{ + for (int i = 0; i < NChannels; i++) { + printf("%s ", channelName(i)); + channels[i].print(); + } +} + void WaveformCalibParam::assign(const WaveformCalibData& data) { for (int isig = 0; isig < NChannels; isig++) { @@ -29,19 +50,32 @@ void WaveformCalibParam::assign(const WaveformCalibData& data) } } -void WaveformCalibChParam::print() const +//______________________________________________________________________________ +int WaveformCalibParam::saveDebugHistos(const std::string fn) const { - if (shape.size() > 0) { - printf("Shape min at bin %d/%d\n", ampMinID, shape.size()); - } else { - printf("No data\n", ampMinID, shape.size()); + TDirectory* cwd = gDirectory; + TFile* f = new TFile(fn.data(), "recreate"); + if (f->IsZombie()) { + LOG(error) << "Cannot create file: " << fn; + return 1; } -} - -void WaveformCalibParam::print() const -{ - for (int i = 0; i < NChannels; i++) { - printf("%s ", channelName(i)); - channels[i].print(); + for (int32_t is = 0; is < NChannels; is++) { + auto& channel = channels[is]; + auto& shape = channel.shape; + int nbx = shape.size(); + int iamin = channel.ampMinID; + if (nbx > 0) { + TString n = TString::Format("h%d", is); + TString t = TString::Format("Waveform %d %s", is, ChannelNames[is].data()); + TH1F h(n, t, nbx, -0.5 - iamin, nbx - iamin - 0.5); + for (int ibx = 0; ibx < nbx; ibx++) { + h.SetBinContent(ibx + 1, shape[ibx]); + } + h.SetEntries(1); + h.Write("", TObject::kOverwrite); + } } + f->Close(); + cwd->cd(); + return 0; } diff --git a/Detectors/ZDC/macro/InspectCCDBFile.C b/Detectors/ZDC/macro/InspectCCDBFile.C index 6b16148030e6b..d8abd88bb7362 100644 --- a/Detectors/ZDC/macro/InspectCCDBFile.C +++ b/Detectors/ZDC/macro/InspectCCDBFile.C @@ -2,6 +2,7 @@ #include "TString.h" #include "TSystem.h" #include "TKey.h" +#include "TFile.h" #include "TDirectory.h" #include "ZDCBase/ModuleConfig.h" #include "ZDCBase/Constants.h" @@ -15,74 +16,76 @@ #include "ZDCCalib/WaveformCalibConfig.h" #include "ZDCCalib/WaveformCalibParam.h" -void InspectCCDBFile(){ - TString dn=gDirectory->GetName(); +void InspectCCDBFile() +{ + TString dn = gDirectory->GetName(); auto p_und = dn.First('_'); auto p_dot = dn.Last('.'); - if(p_und >= 0 && p_dot > 0 && p_dot > p_und){ - TSubString dat = dn(p_und+1,p_dot-p_und-1); + if (p_und >= 0 && p_dot > 0 && p_dot > p_und) { + TSubString dat = dn(p_und + 1, p_dot - p_und - 1); TString data = dat; - if(data.IsDec()){ + if (data.IsDec()) { auto val = data.Atoll(); - val = val/1000; - gSystem->Exec(TString::Format("date -d \"@%lld\"",val)); + val = val / 1000; + gSystem->Exec(TString::Format("date -d \"@%lld\"", val)); } } - TIter nextkey( gDirectory->GetListOfKeys() ); - TKey *key; - while ( (key = (TKey*)nextkey())) { + TIter nextkey(gDirectory->GetListOfKeys()); + TKey* key; + while ((key = (TKey*)nextkey())) { TString cn = key->GetClassName(); - if(cn.EqualTo("o2::zdc::ModuleConfig")){ - o2::zdc::ModuleConfig *ob=(o2::zdc::ModuleConfig *)key->ReadObj(); - printf("%s %s %d %s @ %s\n","OBJ",key->GetName(),key->GetCycle(),key->GetTitle(),o2::zdc::CCDBPathConfigModule.data()); + if (cn.EqualTo("o2::zdc::ModuleConfig")) { + o2::zdc::ModuleConfig* ob = (o2::zdc::ModuleConfig*)key->ReadObj(); + printf("%s %s %d %s @ %s\n", "OBJ", key->GetName(), key->GetCycle(), key->GetTitle(), o2::zdc::CCDBPathConfigModule.data()); ob->print(); - }else if(cn.EqualTo("o2::zdc::SimCondition")){ - o2::zdc::SimCondition *ob=(o2::zdc::SimCondition *)key->ReadObj(); - printf("%s %s %d %s @ %s\n","OBJ",key->GetName(),key->GetCycle(),key->GetTitle(),o2::zdc::CCDBPathConfigSim.data()); + } else if (cn.EqualTo("o2::zdc::SimCondition")) { + // o2::zdc::SimCondition *ob=(o2::zdc::SimCondition *)key->ReadObj(); + o2::zdc::SimCondition* ob = (o2::zdc::SimCondition*)gFile->GetObjectUnchecked("ccdb_object"); + printf("%s %s %d %s @ %s\n", "OBJ", key->GetName(), key->GetCycle(), key->GetTitle(), o2::zdc::CCDBPathConfigSim.data()); ob->print(); - }else if(cn.EqualTo("o2::zdc::RecoConfigZDC")){ - o2::zdc::RecoConfigZDC *ob=(o2::zdc::RecoConfigZDC *)key->ReadObj(); - printf("%s %s %d %s @ %s\n","OBJ",key->GetName(),key->GetCycle(),key->GetTitle(),o2::zdc::CCDBPathRecoConfigZDC.data()); + } else if (cn.EqualTo("o2::zdc::RecoConfigZDC")) { + o2::zdc::RecoConfigZDC* ob = (o2::zdc::RecoConfigZDC*)key->ReadObj(); + printf("%s %s %d %s @ %s\n", "OBJ", key->GetName(), key->GetCycle(), key->GetTitle(), o2::zdc::CCDBPathRecoConfigZDC.data()); ob->print(); - }else if(cn.EqualTo("o2::zdc::ZDCTDCCorr")){ - o2::zdc::ZDCTDCCorr *ob=(o2::zdc::ZDCTDCCorr *)key->ReadObj(); - printf("%s %s %d %s @ %s\n","OBJ",key->GetName(),key->GetCycle(),key->GetTitle(),o2::zdc::CCDBPathTDCCorr.data()); + } else if (cn.EqualTo("o2::zdc::ZDCTDCCorr")) { + o2::zdc::ZDCTDCCorr* ob = (o2::zdc::ZDCTDCCorr*)key->ReadObj(); + printf("%s %s %d %s @ %s\n", "OBJ", key->GetName(), key->GetCycle(), key->GetTitle(), o2::zdc::CCDBPathTDCCorr.data()); ob->print(); - }else if(cn.EqualTo("o2::zdc::ZDCTDCParam")){ - o2::zdc::ZDCTDCParam *ob=(o2::zdc::ZDCTDCParam *)key->ReadObj(); - printf("%s %s %d %s @ %s\n","OBJ",key->GetName(),key->GetCycle(),key->GetTitle(),o2::zdc::CCDBPathTDCCalib.data()); + } else if (cn.EqualTo("o2::zdc::ZDCTDCParam")) { + o2::zdc::ZDCTDCParam* ob = (o2::zdc::ZDCTDCParam*)key->ReadObj(); + printf("%s %s %d %s @ %s\n", "OBJ", key->GetName(), key->GetCycle(), key->GetTitle(), o2::zdc::CCDBPathTDCCalib.data()); ob->print(); - }else if(cn.EqualTo("o2::zdc::ZDCEnergyParam")){ - o2::zdc::ZDCEnergyParam *ob=(o2::zdc::ZDCEnergyParam *)key->ReadObj(); - printf("%s %s %d %s @ %s\n","OBJ",key->GetName(),key->GetCycle(),key->GetTitle(),o2::zdc::CCDBPathEnergyCalib.data()); + } else if (cn.EqualTo("o2::zdc::ZDCEnergyParam")) { + o2::zdc::ZDCEnergyParam* ob = (o2::zdc::ZDCEnergyParam*)key->ReadObj(); + printf("%s %s %d %s @ %s\n", "OBJ", key->GetName(), key->GetCycle(), key->GetTitle(), o2::zdc::CCDBPathEnergyCalib.data()); ob->print(); - }else if(cn.EqualTo("o2::zdc::ZDCTowerParam")){ - o2::zdc::ZDCTowerParam *ob=(o2::zdc::ZDCTowerParam *)key->ReadObj(); - printf("%s %s %d %s @ %s\n","OBJ",key->GetName(),key->GetCycle(),key->GetTitle(),o2::zdc::CCDBPathTowerCalib.data()); + } else if (cn.EqualTo("o2::zdc::ZDCTowerParam")) { + o2::zdc::ZDCTowerParam* ob = (o2::zdc::ZDCTowerParam*)key->ReadObj(); + printf("%s %s %d %s @ %s\n", "OBJ", key->GetName(), key->GetCycle(), key->GetTitle(), o2::zdc::CCDBPathTowerCalib.data()); ob->print(); - }else if(cn.EqualTo("o2::zdc::InterCalibConfig")){ - o2::zdc::InterCalibConfig *ob=(o2::zdc::InterCalibConfig *)key->ReadObj(); - printf("%s %s %d %s @ %s\n","OBJ",key->GetName(),key->GetCycle(),key->GetTitle(),o2::zdc::CCDBPathInterCalibConfig.data()); + } else if (cn.EqualTo("o2::zdc::InterCalibConfig")) { + o2::zdc::InterCalibConfig* ob = (o2::zdc::InterCalibConfig*)key->ReadObj(); + printf("%s %s %d %s @ %s\n", "OBJ", key->GetName(), key->GetCycle(), key->GetTitle(), o2::zdc::CCDBPathInterCalibConfig.data()); ob->print(); - }else if(cn.EqualTo("o2::zdc::WaveformCalibConfig")){ - o2::zdc::WaveformCalibConfig *ob=(o2::zdc::WaveformCalibConfig *)key->ReadObj(); - printf("%s %s %d %s @ %s\n","OBJ",key->GetName(),key->GetCycle(),key->GetTitle(),o2::zdc::CCDBPathWaveformCalibConfig.data()); + } else if (cn.EqualTo("o2::zdc::WaveformCalibConfig")) { + o2::zdc::WaveformCalibConfig* ob = (o2::zdc::WaveformCalibConfig*)key->ReadObj(); + printf("%s %s %d %s @ %s\n", "OBJ", key->GetName(), key->GetCycle(), key->GetTitle(), o2::zdc::CCDBPathWaveformCalibConfig.data()); ob->print(); - }else if(cn.EqualTo("o2::zdc::WaveformCalibParam")){ - o2::zdc::WaveformCalibParam *ob=(o2::zdc::WaveformCalibParam *)key->ReadObj(); - printf("%s %s %d %s @ %s\n","OBJ",key->GetName(),key->GetCycle(),key->GetTitle(),o2::zdc::CCDBPathWaveformCalib.data()); + } else if (cn.EqualTo("o2::zdc::WaveformCalibParam")) { + o2::zdc::WaveformCalibParam* ob = (o2::zdc::WaveformCalibParam*)gFile->GetObjectUnchecked("ccdb_object"); + // o2::zdc::WaveformCalibParam *ob=(o2::zdc::WaveformCalibParam *)key->ReadObj(); + printf("%s %s %d %s @ %s\n", "OBJ", key->GetName(), key->GetCycle(), key->GetTitle(), o2::zdc::CCDBPathWaveformCalib.data()); ob->print(); - //ob->saveDebugHistos("InspectCCDBFile_WaveformCalibParam.root"); - }else{ - printf("%s %s %d %s\n",key->GetClassName(),key->GetName(),key->GetCycle(),key->GetTitle()); + ob->saveDebugHistos("InspectCCDBFile_WaveformCalibParam.root"); + } else { + printf("%s %s %d %s\n", key->GetClassName(), key->GetName(), key->GetCycle(), key->GetTitle()); } } -// TObject *ob = (TObject*)gDirectory->Get("ccdb_object"); -// if(ob == nullptr){ -// printf("Object not found\n"); -// return; -// } -// printf("%s %d\n", ob->Class_Name(), ob->Class_Version()); - + // TObject *ob = (TObject*)gDirectory->Get("ccdb_object"); + // if(ob == nullptr){ + // printf("Object not found\n"); + // return; + // } + // printf("%s %d\n", ob->Class_Name(), ob->Class_Version()); } From c83d184bd5f0798f17390fbb4b01239c3406ac3b Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Tue, 24 May 2022 18:38:36 +0200 Subject: [PATCH 35/40] clang-format --- Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibParam.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibParam.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibParam.h index 12e019b696271..f987b19880522 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibParam.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibParam.h @@ -38,7 +38,7 @@ struct WaveformCalibParam { std::array channels; // configuration per channel - void assign(const WaveformCalibData &data); + void assign(const WaveformCalibData& data); int saveDebugHistos(const std::string fn) const; void print() const; From 80c9ccfde6d9f4a833a875d0705f2e077b9f4325 Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Wed, 25 May 2022 16:01:21 +0200 Subject: [PATCH 36/40] Fixed crash --- Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibParam.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibParam.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibParam.h index f987b19880522..969e7b406a3d2 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibParam.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibParam.h @@ -15,7 +15,7 @@ #include "ZDCBase/Constants.h" #include #include "ZDCCalib/WaveformCalibData.h" -#include +#include /// \file WaveformCalibParam.h /// \brief Waveform calibration data @@ -36,7 +36,7 @@ struct WaveformCalibChParam { struct WaveformCalibParam { - std::array channels; // configuration per channel + WaveformCalibChParam channels[NChannels]; // configuration per channel void assign(const WaveformCalibData& data); int saveDebugHistos(const std::string fn) const; From e96371ff753af16feac7a56ee9fc45838ee5fa05 Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Wed, 25 May 2022 23:00:08 +0200 Subject: [PATCH 37/40] Fixing some compilation errors --- .../ZDC/base/include/ZDCBase/Constants.h | 7 +++++++ .../include/ZDCCalib/WaveformCalibConfig.h | 8 ++++---- .../include/ZDCCalib/WaveformCalibData.h | 20 +++++++++---------- Detectors/ZDC/calib/src/WaveformCalibData.cxx | 4 ++-- .../ZDC/macro/CreateWaveformCalibConfig.C | 2 +- .../ZDC/macro/CreateWaveformCalibParam.C | 4 ++-- .../ZDC/reconstruction/src/RecoParamZDC.cxx | 8 ++++---- 7 files changed, 30 insertions(+), 23 deletions(-) diff --git a/Detectors/ZDC/base/include/ZDCBase/Constants.h b/Detectors/ZDC/base/include/ZDCBase/Constants.h index fdd9c1bddf94b..804129a13a2ff 100644 --- a/Detectors/ZDC/base/include/ZDCBase/Constants.h +++ b/Detectors/ZDC/base/include/ZDCBase/Constants.h @@ -366,6 +366,13 @@ constexpr int toDet(int channel, int& tower) } } +// Calibration workflows +static constexpr int WaveformCalib_NBB = 3; +static constexpr int WaveformCalib_NBA = 6; +static constexpr int WaveformCalib_NBT = WaveformCalib_NBB + WaveformCalib_NBA + 1; +static constexpr int WaveformCalib_NW = WaveformCalib_NBT * NIS; + + } // namespace zdc } // namespace o2 diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h index 1b704373bc5a7..295e641f81992 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h @@ -28,10 +28,10 @@ namespace o2 namespace zdc { struct WaveformCalibConfig { - static constexpr int NBB = 3; - static constexpr int NBA = 6; - static constexpr int NBT = NBB + NBA + 1; - static constexpr int NW = NBT * NIS; + static constexpr int NBB = WaveformCalib_NBB; + static constexpr int NBA = WaveformCalib_NBA; + static constexpr int NBT = WaveformCalib_NBT; + static constexpr int NW = WaveformCalib_NW; WaveformCalibConfig(); diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h index 8735551aa8a18..87bb6886f7cad 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibData.h @@ -26,13 +26,13 @@ namespace zdc { struct WaveformCalibChData { - static constexpr int NBT = WaveformCalibConfig::NBT; - static constexpr int NW = WaveformCalibConfig::NW; + static constexpr int NBT = WaveformCalib_NBT; + static constexpr int NW = WaveformCalib_NW; - int mFirstValid = 0; /// First bin with valid data - int mLastValid = 0; /// Last bin with valid data - uint32_t mEntries = 0; /// Number of waveforms added - std::array mData = {0}; + int mFirstValid = 0; /// First bin with valid data + int mLastValid = 0; /// Last bin with valid data + uint32_t mEntries = 0; /// Number of waveforms added + std::array mData = {0}; /// Waveform WaveformCalibChData& operator+=(const WaveformCalibChData& other); int getEntries() const; @@ -44,10 +44,10 @@ struct WaveformCalibChData { }; struct WaveformCalibData { - static constexpr int NBB = WaveformCalibConfig::NBB; - static constexpr int NBA = WaveformCalibConfig::NBA; - static constexpr int NBT = WaveformCalibConfig::NBT; - static constexpr int NW = WaveformCalibConfig::NW; + static constexpr int NBB = WaveformCalib_NBB; + static constexpr int NBA = WaveformCalib_NBA; + static constexpr int NBT = WaveformCalib_NBT; + static constexpr int NW = WaveformCalib_NW; uint64_t mCTimeBeg = 0; /// Time of processed time frame uint64_t mCTimeEnd = 0; /// Time of processed time frame diff --git a/Detectors/ZDC/calib/src/WaveformCalibData.cxx b/Detectors/ZDC/calib/src/WaveformCalibData.cxx index 734f4c6729101..1b68f075cdeae 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibData.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibData.cxx @@ -136,7 +136,7 @@ void WaveformCalibData::setN(int n) mWave[is].setN(n); } } else { - LOG(fatal) << "WaveformCalibData " << __func__ << " wrong stored b.c. setting " << n << " not in range [0:" << WaveformCalibConfig::NBT << "]"; + LOG(fatal) << "WaveformCalibData " << __func__ << " wrong stored b.c. setting " << n << " not in range [0:" << NBT << "]"; } } @@ -146,7 +146,7 @@ void WaveformCalibChData::setN(int n) mFirstValid = 0; mLastValid = n * NTimeBinsPerBC * TSN - 1; } else { - LOG(fatal) << "WaveformCalibChData " << __func__ << " wrong stored b.c. setting " << n << " not in range [0:" << WaveformCalibConfig::NBT << "]"; + LOG(fatal) << "WaveformCalibChData " << __func__ << " wrong stored b.c. setting " << n << " not in range [0:" << NBT << "]"; } } diff --git a/Detectors/ZDC/macro/CreateWaveformCalibConfig.C b/Detectors/ZDC/macro/CreateWaveformCalibConfig.C index c2a1e0be8ec11..b6d712a13b93a 100644 --- a/Detectors/ZDC/macro/CreateWaveformCalibConfig.C +++ b/Detectors/ZDC/macro/CreateWaveformCalibConfig.C @@ -11,13 +11,13 @@ #if !defined(__CLING__) || defined(__ROOTCLING__) -#include "Framework/Logger.h" #include "CCDB/CcdbApi.h" #include #include #endif +#include "Framework/Logger.h" #include "ZDCBase/Constants.h" #include "ZDCCalib/WaveformCalibConfig.h" diff --git a/Detectors/ZDC/macro/CreateWaveformCalibParam.C b/Detectors/ZDC/macro/CreateWaveformCalibParam.C index 33660dbd0b467..35670e198c043 100644 --- a/Detectors/ZDC/macro/CreateWaveformCalibParam.C +++ b/Detectors/ZDC/macro/CreateWaveformCalibParam.C @@ -11,15 +11,15 @@ #if !defined(__CLING__) || defined(__ROOTCLING__) -#include "Framework/Logger.h" -#include "CCDB/CcdbApi.h" #include #include #include #include +#include "CCDB/CcdbApi.h" #endif +#include "Framework/Logger.h" #include "ZDCBase/Constants.h" #include "ZDCCalib/WaveformCalibParam.h" diff --git a/Detectors/ZDC/reconstruction/src/RecoParamZDC.cxx b/Detectors/ZDC/reconstruction/src/RecoParamZDC.cxx index 8d22343a1f62e..17477d8dcf5b9 100644 --- a/Detectors/ZDC/reconstruction/src/RecoParamZDC.cxx +++ b/Detectors/ZDC/reconstruction/src/RecoParamZDC.cxx @@ -83,7 +83,7 @@ void o2::zdc::RecoParamZDC::print() */ bool modified = false; for (int i = 0; i < o2::zdc::NChannels; i++) { - if (energy_calib[NChannels] != 0) { + if (energy_calib[i] != 0) { modified = true; break; } @@ -95,7 +95,7 @@ void o2::zdc::RecoParamZDC::print() } printf("energ_calib: "); for (int i = 0; i < o2::zdc::NChannels; i++) { - if (energy_calib[NChannels] != 0) { + if (energy_calib[i] != 0) { printf(" %s=%f", o2::zdc::ChannelNames[i].data(), energy_calib[i]); } } @@ -103,7 +103,7 @@ void o2::zdc::RecoParamZDC::print() } modified = false; for (int i = 0; i < o2::zdc::NChannels; i++) { - if (tower_calib[NChannels] != 0) { + if (tower_calib[i] != 0) { modified = true; break; } @@ -115,7 +115,7 @@ void o2::zdc::RecoParamZDC::print() } printf("tower_calib: "); for (int i = 0; i < o2::zdc::NChannels; i++) { - if (tower_calib[NChannels] != 0) { + if (tower_calib[i] != 0) { printf(" %s=%f", o2::zdc::ChannelNames[i].data(), tower_calib[i]); } } From 4d383f37d721d72ee83620383c852fdbd222ef53 Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Wed, 25 May 2022 23:01:38 +0200 Subject: [PATCH 38/40] clang-format --- Detectors/ZDC/base/include/ZDCBase/Constants.h | 1 - 1 file changed, 1 deletion(-) diff --git a/Detectors/ZDC/base/include/ZDCBase/Constants.h b/Detectors/ZDC/base/include/ZDCBase/Constants.h index 804129a13a2ff..f6fb3741831ca 100644 --- a/Detectors/ZDC/base/include/ZDCBase/Constants.h +++ b/Detectors/ZDC/base/include/ZDCBase/Constants.h @@ -372,7 +372,6 @@ static constexpr int WaveformCalib_NBA = 6; static constexpr int WaveformCalib_NBT = WaveformCalib_NBB + WaveformCalib_NBA + 1; static constexpr int WaveformCalib_NW = WaveformCalib_NBT * NIS; - } // namespace zdc } // namespace o2 From 357a6af91d087b7627ba79fa8bc67aee37b81261 Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Thu, 26 May 2022 08:06:26 +0200 Subject: [PATCH 39/40] Fixing some compilation errors --- .../ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h | 1 - Detectors/ZDC/calib/src/WaveformCalibConfig.cxx | 4 ++-- Detectors/ZDC/calib/src/WaveformCalibParam.cxx | 4 ++-- Detectors/ZDC/macro/CreateWaveformCalibConfig.C | 12 +++++------- 4 files changed, 9 insertions(+), 12 deletions(-) diff --git a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h index 295e641f81992..b7f51f02f0498 100644 --- a/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h +++ b/Detectors/ZDC/calib/include/ZDCCalib/WaveformCalibConfig.h @@ -16,7 +16,6 @@ #include "ZDCBase/Constants.h" #include -#include #include /// \file WaveformCalibConfig.h diff --git a/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx b/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx index 7919bcf29890b..73042c42ce2f8 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx @@ -45,10 +45,10 @@ void WaveformCalibConfig::restrictRange(int ib, int ie) void WaveformCalibConfig::print() const { LOG(info) << "WaveformCalibConfig range [" << ibeg << ":" << iend << "]"; - for (Int_t isig = 0; isig < NChannels; isig++) { + for (int isig = 0; isig < NChannels; isig++) { LOG(info) << ChannelNames[isig] << " limits A = (" << cutLow[isig] << " : " << cutHigh[isig] << ") min_entries = " << min_e[isig]; } - for (Int_t itdc = 0; itdc < NTDCChannels; itdc++) { + for (int itdc = 0; itdc < NTDCChannels; itdc++) { LOG(info) << ChannelNames[TDCSignal[itdc]] << " T = (" << cutTimeLow[itdc] << " : " << cutTimeHigh[itdc] << ")"; } } diff --git a/Detectors/ZDC/calib/src/WaveformCalibParam.cxx b/Detectors/ZDC/calib/src/WaveformCalibParam.cxx index 37e411a235e8c..78af3372d6d20 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibParam.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibParam.cxx @@ -20,9 +20,9 @@ using namespace o2::zdc; void WaveformCalibChParam::print() const { if (shape.size() > 0) { - printf("Shape min at bin %d/%d\n", ampMinID, shape.size()); + printf("Shape min at bin %d/%lu\n", ampMinID, shape.size()); } else { - printf("No data\n", ampMinID, shape.size()); + printf("No data\n"); } } diff --git a/Detectors/ZDC/macro/CreateWaveformCalibConfig.C b/Detectors/ZDC/macro/CreateWaveformCalibConfig.C index b6d712a13b93a..82905ace393e2 100644 --- a/Detectors/ZDC/macro/CreateWaveformCalibConfig.C +++ b/Detectors/ZDC/macro/CreateWaveformCalibConfig.C @@ -11,16 +11,15 @@ #if !defined(__CLING__) || defined(__ROOTCLING__) -#include "CCDB/CcdbApi.h" #include #include - -#endif - #include "Framework/Logger.h" +#include "CCDB/CcdbApi.h" #include "ZDCBase/Constants.h" #include "ZDCCalib/WaveformCalibConfig.h" +#endif + using namespace o2::zdc; using namespace std; @@ -41,7 +40,8 @@ void CreateWaveformCalibConfig(long tmin = 0, long tmax = -1, std::string ccdbHo conf.setDescription("Simulated data"); conf.setMinEntries(200); - // Restrict waveform range + // Restrict waveform range (default is -3, 6 as defined in WaveformCalib_NBB + // WaveformCalib_NBA in file Detectors/ZDC/base/include/ZDCBase/Constants.h) conf.restrictRange(-1, 0); conf.print(); @@ -61,6 +61,4 @@ void CreateWaveformCalibConfig(long tmin = 0, long tmax = -1, std::string ccdbHo LOG(info) << "CCDB server: " << api.getURL(); // store abitrary user object in strongly typed manner api.storeAsTFileAny(&conf, CCDBPathWaveformCalibConfig, metadata, tmin, tmax); - - // return conf; } From 19db720be0dca7db75aa1e0ea8204d008d6249d5 Mon Sep 17 00:00:00 2001 From: Pietro Cortese Date: Thu, 26 May 2022 09:43:09 +0200 Subject: [PATCH 40/40] Corrected initialization --- Detectors/ZDC/calib/src/WaveformCalibConfig.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx b/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx index 73042c42ce2f8..d9e732c9aba2c 100644 --- a/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx +++ b/Detectors/ZDC/calib/src/WaveformCalibConfig.cxx @@ -15,7 +15,7 @@ using namespace o2::zdc; WaveformCalibConfig::WaveformCalibConfig() { - for (int isig = 0; isig < NTDCChannels; isig++) { + for (int isig = 0; isig < NChannels; isig++) { cutLow[isig] = -std::numeric_limits::infinity(); cutHigh[isig] = std::numeric_limits::infinity(); }