DeadChannelMapCreator.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_DeadChannelMapCreator_H_
#define ALICEO2_TPC_DeadChannelMapCreator_H_
 
#include <string_view>
#include <unordered_map>
#include <memory>
#include <string_view>
 
#include "Rtypes.h"
 
#include "CCDB/CcdbApi.h"
 
#include "DataFormatsTPC/Defs.h"
#include "TPCBase/CDBTypes.h"
#include "TPCBase/CalDet.h"
#include "TPCBase/FEEConfig.h"
 
namespace o2::tpc
{
 
enum class SourcesDeadMap : unsigned short {
  None = 0,                       
  IDCPadStatus = 1 << 0,          
  FEEConfig = 1 << 1,             
  All = IDCPadStatus | FEEConfig, 
};
inline SourcesDeadMap operator&(SourcesDeadMap a, SourcesDeadMap b) { return static_cast<SourcesDeadMap>(static_cast<unsigned short>(a) & static_cast<unsigned short>(b)); }
inline SourcesDeadMap operator~(SourcesDeadMap a) { return static_cast<SourcesDeadMap>(~static_cast<unsigned short>(a)); }
inline SourcesDeadMap operator|(SourcesDeadMap a, SourcesDeadMap b) { return static_cast<SourcesDeadMap>(static_cast<unsigned short>(a) | static_cast<unsigned short>(b)); }
 
struct FEEConfig;
 
class DeadChannelMapCreator
{
  struct ValidityRange {
    long startvalidity = 0;
    long endvalidity = -1;
    bool isValid(long ts) const { return ts < endvalidity && ts > startvalidity; }
  };
 
 public:
  using CalDetFlag_t = o2::tpc::CalDet<o2::tpc::PadFlags>;
 
  void reset();
 
  void init(std::string_view url = "");
  void load(long timeStampOrRun);
  void loadFEEConfigViaRunInfoTS(long timeStamp);
  void loadFEEConfigViaRunInfo(long timeStampOrRun);
  void loadFEEConfig(long timeStamp = -1);
  void loadIDCPadFlags(long timeStampOrRun);
 
  void setDeadChannelMapIDCPadStatus(const CalDetFlag_t& padStatusMap, PadFlags mask = PadFlags::flagAllNoneGood);
  void setDeadChannelMapFEEConfig(const FEEConfig& feeConfig) { mDeadChannelMapFEE = feeConfig.getDeadChannelMap(); }
 
  const CalDet<bool>& getDeadChannelMapIDC() const { return mDeadChannelMapIDC; }
  const CalDet<bool>& getDeadChannelMapFEE() const { return mDeadChannelMapFEE; }
  const CalDet<bool>& getDeadChannelMap() const { return mDeadChannelMap; }
 
  const FEEConfig* getFEEConfig() const { return mFEEConfig.get(); }
  const CalDetFlag_t* getPadFlags() const { return mPadStatusMap.get(); }
 
  void drawDeadChannelMapIDC();
  void drawDeadChannelMapFEE();
  void drawDeadChannelMap();
 
  long getTimeStamp(long timeStampOrRun) const;
 
  void finalizeDeadChannelMap();
  void resetDeadChannelMap() { mDeadChannelMap = false; }
 
  void setSource(SourcesDeadMap s) { mSources = s; }
  void addSource(SourcesDeadMap s) { mSources = s | mSources; }
  bool useSource(SourcesDeadMap s) const { return (mSources & s) == s; }
  SourcesDeadMap getSources() const { return mSources; }
 
 private:
  std::unique_ptr<FEEConfig> mFEEConfig;       
  std::unique_ptr<CalDetFlag_t> mPadStatusMap; 
  // FEEConfig::CalPadMapType* mPulserData;       ///< Pulser information
  // FEEConfig::CalPadMapType* mCEData;           ///< CE information
 
  std::unordered_map<CDBType, ValidityRange> mObjectValidity; 
  SourcesDeadMap mSources = SourcesDeadMap::All;              
  ccdb::CcdbApi mCCDBApi;                                     
  CalDet<bool> mDeadChannelMapIDC{"DeadChannelMapIDC"};       
  CalDet<bool> mDeadChannelMapFEE{"DeadChannelMapFEE"};       
  CalDet<bool> mDeadChannelMap{"DeadChannelMap"};             
 
  ClassDefNV(DeadChannelMapCreator, 0);
};
 
inline long DeadChannelMapCreator::getTimeStamp(long timeStampOrRun) const
{
  if (timeStampOrRun < 1000000) {
    // assume run number
    const auto c = mCCDBApi.retrieveHeaders("RCT/Info/RunInformation", {}, timeStampOrRun);
    timeStampOrRun = (std::stol(c.at("SOR")) + std::stol(c.at("EOR"))) / 2;
  }
 
  return timeStampOrRun;
}
 
} // namespace o2::tpc
 
#endif