CDBInterface.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_TPC_CDBInterface_H_
#define AliceO2_TPC_CDBInterface_H_
 
#include <memory>
#include <unordered_map>
#include <string_view>
 
#include "Framework/Logger.h"
#include "CCDB/BasicCCDBManager.h"
#include "CCDB/CcdbApi.h"
#include "TPCBase/CalDet.h"
#include "TPCBase/FEEConfig.h"
#include "TPCBase/CDBTypes.h"
#include "TPCBase/DeadChannelMapCreator.h"
#include "DataFormatsTPC/LtrCalibData.h"
#include "DataFormatsTPC/Defs.h"
#include "CommonUtils/NameConf.h"
 
namespace o2::tpc
{
// forward declarations
class ParameterDetector;
class ParameterElectronics;
class ParameterGas;
class ParameterGEM;
 
enum class CDBIntervention {
  Manual,    
  Automatic, 
};
 
const std::unordered_map<CDBIntervention, std::string> CDBInterventionMap{
  {CDBIntervention::Manual, "Manual"},
  {CDBIntervention::Automatic, "Automatic"},
};
 
class CDBInterface
{
 public:
  using CalPadMapType = std::unordered_map<std::string, CalPad>;
  using CalPadFlagType = CalDet<PadFlags>;
 
  CDBInterface(const CDBInterface&) = delete;
 
  static CDBInterface& instance()
  {
    static CDBInterface interface;
    return interface;
  }
 
  const CalPad& getPedestals();
 
  const CalPad& getPedestalsCRU();
 
  const CalPad& getNoise();
 
  const CalPad& getZeroSuppressionThreshold();
 
  const CalPad& getGainMap();
 
  const CalPad& getITFraction();
 
  const CalPad& getITExpLambda();
 
  const CalPad& getCMkValues();
 
  const CalPadFlagType& getPadFlags();
 
  const FEEConfig& getFEEConfig();
 
  DeadChannelMapCreator& getDeadChannelMapCreator() { return mDeadChannelMapCreator; }
 
  const CalDet<bool>& getDeadChannelMap();
  const ParameterDetector& getParameterDetector();
 
  const ParameterElectronics& getParameterElectronics();
 
  const ParameterGas& getParameterGas();
 
  const ParameterGEM& getParameterGEM();
 
  const CalPad& getCalPad(const std::string_view path);
 
  template <typename T>
  T& getSpecificObjectFromCDB(const std::string_view path, long timestamp = -1, const std::map<std::string, std::string>& metaData = std::map<std::string, std::string>());
 
  template <typename T>
  T& getObjectFromCDB(std::string_view path);
 
  void setPedestalsAndNoiseFromFile(const std::string_view fileName) { mPedestalNoiseFileName = fileName; }
 
  void setGainMapFromFile(const std::string_view fileName) { mGainMapFileName = fileName; }
 
  void setThresholdMapFromFile(const std::string_view fileName) { mFEEParamFileName = fileName; }
 
  void setFEEParamsFromFile(const std::string_view fileName) { mFEEParamFileName = fileName; }
 
  void setUseDefaults(bool defaults = true) { mUseDefaults = defaults; }
 
  bool getUseDefaults() const { return mUseDefaults; }
 
  void setTimeStamp(long time)
  {
    auto& cdb = o2::ccdb::BasicCCDBManager::instance();
    cdb.setTimestamp(time);
  }
 
  void setURL(const std::string_view url)
  {
    auto& cdb = o2::ccdb::BasicCCDBManager::instance();
    cdb.setURL(url.data());
    mDeadChannelMapCreator.init(url);
  }
 
  void setDefaultZSsigma(float zs)
  {
    mDefaultZSsigma = zs;
  }
 
  void resetLocalCalibration()
  {
    mPedestals.reset();
    mNoise.reset();
    mZeroSuppression.reset();
    mGainMap.reset();
  }
 
 private:
  CDBInterface();
 
  // ===| Pad calibrations |====================================================
  std::unique_ptr<CalPad> mPedestals;        
  std::unique_ptr<CalPad> mPedestalsCRU;     
  std::unique_ptr<CalPad> mNoise;            
  std::unique_ptr<CalPad> mZeroSuppression;  
  std::unique_ptr<CalPad> mGainMap;          
  std::unique_ptr<CalPad> mITFraction;       
  std::unique_ptr<CalPad> mITExpLambda;      
  std::unique_ptr<CalPad> mCMkValues;        
  std::unique_ptr<CalPadFlagType> mPadFlags; 
 
  std::unique_ptr<FEEConfig> mFEEConfig; 
 
  // ===| switches and parameters |=============================================
  bool mUseDefaults = false;   
  float mDefaultZSsigma = 3.f; 
 
  std::string mPedestalNoiseFileName;           
  std::string mGainMapFileName;                 
  std::string mFEEParamFileName;                
  DeadChannelMapCreator mDeadChannelMapCreator; 
 
  // ===========================================================================
  // ===| functions |===========================================================
  //
  void loadNoiseAndPedestalFromFile(); 
  void loadGainMapFromFile();          
  void loadFEEParamsFromFile();        
 
  void createDefaultPedestals();       
  void createDefaultNoise();           
  void createDefaultZeroSuppression(); 
  void createDefaultGainMap();         
  void createDefaultIonTailParams();   
  void createDefaultCMParams();        
  void createDefaultPadFlags();        
 
  void createFEEConfig(); 
};
 
template <typename T>
inline T& CDBInterface::getObjectFromCDB(std::string_view path)
{
  static auto& cdb = o2::ccdb::BasicCCDBManager::instance();
  auto* object = cdb.get<T>(path.data());
  if (!object) {
    LOGP(fatal, "Could not get {} from cdb", path);
  }
  return *object;
}
 
template <typename T>
inline T& CDBInterface::getSpecificObjectFromCDB(std::string_view path, long timestamp, const std::map<std::string, std::string>& metaData)
{
  static auto& cdb = o2::ccdb::BasicCCDBManager::instance();
  auto* object = cdb.getSpecific<T>(path.data(), timestamp, metaData);
  return *object;
}
 
template CalPad& CDBInterface::getSpecificObjectFromCDB(const std::string_view path, long timestamp, const std::map<std::string, std::string>& metaData);
template std::vector<CalPad>& CDBInterface::getSpecificObjectFromCDB(const std::string_view path, long timestamp, const std::map<std::string, std::string>& metaData);
template CDBInterface::CalPadMapType& CDBInterface::getSpecificObjectFromCDB(const std::string_view path, long timestamp, const std::map<std::string, std::string>& metaData);
template LtrCalibData& CDBInterface::getSpecificObjectFromCDB(const std::string_view path, long timestamp, const std::map<std::string, std::string>& metaData);
 
class CDBStorage
{
 public:
  using MetaData_t = std::map<std::string, std::string>;
  void setURL(std::string_view url)
  {
    mCCDB.init(url.data());
  }
 
  void clearMetaData()
  {
    mMetaData.clear();
  }
 
  void setResponsible(std::string_view responsible)
  {
    mMetaData["Responsible"] = responsible;
  }
 
  void setReason(std::string_view reason)
  {
    mMetaData["Reason"] = reason;
  }
 
  void setIntervention(CDBIntervention const intervention)
  {
    mMetaData["Intervention"] = CDBInterventionMap.at(intervention);
  }
 
  void setJIRA(std::string_view jira)
  {
    mMetaData["JIRA"] = jira;
  }
 
  void setComment(std::string_view comment)
  {
    mMetaData["Comment"] = comment;
  }
 
  void setRunNumber(int run)
  {
    mMetaData[o2::base::NameConf::CCDBRunTag.data()] = std::to_string(run);
  }
 
  const auto& getMetaData() const { return mMetaData; }
 
  std::string getMetaDataString() const;
 
  void setSimulate(bool sim = true) { mSimulate = sim; }
 
  bool getSimulate() const { return mSimulate; }
 
  template <typename T>
  void storeObject(T* obj, CDBType const type, MetaData_t const& metadata, long start, long end)
  {
    if (checkMetaData(metadata)) {
      if (!mSimulate) {
        mCCDB.storeAsTFileAny(obj, CDBTypeMap.at(type), metadata, start, end);
      }
      printObjectSummary(typeid(obj).name(), type, metadata, start, end);
    } else {
      LOGP(error, "Meta data not set properly, object will not be stored");
    }
  }
 
  template <typename T>
  void storeObject(T* obj, CDBType const type, long start, long end)
  {
    storeObject(obj, type, mMetaData, start, end);
  }
 
  void uploadNoiseAndPedestal(std::string_view fileName, long first = -1, long last = o2::ccdb::CcdbObjectInfo::INFINITE_TIMESTAMP);
  void uploadGainMap(std::string_view fileName, bool isFull = true, long first = -1, long last = o2::ccdb::CcdbObjectInfo::INFINITE_TIMESTAMP);
  void uploadPulserOrCEData(CDBType type, std::string_view fileName, long first = -1, long last = o2::ccdb::CcdbObjectInfo::INFINITE_TIMESTAMP);
  void uploadFEEConfigPad(std::string_view fileName, long first = -1, long last = o2::ccdb::CcdbObjectInfo::INFINITE_TIMESTAMP);
  void uploadTimeGain(std::string_view fileName, long first = -1, long last = o2::ccdb::CcdbObjectInfo::INFINITE_TIMESTAMP);
 
 private:
  bool checkMetaData(MetaData_t metaData) const;
  bool checkMetaData() const { return checkMetaData(mMetaData); }
  void printObjectSummary(std::string_view name, CDBType const type, MetaData_t const& metadata, long start, long end) const;
 
  o2::ccdb::CcdbApi mCCDB;
  MetaData_t mMetaData;
  bool mSimulate = false;
};
 
} // namespace o2::tpc
 
#endif