EMCALChannelData.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 CHANNEL_DATA_H_
#define CHANNEL_DATA_H_
 
#include "DetectorsCalibration/TimeSlotCalibration.h"
#include "DetectorsCalibration/TimeSlot.h"
// #include "CommonUtils/BoostHistogramUtils.h"
// #include "EMCALCalib/BadChannelMap.h"
// #include "EMCALCalib/TimeCalibrationParams.h"
#include "EMCALCalib/GainCalibrationFactors.h"
#include "EMCALCalib/EMCALChannelScaleFactors.h"
#include "EMCALCalibration/EMCALCalibExtractor.h"
#include "EMCALCalibration/EMCALCalibParams.h"
#include "DataFormatsEMCAL/Cell.h"
#include "EMCALBase/Geometry.h"
// #include "CCDB/CcdbObjectInfo.h"
 
// #include "Framework/Logger.h"
// #include "CommonUtils/MemFileHelper.h"
// #include "CCDB/CcdbApi.h"
// #include "DetectorsCalibration/Utils.h"
#include <boost/histogram.hpp>
#include <boost/histogram/ostream.hpp>
// #include <boost/format.hpp>
 
#include <thread>
 
// #include <array>
 
namespace o2
{
namespace emcal
{
class EMCALCalibExtractor;
 
class EMCALChannelData
{
  // using Slot = o2::calibration::TimeSlot<o2::emcal::EMCALChannelData>;
  using Cells = o2::emcal::Cell;
  using boostHisto = boost::histogram::histogram<std::tuple<boost::histogram::axis::regular<double, boost::use_default, boost::use_default, boost::use_default>, boost::histogram::axis::regular<double, boost::use_default, boost::use_default, boost::use_default>>>;
  using BadChannelMap = o2::emcal::BadChannelMap;
 
 public:
  // NCELLS includes DCal, treat as one calibration
  o2::emcal::Geometry* mGeometry = o2::emcal::Geometry::GetInstanceFromRunNumber(300000);
  int NCELLS = mGeometry->GetNCells();
 
  EMCALChannelData() : mNBins(EMCALCalibParams::Instance().nBinsEnergyAxis_bc), mRange(EMCALCalibParams::Instance().maxValueEnergyAxis_bc), mNBinsTime(EMCALCalibParams::Instance().nBinsTimeAxis_bc), mRangeTimeLow(EMCALCalibParams::Instance().rangeTimeAxisLow_bc), mRangeTimeHigh(EMCALCalibParams::Instance().rangeTimeAxisHigh_bc), mNThreads(EMCALCalibParams::Instance().nThreads_bc)
  {
 
    // NCELLS includes DCal, treat as one calibration
    o2::emcal::Geometry* mGeometry = o2::emcal::Geometry::GetInstanceFromRunNumber(300000);
    int NCELLS = mGeometry->GetNCells();
 
    mVecNEntriesInHisto.resize(mNThreads);
    mHisto.resize(mNThreads);
    mHistoTime.resize(mNThreads);
    for (size_t i = 0; i < mNThreads; ++i) {
      mHisto[i] = boost::histogram::make_histogram(boost::histogram::axis::regular<>(mNBins, 0., mRange), boost::histogram::axis::regular<>(NCELLS, -0.5, NCELLS - 0.5));
      mHistoTime[i] = boost::histogram::make_histogram(boost::histogram::axis::regular<>(mNBinsTime, mRangeTimeLow, mRangeTimeHigh), boost::histogram::axis::regular<>(NCELLS, -0.5, NCELLS - 0.5));
      mVecNEntriesInHisto[i] = 0;
    }
  }
 
  ~EMCALChannelData() = default;
 
  void PrintStream(std::ostream& stream) const;
  void print();
  void fill(const gsl::span<const o2::emcal::Cell> data);
  void merge(EMCALChannelData* prev);
  // int findBin(float v) const;
  bool hasEnoughData() const;
  const boostHisto& getHisto()
  {
    // set the summed histogram to one of the existing histograms
    mHistoSummed = mHisto[0];
    // reset the histogram
    mHistoSummed.reset();
    // Sum up all entries
    for (const auto& h : mHisto) {
      mHistoSummed += h;
    }
    return mHistoSummed;
  }
 
  void setHisto(boostHisto hist, int nthr = 0) { mHisto[nthr] = hist; }
 
  const boostHisto& getHistoTime()
  {
    mHistoTimeSummed = mHistoTime[0];
    mHistoTimeSummed.reset();
    for (const auto& h : mHistoTime) {
      mHistoTimeSummed += h;
    }
    return mHistoTimeSummed;
  }
 
  void setHistoTime(boostHisto hist, int nthr = 0) { mHistoTime[nthr] = hist; }
 
  void analyzeSlot();
 
  float getRange() const { return mRange; }
  void setRange(float r) { mRange = r; }
 
  int getNbins() const { return mNBins; }
  void setNbins(int nb) { mNBins = nb; }
 
  int getNEvents() const { return mEvents; }
  void setNEvents(int nevt) { mEvents = nevt; }
 
  long unsigned int getNEntriesInHisto() const { return mNEntriesInHisto; }
  void setNEntriesInHisto(long unsigned int n) { mNEntriesInHisto = n; }
  void addEntriesInHisto(long unsigned int n) { mNEntriesInHisto += n; }
 
  void setGainCalibFactors(o2::emcal::GainCalibrationFactors* calibFactors)
  {
    mGainCalibFactors = calibFactors;
    for (unsigned int i = 0; i < mArrGainCalibFactors.size(); ++i) {
      mArrGainCalibFactors[i] = mGainCalibFactors->getGainCalibFactors(i);
    }
    mApplyGainCalib = true;
  }
 
 private:
  float mRange = 10;                                    
  int mNBins = 1000;                                    
  size_t mNThreads = 1;                                 
  std::vector<boostHisto> mHisto;                       
  boostHisto mHistoSummed;                              
  int mNBinsTime = 1000;                                
  float mRangeTimeLow = -500;                           
  float mRangeTimeHigh = 500;                           
  std::vector<boostHisto> mHistoTime;                   
  boostHisto mHistoTimeSummed;                          
  int mEvents = 0;                                      
  long unsigned int mNEntriesInHisto = 0;               
  std::vector<long unsigned int> mVecNEntriesInHisto;   
  boostHisto mEsumHisto;                                
  boostHisto mEsumHistoScaled;                          
  boostHisto mCellAmplitude;                            
  bool mTest = false;                                   
  BadChannelMap mOutputBCM;                             
  bool mApplyGainCalib = false;                         
  o2::emcal::GainCalibrationFactors* mGainCalibFactors; 
  std::array<double, 17664> mArrGainCalibFactors;       
  std::shared_ptr<EMCALCalibExtractor> mCalibExtractor; 
 
  ClassDefNV(EMCALChannelData, 1);
};
std::ostream& operator<<(std::ostream& in, const EMCALChannelData& emcdata);
 
} // end namespace emcal
} // end namespace o2
 
#endif /*CHANNEL_DATA_H_ */