TileCalibDrawerDat.h

Go to the documentation of this file.

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

 
#include "TileCalibBlobObjs/TileCalibDrawerBase.h"
#include "TileCalibBlobObjs/TileCalibType.h"
#include "TileCalibBlobObjs/TileCalibUtils.h"
#include <stdint.h>
#include <vector>
#include <iostream>
#include "CoralBase/Blob.h"
 
template<class T>
class TileCalibDrawerDat : public TileCalibDrawerBase
{
 public:
  typedef std::vector<std::vector<T> > DefType;
  
  virtual ~TileCalibDrawerDat(){}
  
  //==================================================================
  //== Data getter and setter methods
  //==================================================================
  T getData(unsigned int channel, unsigned int adc, unsigned int idx) const;
  
  void init(const DefType& def, 
        uint16_t nChans,
        uint16_t objVers,
        const std::string& author="",
        const std::string& comment="",
        uint64_t timeStamp=0);
  
  void setData(unsigned int channel, unsigned int adc, unsigned int idx, T data);
  
  void setData(unsigned int channel, unsigned int adc, const std::vector<T>& data);
  
  
  virtual void dump() const { dump(std::cout); }
  virtual void dump(std::ostream& stm) const;
  
 protected:
  TileCalibDrawerDat(const coral::Blob& blob) : TileCalibDrawerBase(blob){}
  TileCalibDrawerDat(coral::Blob& blob) : TileCalibDrawerBase(blob){}

  const T* getAddress(unsigned int channel, unsigned int adc) const;
        T* getAddress(unsigned int channel, unsigned int adc);
};
 
//
//_______________________________________________________________
template<class T> void
TileCalibDrawerDat<T>::init(const DefType&      def, 
                uint16_t            nChans,
                uint16_t            objVers,
                const std::string&  author,
                const std::string&  comment,
                uint64_t            timeStamp)
{
  uint16_t nGains   = def.size();
  uint32_t objSize  = nGains>0 ? def.begin()->size() * sizeof(T)/sizeof(uint32_t) : 0; 
  uint32_t nObjs    = nChans*nGains;
 
  //=== ensure all gains have the same object size
  for(unsigned int iGain=0; iGain<nGains; ++iGain){
    unsigned int thisSize = def[iGain].size()*sizeof(T)/sizeof(uint32_t);
    if( thisSize != objSize ){
      throw TileCalib::SizeConflict("TileCalibDrawerDat<T>::init",thisSize,objSize);
    }
  }
  
  //=== create blob
  createBlob(getType(), objVers, objSize, nObjs, nChans, nGains, author, comment, timeStamp);
 
  //=== fill the blob with default
  for(unsigned int channel=0; channel<nChans; ++channel){
    for(unsigned int adc=0; adc<nGains; ++adc){
      setData(channel, adc, def[adc]);
    }
  }
}
 
//
//______________________________________________________________
template<class T> T 
TileCalibDrawerDat<T>::getData(unsigned int channel, unsigned int adc, unsigned int idx) const
{
  if(idx>=getObjSizeUint32()){
    throw TileCalib::IndexOutOfRange("TileCalibDrawerDat::getData",idx,getObjVersion());
  }
 
  //=== Tile 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;}
 
  return getAddress(channel,adc)[idx];
}
 
//
//______________________________________________________________
template<class T> void 
TileCalibDrawerDat<T>::setData(unsigned int channel, unsigned int adc, unsigned int idx, T data) 
{
  //=== check for out of bounds
  if(channel >= getNChans()){
    throw TileCalib::IndexOutOfRange("TileCalibDrawerDat::getAddress(channel)",channel,getNChans());
  }
  if(adc>=getNGains()){
    throw TileCalib::IndexOutOfRange("CaloCalibDrawerDat::getAddress(gain)",adc,getNGains());
  }
  if(idx>=getObjSizeUint32()){
    throw TileCalib::IndexOutOfRange("TileCalibDrawerDat::getData",idx,getObjVersion());
  }
 
  getAddress(channel,adc)[idx] = data;
}
 
//
//______________________________________________________________
template<class T> void 
TileCalibDrawerDat<T>::setData(unsigned int channel, unsigned int adc, const std::vector<T>& data)
{
  for(typename std::vector<T>::const_iterator i=data.begin(); i!=data.end(); ++i){
    setData(channel,adc,i-data.begin(),*i);
  }
}
 
//
//______________________________________________________________
template<class T> const T* 
TileCalibDrawerDat<T>::getAddress(unsigned int channel, unsigned int adc) const
{
  unsigned int idx = channel*getNGains() + adc;
  return static_cast<const T*>(TileCalibDrawerBase::getAddress(idx));
}
 
//
//______________________________________________________________
template<class T> T* 
TileCalibDrawerDat<T>::getAddress(unsigned int channel, unsigned int adc)
{
  unsigned int idx = channel*getNGains() + adc;
  return static_cast<T*>(TileCalibDrawerBase::getAddress(idx));
}
 
//
//______________________________________________________________
template<class T> void 
TileCalibDrawerDat<T>::dump(std::ostream& stm) const
{
  TileCalibDrawerBase::dumpHeader(stm);
  for(unsigned int channel=0; channel<getNChans(); ++channel){
    for(unsigned int adc=0; adc<getNGains(); ++adc){
      stm << channel<<"/"<<adc<<":\t";
      for(unsigned int idx=0; idx<getObjSizeUint32(); ++idx){
    stm << getData(channel,adc,idx) << "\t";
      }
      stm << std::endl;
    }
  }
}
 
 
#endif