TileCondProxyFile.icc

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
 
// Tile includes
#include "TileConditions/TileCondProxyFile.h"
#include "TileCalibBlobObjs/TileCalibDrawerFlt.h"
#include "TileCalibBlobObjs/TileCalibDrawerBch.h"
#include "TileCalibBlobObjs/TileCalibDrawerInt.h"
#include "TileCalibBlobObjs/TileBchDecoder.h"
#include "TileCalibBlobObjs/TileCalibUtils.h"
 
#include "PathResolver/PathResolver.h"
 
#include "CoralBase/Blob.h"
 
#include <fstream>
 
 
//
//____________________________________________________________________
template<typename T>
TileCondProxyFile<T>::TileCondProxyFile(const std::string& type, const std::string& name,
    const IInterface* parent)
    : AthAlgTool(type, name, parent)
    , m_source("")
{
  declareInterface<ITileCondProxy<T> >(this);
  declareProperty("Source", m_source = "", "The ASCII file to read");
}
 
//
//_____________________________________________________________________________
template<typename T>
StatusCode TileCondProxyFile<T>::initialize() {
 
  return StatusCode::SUCCESS;
}
 
 
template<typename T>
StatusCode TileCondProxyFile<T>::fillCalibData(TileCalibData<T>& calibData,
                                               EventIDRange& eventRange) const {
 
 //=== file name needs to be set to read correct defaults
  if (!m_source.size()) {
    ATH_MSG_ERROR( name() << ": Empty file name detected, initialization not possible." );
    return StatusCode::FAILURE;
  }
 
  //=== Try to resolve file location
  std::string fileName = PathResolver::find_file(m_source, "DATAPATH");
  if (!fileName.size()) {
    ATH_MSG_ERROR( name() << ": Could not find file \"" << m_source << "\"" );
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_INFO( "Creating TileCondProxyFile(" << name()
               << ") for ASCII file name: \"" << fileName << "\"" );
 
 
  //=== Open input file
  std::ifstream file(fileName.c_str());
  if (!file.is_open()) {
    ATH_MSG_ERROR( ": Could not open file \"" << fileName << "\"" );
    return StatusCode::FAILURE;
  }
 
 
  //========================================================
 
  //=== loop through the file and fill data maps
  //========================================================
  std::map<unsigned int, unsigned int> drawerStat;
  DataMap dataMap;
  int dataVecSize(-1);
  int objVersion(-1);
  std::string line;
  while (std::getline(file, line)) {
 
    //=== read the objVersion specifier
    if (line.starts_with( "OBJVERSION") && objVersion < 0) {
      std::istringstream iss(line);
      std::string dummy;
      iss >> dummy >> objVersion;
      ATH_MSG_DEBUG( "Found objVersion: " << objVersion );
      continue;
    }
 
    //=== Ensure that we have a data line starting
    //=== with '0x' for the fragmentID in hex
    std::string::size_type lineId = line.find("0x", 0);
    if (lineId == std::string::npos || lineId > 0) {
      continue;
    }
 
    //=== read data line
    std::istringstream iss(line);
    unsigned int frag, channel, gain;
    iss >> std::hex >> frag >> std::dec >> channel >> std::dec >> gain;
    unsigned int drawerIdx = TileCalibUtils::getDrawerIdxFromFragId(frag);
 
    //=== some sanity checks
    if (drawerIdx >= TileCalibUtils::MAX_DRAWERIDX) {
      ATH_MSG_ERROR( "Detected invalid drawer index in file \""
                    << fileName << "\": " << std::hex << frag );
      return StatusCode::FAILURE;
    }
 
 
    //=== Mark module as affected
    {
      unsigned int& stat = drawerStat[drawerIdx];
      stat = std::max(stat, channel);
    }
 
    //=== Loop through all data rows
    DataVec dataVec;
    typename DataVec::value_type value;
    while (iss >> std::skipws >> value) {
      dataVec.push_back(value);
    }
 
    //=== ensure that all dataVec have the same length
    if (dataVecSize < 0) {
      dataVecSize = dataVec.size();
    }
 
    if (dataVecSize != static_cast<int>(dataVec.size())) {
      ATH_MSG_ERROR( "Inconsistent number of data elements in \"" << fileName << "\". " );
      ATH_MSG_ERROR( "The offending line is: " << line );
      return StatusCode::FAILURE;
    }
 
    //=== Save dataVector in map
    dataMap[std::make_tuple(drawerIdx, channel, gain)] = std::move(dataVec);
 
  } // End loop over file
 
  file.close();
 
  //==== Check that objVersion is specified
  if (objVersion < 0) {
    ATH_MSG_ERROR( "No OBJVERSION specified in file \"" << fileName << "\"" );
    return StatusCode::FAILURE;
  }
 
  //==== Check that global detector default (drawerIdx=0) is specified
  if (drawerStat.find(0) == drawerStat.end()) {
    ATH_MSG_ERROR( "No global default (fragId=0x000) specified in file \"" << fileName << "\"" );
    return StatusCode::FAILURE;
  }
 
  //====================================================
  //=== Initialize drawers, following the default policy
  //=== implemented in TileCalibUtils::getDefaultDrawerIdx()
  //====================================================
  for (unsigned int drawerIdx = 0; drawerIdx < TileCalibUtils::MAX_DRAWERIDX; ++drawerIdx) {
 
      //=== if no data for drawer, link to default drawer...
      if (drawerStat.find(drawerIdx) == drawerStat.end()) {
 
        unsigned int defaultDrawerIdx = TileCalibUtils::getDefaultDrawerIdx(drawerIdx);
        calibData.setCalibDrawer(drawerIdx, calibData.getCalibDrawer(defaultDrawerIdx));
 
        ATH_MSG_VERBOSE( "Using default drawer " << defaultDrawerIdx
                         << " for drawerIdx=" << drawerIdx << endmsg
                         << "... i.e. TileCalibDrawer @ " << calibData.getCalibDrawer(drawerIdx));
 
        continue;
      }
 
      unsigned int nChannels = drawerStat[drawerIdx] + 1;
 
      calibData.setCalibDrawer(drawerIdx, createCalibDrawer(drawerIdx, nChannels, objVersion, dataMap).release());
 
  }  // End drawerIdx
 
 
  eventRange = EventIDRange{
    EventIDBase{0, // Run number
                EventIDBase::UNDEFEVT,
                EventIDBase::UNDEFNUM,
                EventIDBase::UNDEFNUM,
                0}, // Lumi block
    EventIDBase{EventIDBase::UNDEFNUM - 1, // Run number
                EventIDBase::UNDEFEVT,
                EventIDBase::UNDEFNUM,
                EventIDBase::UNDEFNUM,
                EventIDBase::UNDEFNUM - 1} // Lumi block
  };
 
  return StatusCode::SUCCESS;
 
}
 
 
//
//_____________________________________________________________________________
template<typename T>
std::unique_ptr<const T> TileCondProxyFile<T>::createCalibDrawer(unsigned int drawerIdx,
                                                                 unsigned int nChannels,
                                                                 unsigned int objVers,
                                                                 const DataMap& dataMap) const {
  //=== Prepare vector with defaults
  //--- Low gain is always there
  typename T::DefType defaultVec;
 
  unsigned int gain(0);
 
  typename TileCondProxyFile::DataMap::const_iterator iDataMap = dataMap.find(std::make_tuple(drawerIdx, 0, gain));
  while (iDataMap != dataMap.end()) {
    defaultVec.push_back(iDataMap->second);
    ++gain;
    iDataMap = dataMap.find(std::make_tuple(drawerIdx, 0, gain));
  }
 
  unsigned int nGains(gain);
 
  //=== create the calibDrawer
  std::unique_ptr<coral::Blob> blob = std::make_unique<coral::Blob>(0);
  std::unique_ptr<T> tmpCalibDrawer(T::getInstance(*blob,
                                                   defaultVec,
                                                   nChannels,
                                                   objVers));
  // Trick to make calib drawer to own blob
  std::unique_ptr<T> calibDrawer = std::make_unique<T>(*tmpCalibDrawer);
 
  //=== fill calibDrawer with settings in dataMap
  for (unsigned int channel = 0; channel < nChannels; ++channel) {
    for (unsigned int adc = 0; adc < nGains; ++adc) {
      iDataMap = dataMap.find(std::make_tuple(drawerIdx, channel, adc));
      if (iDataMap != dataMap.end()) {
        calibDrawer->setData(channel, adc, iDataMap->second);
      }
    }
  }
 
  return calibDrawer;
}
 
//
//_____________________________________________________________________________
template<>
std::unique_ptr<const TileCalibDrawerBch> TileCondProxyFile<TileCalibDrawerBch>::createCalibDrawer(unsigned int drawerIdx,
                                                                                                   unsigned int nChannels,
                                                                                                   unsigned int objVers,
                                                                                                   const DataMap& dataMap) const {
  //-------------------------------------------------------------------------------
  //--- Observed special case for TileCalibDrawerBch, which always expects 3 gains:
  //--- 0=low gain, 1=high gain, 2=common channel problems!
  //--- However, in the file format only up to 2 gains can be encoded.
  //--- Therefore the convention is assumed that the words for the three gains are
  //--- all listed under gain 0 in the file.
  //-------------------------------------------------------------------------------
 
  //=== prepare vector with defaults (no bad channels)
  TileCalibDrawerBch::DefType defaultVec{{0}, {0}, {0}};
 
  //=== create the calibDrawer
  std::unique_ptr<coral::Blob> blob = std::make_unique<coral::Blob>(0);
  TileBchDecoder::BitPatVer bitPatVer = static_cast<TileBchDecoder::BitPatVer>(objVers);
  std::unique_ptr<TileCalibDrawerBch> tmpCalibDrawer(TileCalibDrawerBch::getInstance(*blob,
                                                                                     defaultVec,
                                                                                     nChannels,
                                                                                     bitPatVer));
  // Trick to make calib drawer to own blob
  std::unique_ptr<TileCalibDrawerBch> calibDrawer = std::make_unique<TileCalibDrawerBch>(*tmpCalibDrawer);
 
 
  //=== fill calibDrawer with settings in dataMap
  for (unsigned int channel = 0; channel < nChannels; ++channel) {
    TileCondProxyFile::DataMap::const_iterator iDataMap = dataMap.find( std::make_tuple(drawerIdx, channel, 0));
    if (iDataMap != dataMap.end()) {
      const DataVec& dataVec = iDataMap->second;
      for (unsigned int idx = 0; idx < dataVec.size(); ++idx) {
        float data = dataVec[idx];
        calibDrawer->setData(channel, idx, 0, static_cast<uint32_t>(data > 0. ? data + 0.5 : data - 0.5));
      }
    }
  }
 
  return calibDrawer;
}
 
//
//_____________________________________________________________________________
template<typename T>
StatusCode TileCondProxyFile<T>::finalize() {
 
  ATH_MSG_DEBUG( "finalize called for " << name() );
  return StatusCode::SUCCESS;
}