IntegratedClusterCalibrator.h

Go to the documentation of this file.

// 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 INTEGRATEDCLUSTERCALIBRATOR_H_
#define INTEGRATEDCLUSTERCALIBRATOR_H_
 
#include "DetectorsCalibration/TimeSlotCalibration.h"
#include "DetectorsCalibration/TimeSlot.h"
 
class TTree;
 
namespace o2
{
 
// see https://stackoverflow.com/questions/56483053/if-condition-checking-multiple-vector-sizes-are-equal
// comparing if all vector have the same size
template <typename T0, typename... Ts>
bool sameSize(T0 const& first, Ts const&... rest)
{
  return ((first.size() == rest.size()) && ...);
}
 
namespace tof
{
 
struct ITOFC {
  std::vector<float> mITOFCNCl;                                     
  std::vector<float> mITOFCQ;                                       
  long mTimeMS{};                                                   
  bool areSameSize() const { return sameSize(mITOFCNCl, mITOFCQ); } 
  bool isEmpty() const { return mITOFCNCl.empty(); }                
  size_t getEntries() const { return mITOFCNCl.size(); }            
  void setStartTime(long timeMS) { mTimeMS = timeMS; }
 
  void fill(const unsigned int posIndex, const ITOFC& data)
  {
    std::copy(data.mITOFCNCl.begin(), data.mITOFCNCl.end(), mITOFCNCl.begin() + posIndex);
    std::copy(data.mITOFCQ.begin(), data.mITOFCQ.end(), mITOFCQ.begin() + posIndex);
  }
 
  void insert(const unsigned int nDummyValues)
  {
    std::vector<float> vecTmp(nDummyValues, 0);
    mITOFCNCl.insert(mITOFCNCl.begin(), vecTmp.begin(), vecTmp.end());
    mITOFCQ.insert(mITOFCQ.begin(), vecTmp.begin(), vecTmp.end());
  }
 
  void resize(const unsigned int nTotal)
  {
    mITOFCNCl.resize(nTotal);
    mITOFCQ.resize(nTotal);
  }
 
  ClassDefNV(ITOFC, 2);
};
} // end namespace tof
 
namespace tpc
{
 
struct ITPCC {
  std::vector<float> mIQMaxA; 
  std::vector<float> mIQMaxC; 
  std::vector<float> mIQTotA; 
  std::vector<float> mIQTotC; 
  std::vector<float> mINClA;  
  std::vector<float> mINClC;  
  long mTimeMS{};             
 
  float compression(float value, const int nBits) const
  {
    const int shiftN = std::pow(2, nBits);
    int exp2;
    const auto mantissa = std::frexp(value, &exp2);
    const auto mantissaRounded = std::round(mantissa * shiftN) / shiftN;
    return std::ldexp(mantissaRounded, exp2);
  }
 
  void compress(const int nBits)
  {
    std::transform(mIQMaxA.begin(), mIQMaxA.end(), mIQMaxA.begin(), [this, nBits](float val) { return compression(val, nBits); });
    std::transform(mIQMaxC.begin(), mIQMaxC.end(), mIQMaxC.begin(), [this, nBits](float val) { return compression(val, nBits); });
    std::transform(mIQTotA.begin(), mIQTotA.end(), mIQTotA.begin(), [this, nBits](float val) { return compression(val, nBits); });
    std::transform(mIQTotC.begin(), mIQTotC.end(), mIQTotC.begin(), [this, nBits](float val) { return compression(val, nBits); });
    std::transform(mINClA.begin(), mINClA.end(), mINClA.begin(), [this, nBits](float val) { return compression(val, nBits); });
    std::transform(mINClC.begin(), mINClC.end(), mINClC.begin(), [this, nBits](float val) { return compression(val, nBits); });
  }
 
  bool areSameSize() const { return sameSize(mIQMaxA, mIQMaxC, mIQTotA, mIQTotC, mINClA, mINClC); } 
  bool isEmpty() const { return mIQMaxA.empty(); }                                                  
  size_t getEntries() const { return mIQMaxA.size(); }                                              
  void setStartTime(long timeMS) { mTimeMS = timeMS; }
 
  void fill(const unsigned int posIndex, const ITPCC& data)
  {
    std::copy(data.mIQMaxA.begin(), data.mIQMaxA.end(), mIQMaxA.begin() + posIndex);
    std::copy(data.mIQMaxC.begin(), data.mIQMaxC.end(), mIQMaxC.begin() + posIndex);
    std::copy(data.mIQTotA.begin(), data.mIQTotA.end(), mIQTotA.begin() + posIndex);
    std::copy(data.mIQTotC.begin(), data.mIQTotC.end(), mIQTotC.begin() + posIndex);
    std::copy(data.mINClA.begin(), data.mINClA.end(), mINClA.begin() + posIndex);
    std::copy(data.mINClC.begin(), data.mINClC.end(), mINClC.begin() + posIndex);
  }
 
  void insert(const unsigned int nDummyValues)
  {
    std::vector<float> vecTmp(nDummyValues, 0);
    mIQMaxA.insert(mIQMaxA.begin(), vecTmp.begin(), vecTmp.end());
    mIQMaxC.insert(mIQMaxC.begin(), vecTmp.begin(), vecTmp.end());
    mIQTotA.insert(mIQTotA.begin(), vecTmp.begin(), vecTmp.end());
    mIQTotC.insert(mIQTotC.begin(), vecTmp.begin(), vecTmp.end());
    mINClA.insert(mINClA.begin(), vecTmp.begin(), vecTmp.end());
    mINClC.insert(mINClC.begin(), vecTmp.begin(), vecTmp.end());
  }
 
  void resize(const unsigned int nTotal)
  {
    mIQMaxA.resize(nTotal);
    mIQMaxC.resize(nTotal);
    mIQTotA.resize(nTotal);
    mIQTotC.resize(nTotal);
    mINClA.resize(nTotal);
    mINClC.resize(nTotal);
  }
 
  void reset()
  {
    std::fill(mIQMaxA.begin(), mIQMaxA.end(), 0);
    std::fill(mIQMaxC.begin(), mIQMaxC.end(), 0);
    std::fill(mIQTotA.begin(), mIQTotA.end(), 0);
    std::fill(mIQTotC.begin(), mIQTotC.end(), 0);
    std::fill(mINClA.begin(), mINClA.end(), 0);
    std::fill(mINClC.begin(), mINClC.end(), 0);
  }
 
  void normalize(const float factor)
  {
    std::transform(mIQMaxA.begin(), mIQMaxA.end(), mIQMaxA.begin(), [factor](const float val) { return val * factor; });
    std::transform(mIQMaxC.begin(), mIQMaxC.end(), mIQMaxC.begin(), [factor](const float val) { return val * factor; });
    std::transform(mIQTotA.begin(), mIQTotA.end(), mIQTotA.begin(), [factor](const float val) { return val * factor; });
    std::transform(mIQTotC.begin(), mIQTotC.end(), mIQTotC.begin(), [factor](const float val) { return val * factor; });
    std::transform(mINClA.begin(), mINClA.end(), mINClA.begin(), [factor](const float val) { return val * factor; });
    std::transform(mINClC.begin(), mINClC.end(), mINClC.begin(), [factor](const float val) { return val * factor; });
  }
 
  ClassDefNV(ITPCC, 2);
};
 
struct TimeSeries {
  std::vector<float> mDCAr_A_Median;       
  std::vector<float> mDCAr_C_Median;       
  std::vector<float> mDCAr_A_WeightedMean; 
  std::vector<float> mDCAr_C_WeightedMean; 
  std::vector<float> mDCAr_A_RMS;          
  std::vector<float> mDCAr_C_RMS;          
  std::vector<float> mDCAr_A_NTracks;      
  std::vector<float> mDCAr_C_NTracks;      
  std::vector<float> mDCAz_A_Median;       
  std::vector<float> mDCAz_C_Median;       
  std::vector<float> mDCAz_A_WeightedMean; 
  std::vector<float> mDCAz_C_WeightedMean; 
  std::vector<float> mDCAz_A_RMS;          
  std::vector<float> mDCAz_C_RMS;          
  std::vector<float> mDCAz_A_NTracks;      
  std::vector<float> mDCAz_C_NTracks;      
  std::vector<float> mMIPdEdxRatioQMaxA;   
  std::vector<float> mMIPdEdxRatioQMaxC;   
  std::vector<float> mMIPdEdxRatioQTotA;   
  std::vector<float> mMIPdEdxRatioQTotC;   
  std::vector<float> mTPCChi2A;            
  std::vector<float> mTPCChi2C;            
  std::vector<float> mTPCNClA;             
  std::vector<float> mTPCNClC;             
 
  unsigned char mNBinsPhi{}; 
  unsigned char mNBinsTgl{}; 
  float mTglMax{};           
  unsigned char mNBinsqPt{}; 
  float mQPtMax{};           
  unsigned char mMultBins{}; 
  float mMultMax{};          
  long mTimeMS{};            
 
  void setStartTime(long timeMS) { mTimeMS = timeMS; }
 
  int getNBins() const { return mNBinsTgl + mNBinsPhi + mNBinsqPt + mMultBins + 1; }
 
  int getIndexPhi(const int iPhi, int slice = 0) const { return iPhi + slice * getNBins(); }
 
  int getIndexTgl(const int iTgl, int slice = 0) const { return mNBinsPhi + iTgl + slice * getNBins(); }
 
  int getIndexqPt(const int iqPt, int slice = 0) const { return mNBinsPhi + mNBinsTgl + iqPt + slice * getNBins(); }
 
  int getIndexMult(const int iMult, int slice = 0) const { return mNBinsPhi + mNBinsTgl + mNBinsqPt + iMult + slice * getNBins(); }
 
  int getIndexInt(int slice = 0) const { return getNBins() - 1 + slice * getNBins(); }
 
  void resize(const unsigned int nTotal)
  {
    mDCAr_A_Median.resize(nTotal);
    mDCAr_C_Median.resize(nTotal);
    mDCAr_A_RMS.resize(nTotal);
    mDCAr_C_RMS.resize(nTotal);
    mDCAz_A_Median.resize(nTotal);
    mDCAz_C_Median.resize(nTotal);
    mDCAz_A_RMS.resize(nTotal);
    mDCAz_C_RMS.resize(nTotal);
    mDCAr_C_NTracks.resize(nTotal);
    mDCAr_A_NTracks.resize(nTotal);
    mDCAz_A_NTracks.resize(nTotal);
    mDCAz_C_NTracks.resize(nTotal);
    mDCAr_A_WeightedMean.resize(nTotal);
    mDCAr_C_WeightedMean.resize(nTotal);
    mDCAz_A_WeightedMean.resize(nTotal);
    mDCAz_C_WeightedMean.resize(nTotal);
    mMIPdEdxRatioQMaxA.resize(nTotal);
    mMIPdEdxRatioQMaxC.resize(nTotal);
    mMIPdEdxRatioQTotA.resize(nTotal);
    mMIPdEdxRatioQTotC.resize(nTotal);
    mTPCChi2A.resize(nTotal);
    mTPCChi2C.resize(nTotal);
    mTPCNClA.resize(nTotal);
    mTPCNClC.resize(nTotal);
  }
 
  ClassDefNV(TimeSeries, 1);
};
 
struct ITSTPC_Matching {
  std::vector<float> mITSTPC_A_MatchEff;  
  std::vector<float> mITSTPC_C_MatchEff;  
  std::vector<float> mITSTPC_A_Chi2Match; 
  std::vector<float> mITSTPC_C_Chi2Match; 
 
  void resize(const unsigned int nTotal)
  {
    mITSTPC_A_MatchEff.resize(nTotal);
    mITSTPC_C_MatchEff.resize(nTotal);
    mITSTPC_A_Chi2Match.resize(nTotal);
    mITSTPC_C_Chi2Match.resize(nTotal);
  }
 
  ClassDefNV(ITSTPC_Matching, 2);
};
 
struct TimeSeriesdEdx {
  std::vector<float> mLogdEdx_A_Median;       
  std::vector<float> mLogdEdx_A_RMS;          
  std::vector<float> mLogdEdx_A_IROC_Median;  
  std::vector<float> mLogdEdx_A_IROC_RMS;     
  std::vector<float> mLogdEdx_A_OROC1_Median; 
  std::vector<float> mLogdEdx_A_OROC1_RMS;    
  std::vector<float> mLogdEdx_A_OROC2_Median; 
  std::vector<float> mLogdEdx_A_OROC2_RMS;    
  std::vector<float> mLogdEdx_A_OROC3_Median; 
  std::vector<float> mLogdEdx_A_OROC3_RMS;    
  std::vector<float> mLogdEdx_C_Median;       
  std::vector<float> mLogdEdx_C_RMS;          
  std::vector<float> mLogdEdx_C_IROC_Median;  
  std::vector<float> mLogdEdx_C_IROC_RMS;     
  std::vector<float> mLogdEdx_C_OROC1_Median; 
  std::vector<float> mLogdEdx_C_OROC1_RMS;    
  std::vector<float> mLogdEdx_C_OROC2_Median; 
  std::vector<float> mLogdEdx_C_OROC2_RMS;    
  std::vector<float> mLogdEdx_C_OROC3_Median; 
  std::vector<float> mLogdEdx_C_OROC3_RMS;    
 
  void resize(const unsigned int nTotal)
  {
    mLogdEdx_A_Median.resize(nTotal);
    mLogdEdx_A_RMS.resize(nTotal);
    mLogdEdx_A_IROC_Median.resize(nTotal);
    mLogdEdx_A_IROC_RMS.resize(nTotal);
    mLogdEdx_A_OROC1_Median.resize(nTotal);
    mLogdEdx_A_OROC1_RMS.resize(nTotal);
    mLogdEdx_A_OROC2_Median.resize(nTotal);
    mLogdEdx_A_OROC2_RMS.resize(nTotal);
    mLogdEdx_A_OROC3_Median.resize(nTotal);
    mLogdEdx_A_OROC3_RMS.resize(nTotal);
    mLogdEdx_C_Median.resize(nTotal);
    mLogdEdx_C_RMS.resize(nTotal);
    mLogdEdx_C_IROC_Median.resize(nTotal);
    mLogdEdx_C_IROC_RMS.resize(nTotal);
    mLogdEdx_C_OROC1_Median.resize(nTotal);
    mLogdEdx_C_OROC1_RMS.resize(nTotal);
    mLogdEdx_C_OROC2_Median.resize(nTotal);
    mLogdEdx_C_OROC2_RMS.resize(nTotal);
    mLogdEdx_C_OROC3_Median.resize(nTotal);
    mLogdEdx_C_OROC3_RMS.resize(nTotal);
  }
 
  ClassDefNV(TimeSeriesdEdx, 1);
};
 
struct TimeSeriesITSTPC {
  float mVDrift = 0;                                   
  float mPressure = 0;                                 
  float mTemperature = 0;                              
  TimeSeries mTSTPC;                                   
  TimeSeries mTSITSTPC;                                
  ITSTPC_Matching mITSTPCAll;                          
  ITSTPC_Matching mITSTPCStandalone;                   
  ITSTPC_Matching mITSTPCAfterburner;                  
  TimeSeriesdEdx mdEdxQTot;                            
  TimeSeriesdEdx mdEdxQMax;                            
  std::vector<unsigned int> mOccupancyMapTPC;          
  std::vector<std::pair<int, float>> mSecEdgeFlucCorr; 
 
  std::vector<float> nPrimVertices;                  
  std::vector<float> nPrimVertices_ITS;              
  std::vector<float> nVertexContributors_ITS_Median; 
  std::vector<float> nVertexContributors_ITS_RMS;    
  std::vector<float> vertexX_ITS_Median;             
  std::vector<float> vertexY_ITS_Median;             
  std::vector<float> vertexZ_ITS_Median;             
  std::vector<float> vertexX_ITS_RMS;                
  std::vector<float> vertexY_ITS_RMS;                
  std::vector<float> vertexZ_ITS_RMS;                
 
  std::vector<float> nPrimVertices_ITSTPC;              
  std::vector<float> nVertexContributors_ITSTPC_Median; 
  std::vector<float> nVertexContributors_ITSTPC_RMS;    
  std::vector<float> vertexX_ITSTPC_Median;             
  std::vector<float> vertexY_ITSTPC_Median;             
  std::vector<float> vertexZ_ITSTPC_Median;             
  std::vector<float> vertexX_ITSTPC_RMS;                
  std::vector<float> vertexY_ITSTPC_RMS;                
  std::vector<float> vertexZ_ITSTPC_RMS;                
 
  int quantileValues = 23;                          
  std::vector<float> nVertexContributors_Quantiles; 
 
  std::vector<float> mDCAr_comb_A_Median;       
  std::vector<float> mDCAz_comb_A_Median;       
  std::vector<float> mDCAr_comb_A_RMS;          
  std::vector<float> mDCAz_comb_A_RMS;          
  std::vector<float> mDCAr_comb_C_Median;       
  std::vector<float> mDCAz_comb_C_Median;       
  std::vector<float> mDCAr_comb_C_RMS;          
  std::vector<float> mDCAz_comb_C_RMS;          
  std::vector<float> mITS_A_NCl_Median;         
  std::vector<float> mITS_A_NCl_RMS;            
  std::vector<float> mITS_C_NCl_Median;         
  std::vector<float> mITS_C_NCl_RMS;            
  std::vector<float> mSqrtITSChi2_Ncl_A_Median; 
  std::vector<float> mSqrtITSChi2_Ncl_C_Median; 
  std::vector<float> mSqrtITSChi2_Ncl_A_RMS;    
  std::vector<float> mSqrtITSChi2_Ncl_C_RMS;    
 
  std::vector<float> mITSTPCDeltaP2_A_Median; 
  std::vector<float> mITSTPCDeltaP3_A_Median; 
  std::vector<float> mITSTPCDeltaP4_A_Median; 
  std::vector<float> mITSTPCDeltaP2_C_Median; 
  std::vector<float> mITSTPCDeltaP3_C_Median; 
  std::vector<float> mITSTPCDeltaP4_C_Median; 
  std::vector<float> mITSTPCDeltaP2_A_RMS;    
  std::vector<float> mITSTPCDeltaP3_A_RMS;    
  std::vector<float> mITSTPCDeltaP4_A_RMS;    
  std::vector<float> mITSTPCDeltaP2_C_RMS;    
  std::vector<float> mITSTPCDeltaP3_C_RMS;    
  std::vector<float> mITSTPCDeltaP4_C_RMS;    
 
  std::vector<float> mTPCSigmaY2A_Median; 
  std::vector<float> mTPCSigmaZ2A_Median; 
  std::vector<float> mTPCSigmaY2C_Median; 
  std::vector<float> mTPCSigmaZ2C_Median; 
  std::vector<float> mTPCSigmaY2A_RMS;    
  std::vector<float> mTPCSigmaZ2A_RMS;    
  std::vector<float> mTPCSigmaY2C_RMS;    
  std::vector<float> mTPCSigmaZ2C_RMS;    
 
  void setStartTime(long timeMS)
  {
    mTSTPC.setStartTime(timeMS);
    mTSITSTPC.setStartTime(timeMS);
  }
 
  void setBinning(const int nBinsPhi, const int nBinsTgl, const int qPtBins, const int nBinsMult, float tglMax, float qPtMax, float multMax)
  {
    mTSTPC.mNBinsPhi = nBinsPhi;
    mTSTPC.mNBinsTgl = nBinsTgl;
    mTSTPC.mNBinsqPt = qPtBins;
    mTSTPC.mMultBins = nBinsMult;
    mTSTPC.mTglMax = tglMax;
    mTSTPC.mQPtMax = qPtMax;
    mTSTPC.mMultMax = multMax;
    mTSITSTPC.mNBinsPhi = nBinsPhi;
    mTSITSTPC.mNBinsTgl = nBinsTgl;
    mTSITSTPC.mNBinsqPt = qPtBins;
    mTSITSTPC.mMultBins = nBinsMult;
    mTSITSTPC.mTglMax = tglMax;
    mTSITSTPC.mQPtMax = qPtMax;
    mTSITSTPC.mMultMax = multMax;
  }
 
  void resize(const unsigned int nTotal)
  {
    mTSTPC.resize(nTotal);
    mTSITSTPC.resize(nTotal);
    mITSTPCAll.resize(nTotal);
    mITSTPCStandalone.resize(nTotal);
    mITSTPCAfterburner.resize(nTotal);
    mdEdxQTot.resize(nTotal);
    mdEdxQMax.resize(nTotal);
    mDCAr_comb_A_Median.resize(nTotal);
    mDCAz_comb_A_Median.resize(nTotal);
    mDCAr_comb_A_RMS.resize(nTotal);
    mDCAz_comb_A_RMS.resize(nTotal);
    mDCAr_comb_C_Median.resize(nTotal);
    mDCAz_comb_C_Median.resize(nTotal);
    mDCAr_comb_C_RMS.resize(nTotal);
    mDCAz_comb_C_RMS.resize(nTotal);
    mITS_A_NCl_Median.resize(nTotal);
    mITS_A_NCl_RMS.resize(nTotal);
    mITS_C_NCl_Median.resize(nTotal);
    mITS_C_NCl_RMS.resize(nTotal);
    mSqrtITSChi2_Ncl_A_Median.resize(nTotal);
    mSqrtITSChi2_Ncl_C_Median.resize(nTotal);
    mSqrtITSChi2_Ncl_A_RMS.resize(nTotal);
    mSqrtITSChi2_Ncl_C_RMS.resize(nTotal);
    mITSTPCDeltaP2_A_Median.resize(nTotal);
    mITSTPCDeltaP3_A_Median.resize(nTotal);
    mITSTPCDeltaP4_A_Median.resize(nTotal);
    mITSTPCDeltaP2_C_Median.resize(nTotal);
    mITSTPCDeltaP3_C_Median.resize(nTotal);
    mITSTPCDeltaP4_C_Median.resize(nTotal);
    mITSTPCDeltaP2_A_RMS.resize(nTotal);
    mITSTPCDeltaP3_A_RMS.resize(nTotal);
    mITSTPCDeltaP4_A_RMS.resize(nTotal);
    mITSTPCDeltaP2_C_RMS.resize(nTotal);
    mITSTPCDeltaP3_C_RMS.resize(nTotal);
    mITSTPCDeltaP4_C_RMS.resize(nTotal);
    mTPCSigmaY2A_Median.resize(nTotal);
    mTPCSigmaZ2A_Median.resize(nTotal);
    mTPCSigmaY2C_Median.resize(nTotal);
    mTPCSigmaZ2C_Median.resize(nTotal);
    mTPCSigmaY2A_RMS.resize(nTotal);
    mTPCSigmaZ2A_RMS.resize(nTotal);
    mTPCSigmaY2C_RMS.resize(nTotal);
    mTPCSigmaZ2C_RMS.resize(nTotal);
 
    const int nTotalVtx = nTotal / mTSTPC.getNBins();
    nPrimVertices.resize(nTotalVtx);
    nPrimVertices_ITS.resize(nTotalVtx);
    nVertexContributors_ITS_Median.resize(nTotalVtx);
    nVertexContributors_ITS_RMS.resize(nTotalVtx);
    vertexX_ITS_Median.resize(nTotalVtx);
    vertexY_ITS_Median.resize(nTotalVtx);
    vertexZ_ITS_Median.resize(nTotalVtx);
    vertexX_ITS_RMS.resize(nTotalVtx);
    vertexY_ITS_RMS.resize(nTotalVtx);
    vertexZ_ITS_RMS.resize(nTotalVtx);
    nPrimVertices_ITSTPC.resize(nTotalVtx);
    nVertexContributors_ITSTPC_Median.resize(nTotalVtx);
    nVertexContributors_ITSTPC_RMS.resize(nTotalVtx);
    vertexX_ITSTPC_Median.resize(nTotalVtx);
    vertexY_ITSTPC_Median.resize(nTotalVtx);
    vertexZ_ITSTPC_Median.resize(nTotalVtx);
    vertexX_ITSTPC_RMS.resize(nTotalVtx);
    vertexY_ITSTPC_RMS.resize(nTotalVtx);
    vertexZ_ITSTPC_RMS.resize(nTotalVtx);
 
    const int nTotalQ = quantileValues * nTotal / mTSTPC.getNBins();
    nVertexContributors_Quantiles.resize(nTotalQ);
  }
 
  ClassDefNV(TimeSeriesITSTPC, 7);
};
 
} // end namespace tpc
 
namespace fit
{
 
struct IFT0C {
  std::vector<float> mINChanA;                                                        
  std::vector<float> mINChanC;                                                        
  std::vector<float> mIAmplA;                                                         
  std::vector<float> mIAmplC;                                                         
  long mTimeMS{};                                                                     
  bool areSameSize() const { return sameSize(mINChanA, mINChanC, mIAmplA, mIAmplC); } 
  bool isEmpty() const { return mINChanA.empty(); }                                   
  size_t getEntries() const { return mINChanA.size(); }                               
  void setStartTime(long timeMS) { mTimeMS = timeMS; }
 
  void fill(const unsigned int posIndex, const IFT0C& data)
  {
    std::copy(data.mINChanA.begin(), data.mINChanA.end(), mINChanA.begin() + posIndex);
    std::copy(data.mINChanC.begin(), data.mINChanC.end(), mINChanC.begin() + posIndex);
    std::copy(data.mIAmplA.begin(), data.mIAmplA.end(), mIAmplA.begin() + posIndex);
    std::copy(data.mIAmplC.begin(), data.mIAmplC.end(), mIAmplC.begin() + posIndex);
  }
 
  void insert(const unsigned int nDummyValues)
  {
    std::vector<float> vecTmp(nDummyValues, 0);
    mINChanA.insert(mINChanA.begin(), vecTmp.begin(), vecTmp.end());
    mINChanC.insert(mINChanC.begin(), vecTmp.begin(), vecTmp.end());
    mIAmplA.insert(mIAmplA.begin(), vecTmp.begin(), vecTmp.end());
    mIAmplC.insert(mIAmplC.begin(), vecTmp.begin(), vecTmp.end());
  }
 
  void resize(const unsigned int nTotal)
  {
    mINChanA.resize(nTotal);
    mINChanC.resize(nTotal);
    mIAmplA.resize(nTotal);
    mIAmplC.resize(nTotal);
  }
 
  void reset()
  {
    std::fill(mINChanA.begin(), mINChanA.end(), 0);
    std::fill(mINChanC.begin(), mINChanC.end(), 0);
    std::fill(mIAmplA.begin(), mIAmplA.end(), 0);
    std::fill(mIAmplC.begin(), mIAmplC.end(), 0);
  }
 
  void normalize(const float factor)
  {
    std::transform(mINChanA.begin(), mINChanA.end(), mINChanA.begin(), [factor](const float val) { return val * factor; });
    std::transform(mINChanC.begin(), mINChanC.end(), mINChanC.begin(), [factor](const float val) { return val * factor; });
    std::transform(mIAmplA.begin(), mIAmplA.end(), mIAmplA.begin(), [factor](const float val) { return val * factor; });
    std::transform(mIAmplC.begin(), mIAmplC.end(), mIAmplC.begin(), [factor](const float val) { return val * factor; });
  }
 
  ClassDefNV(IFT0C, 2);
};
 
struct IFV0C {
  std::vector<float> mINChanA;                                     
  std::vector<float> mIAmplA;                                      
  long mTimeMS{};                                                  
  bool areSameSize() const { return sameSize(mINChanA, mIAmplA); } 
  bool isEmpty() const { return mINChanA.empty(); }                
  size_t getEntries() const { return mINChanA.size(); }            
  void setStartTime(long timeMS) { mTimeMS = timeMS; }
 
  void fill(const unsigned int posIndex, const IFV0C& data)
  {
    std::copy(data.mINChanA.begin(), data.mINChanA.end(), mINChanA.begin() + posIndex);
    std::copy(data.mIAmplA.begin(), data.mIAmplA.end(), mIAmplA.begin() + posIndex);
  }
 
  void insert(const unsigned int nDummyValues)
  {
    std::vector<float> vecTmp(nDummyValues, 0);
    mINChanA.insert(mINChanA.begin(), vecTmp.begin(), vecTmp.end());
    mIAmplA.insert(mIAmplA.begin(), vecTmp.begin(), vecTmp.end());
  }
 
  void resize(const unsigned int nTotal)
  {
    mINChanA.resize(nTotal);
    mIAmplA.resize(nTotal);
  }
 
  void reset()
  {
    std::fill(mINChanA.begin(), mINChanA.end(), 0);
    std::fill(mIAmplA.begin(), mIAmplA.end(), 0);
  }
 
  void normalize(const float factor)
  {
    std::transform(mINChanA.begin(), mINChanA.end(), mINChanA.begin(), [factor](const float val) { return val * factor; });
    std::transform(mIAmplA.begin(), mIAmplA.end(), mIAmplA.begin(), [factor](const float val) { return val * factor; });
  }
 
  ClassDefNV(IFV0C, 2);
};
 
struct IFDDC {
  std::vector<float> mINChanA;                                                        
  std::vector<float> mINChanC;                                                        
  std::vector<float> mIAmplA;                                                         
  std::vector<float> mIAmplC;                                                         
  long mTimeMS{};                                                                     
  bool areSameSize() const { return sameSize(mINChanA, mINChanC, mIAmplA, mIAmplC); } 
  bool isEmpty() const { return mINChanA.empty(); }                                   
  size_t getEntries() const { return mINChanA.size(); }                               
  void setStartTime(long timeMS) { mTimeMS = timeMS; }
 
  void fill(const unsigned int posIndex, const IFDDC& data)
  {
    std::copy(data.mINChanA.begin(), data.mINChanA.end(), mINChanA.begin() + posIndex);
    std::copy(data.mINChanC.begin(), data.mINChanC.end(), mINChanC.begin() + posIndex);
    std::copy(data.mIAmplA.begin(), data.mIAmplA.end(), mIAmplA.begin() + posIndex);
    std::copy(data.mIAmplC.begin(), data.mIAmplC.end(), mIAmplC.begin() + posIndex);
  }
 
  void insert(const unsigned int nDummyValues)
  {
    std::vector<float> vecTmp(nDummyValues, 0);
    mINChanA.insert(mINChanA.begin(), vecTmp.begin(), vecTmp.end());
    mINChanC.insert(mINChanC.begin(), vecTmp.begin(), vecTmp.end());
    mIAmplA.insert(mIAmplA.begin(), vecTmp.begin(), vecTmp.end());
    mIAmplC.insert(mIAmplC.begin(), vecTmp.begin(), vecTmp.end());
  }
 
  void resize(const unsigned int nTotal)
  {
    mINChanA.resize(nTotal);
    mINChanC.resize(nTotal);
    mIAmplA.resize(nTotal);
    mIAmplC.resize(nTotal);
  }
 
  void reset()
  {
    std::fill(mINChanA.begin(), mINChanA.end(), 0);
    std::fill(mINChanC.begin(), mINChanC.end(), 0);
    std::fill(mIAmplA.begin(), mIAmplA.end(), 0);
    std::fill(mIAmplC.begin(), mIAmplC.end(), 0);
  }
 
  void normalize(const float factor)
  {
    std::transform(mINChanA.begin(), mINChanA.end(), mINChanA.begin(), [factor](const float val) { return val * factor; });
    std::transform(mINChanC.begin(), mINChanC.end(), mINChanC.begin(), [factor](const float val) { return val * factor; });
    std::transform(mIAmplA.begin(), mIAmplA.end(), mIAmplA.begin(), [factor](const float val) { return val * factor; });
    std::transform(mIAmplC.begin(), mIAmplC.end(), mIAmplC.begin(), [factor](const float val) { return val * factor; });
  }
 
  ClassDefNV(IFDDC, 2);
};
 
} // end namespace fit
} // end namespace o2
 
namespace o2
{
namespace calibration
{
 
template <typename DataT>
class IntegratedClusters
{
 public:
  IntegratedClusters(o2::calibration::TFType tFirst, o2::calibration::TFType tLast) : mTFFirst{tFirst}, mTFLast{tLast} {};
 
  IntegratedClusters() = default;
 
  void print() const { LOGP(info, "TF Range from {} to {} with {} of remaining data", mTFFirst, mTFLast, mRemainingData); }
 
  void fill(const o2::calibration::TFType tfID, const DataT& currentsContainer);
 
  void merge(const IntegratedClusters* prev);
 
  bool hasEnoughData() const { return (mRemainingData != -1); }
 
  const auto& getCurrents() const& { return mCurrents; }
 
  auto getCurrents() && { return std::move(mCurrents); }
 
  void setCurrents(const DataT& currents) { mCurrents = currents; }
 
  void dumpToFile(const char* outFileName = "IntegratedClusters.root", const char* outName = "IC") const;
 
  void dumpToTree(const char* outFileName = "ICTree.root");
 
  void setStartTime(long timeMS) { mCurrents.setStartTime(timeMS); }
 
 private:
  DataT mCurrents;                             
  o2::calibration::TFType mTFFirst{};          
  o2::calibration::TFType mTFLast{};           
  o2::calibration::TFType mRemainingData = -1; 
  unsigned int mNValuesPerTF{};                
  bool mInitialize{true};                      
 
  void initData(const unsigned int valuesPerTF);
 
  ClassDefNV(IntegratedClusters, 1);
};
 
template <typename DataT>
class IntegratedClusterCalibrator final : public o2::calibration::TimeSlotCalibration<IntegratedClusters<DataT>>
{
  using TFType = o2::calibration::TFType;
  using Slot = o2::calibration::TimeSlot<IntegratedClusters<DataT>>;
  using CalibVector = std::vector<DataT>;
  using TFinterval = std::vector<std::pair<TFType, TFType>>;
  using TimeInterval = std::vector<std::pair<long, long>>;
 
 public:
  IntegratedClusterCalibrator() = default;
 
  ~IntegratedClusterCalibrator() final = default;
 
  bool hasEnoughData(const Slot& slot) const final { return slot.getContainer()->hasEnoughData(); }
 
  void initOutput() final;
 
  void finalizeSlot(Slot& slot) final;
 
  Slot& emplaceNewSlot(bool front, TFType tstart, TFType tend) final;
 
  const TFinterval& getTFinterval() const { return mIntervals; }
 
  const TimeInterval& getTimeIntervals() const { return mTimeIntervals; }
 
  auto getCalibs() && { return std::move(mCalibs); }
 
  bool hasCalibrationData() const { return mCalibs.size() > 0; }
 
  void setDebug(const bool debug) { mDebug = debug; }
 
 private:
  TFinterval mIntervals;       
  TimeInterval mTimeIntervals; 
  CalibVector mCalibs;         
  bool mDebug{false};          
 
  ClassDefOverride(IntegratedClusterCalibrator, 1);
};
 
} // end namespace calibration
} // end namespace o2
 
#endif