CalibLoader.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 O2_EMCAL_CALIBLOADER
#define O2_EMCAL_CALIBLOADER
 
#include <bitset>
#include <vector>
#include <Framework/ProcessingContext.h>
#include "Framework/ConcreteDataMatcher.h"
#include "Framework/InputSpec.h"
 
namespace o2
{
 
namespace emcal
{
class BadChannelMap;
class FeeDCS;
class EMCALChannelScaleFactors;
class TimeCalibrationParams;
class GainCalibrationFactors;
class TempCalibrationParams;
class SimParam;
class RecoParam;
 
class CalibLoader
{
 public:
  CalibLoader() = default;
 
  ~CalibLoader() = default;
 
  BadChannelMap* getBadChannelMap() const { return mBadChannelMap; }
 
  EMCALChannelScaleFactors* getBCMScaleFactors() const { return mBCMScaleFactors; }
 
  FeeDCS* getFEEDCS() const { return mFeeDCS; }
 
  TimeCalibrationParams* getTimeCalibration() const { return mTimeCalibParams; }
 
  GainCalibrationFactors* getGainCalibration() const { return mGainCalibParams; }
 
  TempCalibrationParams* getTemperatureCalibration() const { return mTempCalibParams; }
 
  bool hasBadChannelMap() const { return mEnableStatus.test(OBJ_BADCHANNELMAP); }
 
  bool hasBCMScaleFactors() const { return mEnableStatus.test(OBJ_BCMSCALEFACTORS); }
 
  bool hasFEEDCS() const { return mEnableStatus.test(OBJ_FEEDCS); }
 
  bool hasTimeCalib() const { return mEnableStatus.test(OBJ_TIMECALIB); }
 
  bool hasGainCalib() const { return mEnableStatus.test(OBJ_GAINCALIB); }
 
  bool hasTemperatureCalib() const { return mEnableStatus.test(OBJ_TEMPCALIB); }
 
  bool hasRecoParams() const { return mEnableStatus.test(OBJ_RECOPARAM); }
 
  bool hasSimParams() const { return mEnableStatus.test(OBJ_SIMPARAM); }
 
  bool hasUpdateBadChannelMap() const { return mUpdateStatus.test(OBJ_BADCHANNELMAP); }
 
  bool hasUpdateBCMScaleFactors() const { return mUpdateStatus.test(OBJ_BCMSCALEFACTORS); }
 
  bool hasUpdateFEEDCS() const { return mUpdateStatus.test(OBJ_FEEDCS); }
 
  bool hasUpdateTimeCalib() const { return mUpdateStatus.test(OBJ_TIMECALIB); }
 
  bool hasUpdateGainCalib() const { return mUpdateStatus.test(OBJ_GAINCALIB); }
 
  bool hasUpdateTemperatureCalib() const { return mUpdateStatus.test(OBJ_TEMPCALIB); }
 
  bool hasUpdateRecoParam() const { return mUpdateStatus.test(OBJ_RECOPARAM); }
 
  bool hasUpdateSimParam() const { return mUpdateStatus.test(OBJ_SIMPARAM); }
 
  void enableBadChannelMap(bool doEnable) { mEnableStatus.set(OBJ_BADCHANNELMAP, doEnable); }
 
  void enableBCMScaleFactors(bool doEnable) { mEnableStatus.set(OBJ_BCMSCALEFACTORS, doEnable); }
 
  void enableFEEDCS(bool doEnable) { mEnableStatus.set(OBJ_FEEDCS, doEnable); }
 
  void enableTimeCalib(bool doEnable) { mEnableStatus.set(OBJ_TIMECALIB, doEnable); }
 
  void enableGainCalib(bool doEnable) { mEnableStatus.set(OBJ_GAINCALIB, doEnable); }
 
  void enableTemperatureCalib(bool doEnable) { mEnableStatus.set(OBJ_TEMPCALIB, doEnable); }
 
  void enableRecoParams(bool doEnable) { mEnableStatus.set(OBJ_RECOPARAM, doEnable); }
 
  void enableSimParams(bool doEnable) { mEnableStatus.set(OBJ_SIMPARAM, doEnable); }
 
  void setUpdateBadChannelMap() { mUpdateStatus.set(OBJ_BADCHANNELMAP, true); }
 
  void setUpdateBCMScaleFactors() { mUpdateStatus.set(OBJ_BCMSCALEFACTORS, true); }
 
  void setUpdateFEEDCS() { mUpdateStatus.set(OBJ_FEEDCS, true); }
 
  void setUpdateTimeCalib() { mUpdateStatus.set(OBJ_TIMECALIB, true); }
 
  void setUpdateGainCalib() { mUpdateStatus.set(OBJ_GAINCALIB, true); }
 
  void setUpdateTemperatureCalib() { mUpdateStatus.set(OBJ_TEMPCALIB, true); }
 
  void setUpdateRecoParams() { mUpdateStatus.set(OBJ_RECOPARAM, true); }
 
  void setUpdateSimParams() { mUpdateStatus.set(OBJ_SIMPARAM, true); }
 
  void resetUpdateStatus() { mUpdateStatus.reset(); }
 
  void defineInputSpecs(std::vector<framework::InputSpec>& ccdbInputs);
 
  void checkUpdates(o2::framework::ProcessingContext& ctx);
 
  bool finalizeCCDB(framework::ConcreteDataMatcher& matcher, void* obj);
 
 private:
  enum CalibObject_t {
    OBJ_BADCHANNELMAP,   
    OBJ_TIMECALIB,       
    OBJ_GAINCALIB,       
    OBJ_TEMPCALIB,       
    OBJ_TIMSLEWINGCORR,  
    OBJ_BCMSCALEFACTORS, 
    OBJ_FEEDCS,          
    OBJ_SIMPARAM,        
    OBJ_RECOPARAM,       
    OBJ_CALIBPARAM       
  };
  o2::emcal::BadChannelMap* mBadChannelMap = nullptr;              
  o2::emcal::FeeDCS* mFeeDCS = nullptr;                            
  o2::emcal::TimeCalibrationParams* mTimeCalibParams = nullptr;    
  o2::emcal::GainCalibrationFactors* mGainCalibParams = nullptr;   
  o2::emcal::TempCalibrationParams* mTempCalibParams = nullptr;    
  o2::emcal::EMCALChannelScaleFactors* mBCMScaleFactors = nullptr; 
  o2::emcal::RecoParam* mRecoParam;                                
  o2::emcal::SimParam* mSimParam;                                  
  std::bitset<16> mEnableStatus;                                   
  std::bitset<16> mUpdateStatus;                                   
};
 
} // namespace emcal
 
} // namespace o2
 
#endif //  O2_EMCAL_CALIBLOADER