CalibDB.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 ALICEO2_EMCAL_CALIBDB
#define ALICEO2_EMCAL_CALIBDB
 
#include <exception>
#include <map>
#include <string>
#include "Rtypes.h"
#include "RStringView.h"
#include "CCDB/CcdbApi.h"
#include "CCDB/BasicCCDBManager.h"
 
namespace o2
{
 
namespace emcal
{
 
class BadChannelMap;
class TempCalibrationParams;
class TempCalibParamSM;
class TimeCalibrationParams;
class TimeCalibParamL1Phase;
class GainCalibrationFactors;
class EMCALChannelScaleFactors;
class FeeDCS;
class ElmbData;
class Pedestal;
 
class CalibDB
{
 
  using CcdbManager = o2::ccdb::BasicCCDBManager;
 
 public:
  class ObjectNotFoundException final : public std::exception
  {
   public:
    ObjectNotFoundException(const std::string_view server, const std::string_view path, const std::map<std::string, std::string>& metadata, ULong_t timestamp) : std::exception(),
                                                                                                                                                                 mServ(server),
                                                                                                                                                                 mPath(path),
                                                                                                                                                                 mMetaDat(metadata),
                                                                                                                                                                 mTimestamp(timestamp)
    {
      mMessage = "Not possible to access entry \"" + mPath + "\" on " + mServ + " for timestamp " + std::to_string(mTimestamp);
    }
 
    ~ObjectNotFoundException() noexcept final = default;
 
    const char* what() const noexcept final
    {
      return mMessage.data();
    }
 
    const std::map<std::string, std::string> getMetaData() const { return mMetaDat; }
 
    const std::string& getServer() const { return mServ; }
 
    const std::string& getPath() const { return mPath; }
 
    ULong_t getTimestamp() const { return mTimestamp; }
 
   private:
    const std::string mServ;                           
    const std::string mPath;                           
    std::string mMessage;                              
    const std::map<std::string, std::string> mMetaDat; 
    ULong_t mTimestamp;                                
  };
 
  class TypeMismatchException final : public std::exception
  {
   public:
    TypeMismatchException(const std::string_view obtained, const std::string_view expected) : std::exception(),
                                                                                              mTypeObtained(obtained),
                                                                                              mTypeExpected(expected),
                                                                                              mMessage()
    {
      mMessage = "Incorrect type, expected " + mTypeExpected + ", obtained " + mTypeObtained;
    }
 
    ~TypeMismatchException() noexcept final = default;
 
    const char* what() const noexcept final
    {
      return mMessage.data();
    }
 
    const std::string& getExpectedType() const { return mTypeExpected; }
 
    const std::string& getObtainedType() const { return mTypeObtained; }
 
   private:
    const std::string mTypeObtained; 
    const std::string mTypeExpected; 
    std::string mMessage;            
  };
 
  CalibDB() = default;
 
  CalibDB(const std::string_view server);
 
  ~CalibDB() = default;
 
  void storeBadChannelMap(BadChannelMap* bcm, const std::map<std::string, std::string>& metadata, ULong_t timestart, ULong_t timeend);
 
  BadChannelMap* readBadChannelMap(ULong_t timestamp, const std::map<std::string, std::string>& metadata);
 
  void storeTimeCalibParam(TimeCalibrationParams* tcp, const std::map<std::string, std::string>& metadata, ULong_t timestart, ULong_t timeend);
 
  TimeCalibrationParams* readTimeCalibParam(ULong_t timestamp, const std::map<std::string, std::string>& metadata);
 
  void storeTimeCalibParamL1Phase(TimeCalibParamL1Phase* tcp, const std::map<std::string, std::string>& metadata, ULong_t timestart, ULong_t timeend);
 
  TimeCalibParamL1Phase* readTimeCalibParamL1Phase(ULong_t timestamp, const std::map<std::string, std::string>& metadata);
 
  void storeTempCalibParam(TempCalibrationParams* tcp, const std::map<std::string, std::string>& metadata, ULong_t timestart, ULong_t timeend);
 
  TempCalibrationParams* readTempCalibParam(ULong_t timestamp, const std::map<std::string, std::string>& metadata);
 
  void storeTempCalibParamSM(TempCalibParamSM* tcp, const std::map<std::string, std::string>& metadata, ULong_t timestart, ULong_t timeend);
 
  TempCalibParamSM* readTempCalibParamSM(ULong_t timestamp, const std::map<std::string, std::string>& metadata);
 
  void storeGainCalibFactors(GainCalibrationFactors* gcf, const std::map<std::string, std::string>& metadata, ULong_t timestart, ULong_t timeend);
 
  GainCalibrationFactors* readGainCalibFactors(ULong_t timestamp, const std::map<std::string, std::string>& metadata);
 
  EMCALChannelScaleFactors* readChannelScaleFactors(ULong_t timestamp, const std::map<std::string, std::string>& metadata);
 
  void storeFeeDCSData(FeeDCS* dcs, const std::map<std::string, std::string>& metadata, ULong_t timestart, ULong_t timeend);
 
  FeeDCS* readFeeDCSData(ULong_t timestamp, const std::map<std::string, std::string>& metadata);
 
  void storeTemperatureSensorData(ElmbData* dcs, const std::map<std::string, std::string>& metadata, ULong_t timestart, ULong_t timeend);
 
  ElmbData* readTemperatureSensorData(ULong_t timestamp, const std::map<std::string, std::string>& metadata);
 
  void storePedestalData(Pedestal* pedestals, const std::map<std::string, std::string>& metadata, ULong_t timestart, ULong_t timeend);
 
  Pedestal* readPedestalData(ULong_t timestamp, const std::map<std::string, std::string>& metadata);
 
  void setServer(const std::string_view server)
  {
    mCCDBServer = server;
    mInit = false;
  }
 
  static const char* getCDBPathBadChannelMap() { return "EMC/Calib/BadChannelMap"; }
 
  static const char* getCDBPathTimeCalibrationParams() { return "EMC/Calib/TimeCalibParams"; }
 
  static const char* getCDBPathL1Phase() { return "EMC/Calib/TimeCalibParamsL1Phase"; }
 
  static const char* getCDBPathTemperatureCalibrationParams() { return "EMC/Calib/TempCalibParams"; }
 
  static const char* getCDBPathTemperatureCalibrationParamsSM() { return "EMC/Calib/TempCalibParamsSM"; }
 
  static const char* getCDBPathGainCalibrationParams() { return "EMC/Calib/GainCalibFactors"; }
 
  static const char* getCDBPathFeeDCS() { return "EMC/Calib/FeeDCS"; }
 
  static const char* getCDBPathTemperatureSensor() { return "EMC/Calib/Temperature"; }
 
  static const char* getCDBPathChannelScaleFactors() { return "EMC/Config/ChannelScaleFactors"; }
 
  static const char* getCDBPathChannelPedestals() { return "EMC/Calib/Pedestal"; }
 
 private:
  void
    init();
 
  ccdb::CcdbApi mCCDBManager;                       
  std::string mCCDBServer = "emcccdb-test.cern.ch"; 
  Bool_t mInit = false;                             
 
  ClassDefNV(CalibDB, 2);
};
} // namespace emcal
 
} // namespace o2
 
#endif