TileCalibDrawerOfc.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TILECALIBDRAWEROFC_H
#define TILECALIBDRAWEROFC_H

 
#include "TileCalibBlobObjs/TileCalibDrawerBase.h"
#include "TileCalibBlobObjs/TileCalibType.h"
#include "TileCalibBlobObjs/TileCalibUtils.h"
#include "CoralBase/Blob.h"
#include <iosfwd>
#include <vector>
#include <cstdint>
#include <cmath>
#include <string>
#include <cstring> //std::memcpy, std::memset
 
#define PHASE_PRECISION 0.1
 
class TileCalibDrawerOfc : public TileCalibDrawerBase {
 
 public:

  enum FIELD{FieldA = 0, FieldB = 1, FieldG = 2, FieldC = 3, FieldDG = 4};

  virtual ~TileCalibDrawerOfc(){}

  virtual uint16_t getType()const {return TileCalibType::OFC;} 

  static TileCalibDrawerOfc* getInstance(coral::Blob&         blob
                                         , uint16_t           objVersion
                                         , uint32_t           nSamples
                                         , int32_t            nPhases
                                         , uint16_t           nChans
                                         , uint16_t           nGains
                                         , std::string_view author = ""
                                         , std::string_view comment = ""
                                         , uint64_t           timeStamp = 0);

  static const TileCalibDrawerOfc* getInstance(const coral::Blob& blob);
  
 
  //==================================================================
  //== Accessors to extra header fields
  //==================================================================
  uint32_t getNSamples() const;
  int32_t getNPhases() const;
  float getPhase(unsigned int channel, unsigned int adc, unsigned int phaseIdx) const;
  uint32_t getNFields(uint16_t objVersion = 0) const;
  
  //==================================================================
  //== Accessors to OFC data
  //==================================================================

  float  getOfc(unsigned int field, unsigned int channel, unsigned int adc, float phase, unsigned int sample) const;

  void fillOfc (unsigned int channel,unsigned int adc, float& phase, float* w_a, float* w_b, float* w_c, float* g, float* dg ) const;
 

  virtual void dump() const;
  virtual void dump(std::ostream& stm) const;
  
  //==================================================================
  //== Setter methods
  //==================================================================
  void init(uint16_t objVersion
            , uint32_t nSamples
            , int32_t  nPhases
            , uint16_t nChans
            , uint16_t nGains
            , std::string_view author=""
            , std::string_view comment=""
            , uint64_t timeStamp=0);
  
  void setOfc(unsigned int field, unsigned int channel, unsigned int adc, float phase, unsigned int sample, float value);
  
  void setPhases(unsigned int channel, unsigned int adc, const std::vector<float>& phases); 
  
 protected:
  TileCalibDrawerOfc(const coral::Blob& blob);
  TileCalibDrawerOfc(coral::Blob& blob);
  
 private:
  void initCheck();

  const float* getOfcStartAddress(unsigned int field, unsigned int channel, unsigned int adc, float& phase) const;
       float* getOfcStartAddress(unsigned int field, unsigned int channel, unsigned int adc, float& phase);
 
  unsigned int getOfcStartOffset(unsigned int field, unsigned int channel, unsigned int adc, float& phase) const;

  const int32_t* getPhaseStartAddress(unsigned int channel, unsigned int adc, unsigned int phaseIdx) const;
       int32_t* getPhaseStartAddress(unsigned int channel, unsigned int adc, unsigned int phaseIdx);
 
  unsigned int getPhaseStartOffset(unsigned int channel, unsigned int adc, unsigned int phaseIdx) const;

  unsigned int getPhaseNumber(unsigned int channel, unsigned int adc, float& phase) const;
};
 
//
//______________________________________________________________
__attribute__((always_inline)) 
inline uint32_t TileCalibDrawerOfc::getNSamples() const {
  return *(static_cast<const uint32_t*>(getAddress(0)));
}
 
//
//______________________________________________________________
__attribute__((always_inline)) 
inline int32_t TileCalibDrawerOfc::getNPhases() const {
  return *(static_cast<const int32_t*>(getAddress(1)));
}
 
//
//______________________________________________________________
__attribute__((always_inline)) 
inline unsigned int TileCalibDrawerOfc::getPhaseNumber(unsigned int channel, unsigned int adc, float& phase) const {
 
  if (std::abs(phase) > 1e6F) {
    // Bad phase is requested (probably, bad value is in the DB)
    phase = 0.0F;
  }
  int db_phase = (int) std::round(phase * (1 / PHASE_PRECISION)); // Phases are stored as int(10*phase) in DB
  const int32_t* beg = getPhaseStartAddress(channel, adc, 0);
  const int32_t* end = beg + std::abs(getNPhases());
  const int32_t* pos = std::lower_bound(beg, end, db_phase);
 
  if (pos == end || (*pos != db_phase && pos != beg && (*pos - db_phase) > (db_phase - *(pos - 1)))) {
    --pos;
  }
 
  phase = *pos * PHASE_PRECISION;
  return (pos - beg);
}
 
//
//______________________________________________________________
__attribute__((always_inline)) 
inline float TileCalibDrawerOfc::getPhase(unsigned int channel, unsigned int adc, unsigned int phaseIdx) const {
  return *(getPhaseStartAddress(channel, adc, phaseIdx)) * PHASE_PRECISION; // Phases are stored as int(10*phase) in DB
}
 
//
//______________________________________________________________
__attribute__((always_inline)) 
inline uint32_t TileCalibDrawerOfc::getNFields(uint16_t objVersion) const {
  //=== determine objVersion from Blob if default is passed
  if(objVersion==0) objVersion = getObjVersion();
 
  if(     objVersion == 3){ return 5; }
  else if(objVersion == 2){ return 4; }
  else if(objVersion == 1){ return 3; }
  else{ 
    throw TileCalib::VersionConflict("TileCalibDrawerOfc::getNFields", objVersion); 
  }
}
 
//
//______________________________________________________________
inline float TileCalibDrawerOfc::getOfc(unsigned int field, unsigned int channel, unsigned int adc
                                        , float phase, unsigned int sample) const {
  if(sample >= getNSamples())
    throw TileCalib::IndexOutOfRange("TileCalibDrawerOfc::getA", sample, getNSamples());
  return getOfcStartAddress(field, channel, adc, phase)[sample];
}
 
inline void TileCalibDrawerOfc::fillOfc (unsigned int channel,unsigned int adc, float& phase
                                         , float* w_a, float* w_b, float* w_c, float* g, float* dg) const {
 
 
  const float* startAddress = getOfcStartAddress(TileCalibDrawerOfc::FieldA, channel, adc, phase);
  size_t allSamplesSize = getNSamples() * sizeof(float); 
  size_t fieldSize = getObjSizeUint32() * getNSamples();
 
  std::memcpy(w_a, startAddress, allSamplesSize);
  startAddress += fieldSize;
  std::memcpy(w_b, startAddress, allSamplesSize);
  startAddress += fieldSize;
  std::memcpy(g, startAddress, allSamplesSize);
  startAddress += fieldSize;
  std::memcpy(w_c, startAddress, allSamplesSize);
  if (getNFields() > 4) {
    startAddress += fieldSize;
    std::memcpy(dg, startAddress, allSamplesSize);
  } else {
    std::memset(dg, 0, allSamplesSize);
  }
}
 
 
//
//______________________________________________________________
inline void TileCalibDrawerOfc::setOfc(unsigned int field,unsigned int channel, unsigned int adc
                                       , float phase, unsigned int sample, float value) {
  if(sample >= getNSamples())
    throw TileCalib::IndexOutOfRange("TileCalibDrawerOfc::setOfc", sample, getNSamples());
  getOfcStartAddress(field, channel, adc, phase)[sample] = value;
}
 
//
//______________________________________________________________
__attribute__((always_inline)) 
inline unsigned int TileCalibDrawerOfc::getPhaseStartOffset(unsigned int channel, unsigned int adc, unsigned int phaseIdx) const
{
  if(phaseIdx >= static_cast<unsigned int>(std::abs(getNPhases()))){
    throw TileCalib::IndexOutOfRange("TileCalibDrawerOfc::getPhaseStartAddress", phaseIdx, std::abs(getNPhases()));
  }
  //=== use only one phase table for all ADCs
  if(getNPhases() < 0){
    channel = 0;
    adc = 0;
  }
  //=== check for out of bounds channel, adc
  if(channel > getNChans())
    throw TileCalib::IndexOutOfRange("TileCalibDrawerOfc::getPhaseStartAddress", channel, getNChans());
  if(adc > getNGains())
    throw TileCalib::IndexOutOfRange("TileCalibDrawerOfc::getPhaseStartAddress", adc, getNGains());
 
  //=== extra header
  unsigned int offset = 2;
  unsigned int nPhases = std::abs(getNPhases());
  offset += channel * nPhases * getNGains() + adc * nPhases + phaseIdx;
  return offset;
}
 
//
//______________________________________________________________
__attribute__((always_inline)) 
inline const int32_t* TileCalibDrawerOfc::getPhaseStartAddress(unsigned int channel, unsigned int adc, unsigned int phaseIdx) const
{
  return static_cast<const int32_t*>(getAddress(getPhaseStartOffset(channel, adc, phaseIdx)));
}
 
//
//______________________________________________________________
__attribute__((always_inline)) 
inline int32_t* TileCalibDrawerOfc::getPhaseStartAddress(unsigned int channel, unsigned int adc, unsigned int phaseIdx)
{
  return static_cast<int32_t*>(getAddress(getPhaseStartOffset(channel, adc, phaseIdx)));
}
 
//
//______________________________________________________________
__attribute__((always_inline)) 
inline unsigned int TileCalibDrawerOfc::getOfcStartOffset(unsigned int field, unsigned int channel, unsigned int adc, float& phase) const
{
  //=== check default policy
 
  if(channel >= getNChans()) {
    if (channel <= TileCalibUtils::MAX_CHAN) {
      channel = 0;
    } else {
      channel = channel % TileCalibUtils::MAX_CHAN;
      if (channel >= getNChans()) channel = 0;
    }
  }
 
 
  if(adc >= getNGains()) {adc = 0;}
  
  //=== this calculation is only valid for a blob layout according 
  //=== to version 1 or version 2
  uint16_t objVer = getObjVersion();  
  if(objVer!=1 && objVer!=2 && objVer!=3){ 
    throw TileCalib::VersionConflict("TileCalibDrawerOfc::getOfcStartAddress", objVer);
  }
  
  //=== number of fields:
  //=== for Version 1 = OFC1 we have 3 fields: ai, bi, gi
  //=== for Version 2 = OFC2 we have 4 fields: ai, bi, gi, ci
  //=== for Version 3 = OFC2 we have 5 fields: ai, bi, gi, ci, dgi
  unsigned int nField = getNFields(objVer);
  if(field >= nField){
    throw TileCalib::IndexOutOfRange("TileCalibDrawerOfc::getOfcStartAddress", field, nField);
  }
  
  //=== calculate the offset
  //=== first get rid of ofc specific header
  unsigned int nPhaseAbs = std::abs(getNPhases());
  int          nPhaseSgn = getNPhases() < 0 ? -1 : 1; 
  unsigned int offset = 2;
  if(nPhaseSgn < 0) { offset += nPhaseAbs;                             }
  else              { offset += nPhaseAbs * getNChans() * getNGains(); }
 
  //=== add offset for requested field
  unsigned int iPhase  = getPhaseNumber(channel, adc, phase);
  unsigned int nGain   = getNGains();
  unsigned int nSample = getNSamples(); 
  unsigned int lPhase  = nSample * nField;
  unsigned int lAdc    = lPhase * nPhaseAbs;
  unsigned int lChan   = lAdc * nGain;
  offset += channel * lChan + adc * lAdc + iPhase * lPhase + field * nSample;
  
  return offset;
}
 
//
//______________________________________________________________
__attribute__((always_inline)) 
inline const float* TileCalibDrawerOfc::getOfcStartAddress(unsigned int field, unsigned int channel, unsigned int adc, float& phase) const
{
  return static_cast<const float*>(getAddress(getOfcStartOffset(field, channel, adc, phase)));
}
 
//
//______________________________________________________________
__attribute__((always_inline)) 
inline float* TileCalibDrawerOfc::getOfcStartAddress(unsigned int field, unsigned int channel, unsigned int adc, float& phase)
{
  return static_cast<float*>(getAddress(getOfcStartOffset(field, channel, adc, phase)));
}
 
#endif