CaloCondBlobDat.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef CALOCONDBLOBOBJS_CALOCONDBLOBDAT_H
#define CALOCONDBLOBOBJS_CALOCONDBLOBDAT_H
 
#include "CaloCondBlobObjs/CaloCondBlobBase.h"
#include "CaloCondBlobObjs/CaloCondType.h"
#include <stdint.h>
#include <vector>
#include <ostream>
#include <iostream>
#include "CoralBase/Blob.h"
 
template<class T>
class CaloCondBlobDat : public CaloCondBlobBase
{
 public:
  typedef std::vector<std::vector<T> > DefType;
  
  virtual ~CaloCondBlobDat(){}
  
  //==================================================================
  //== Data getter and setter methods
  //==================================================================
  T getData(const unsigned int channel, const unsigned int adc, const unsigned int idx) const;
 
  //==================================================================
  //== Optimized data getter for calibrations independent of gain and ADC
  //==================================================================
  T getData(const unsigned int channel) const;
  
  void init(const DefType& def, 
        uint32_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:
  CaloCondBlobDat(const coral::Blob& blob) : CaloCondBlobBase(blob){}
  CaloCondBlobDat(coral::Blob& blob) : CaloCondBlobBase(blob){}
 
 
  const T* getAddress(const unsigned int channel, const unsigned int adc) const;
  T* getAddress(const unsigned int channel, const unsigned int adc);
};
 
//
//_______________________________________________________________
template<class T> void
CaloCondBlobDat<T>::init(const DefType&      def, 
                uint32_t            nChans,
                uint16_t            objVers,
                const std::string&  author,
                const std::string&  comment,
                uint64_t            timeStamp)
{
  uint32_t objSize  = def.begin()->size() * sizeof(T)/sizeof(uint32_t); 
  uint16_t nGains   = def.size();
  uint32_t nObjs    = nChans*nGains;
  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 
CaloCondBlobDat<T>::getData(const unsigned int channel, const unsigned int adc, const unsigned int idx) const
{
  if(idx<getObjSizeUint32()){return getAddress(channel,adc)[idx];}
  else{throw CaloCond::IndexOutOfRange("CaloCondBlobDat::getData",idx,getObjVersion());}
}
 
 
template<class T> T 
CaloCondBlobDat<T>::getData(const unsigned int channel) const {
return (static_cast<const T*>(m_pDataStart))[channel];
}
 
 
//
//______________________________________________________________
template<class T> void 
CaloCondBlobDat<T>::setData(unsigned int channel, unsigned int adc, unsigned int idx, T data) 
{
  if(idx<getObjSizeUint32()){ getAddress(channel,adc)[idx] = data;}
  else{throw CaloCond::IndexOutOfRange("CaloCondBlobDat::setData",idx,getObjVersion());}
}
 
//
//______________________________________________________________
template<class T> void 
CaloCondBlobDat<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* 
CaloCondBlobDat<T>::getAddress(const unsigned int channel, const unsigned int adc) const
{
  //=== check for out of bounds
  if(channel >= getNChans()){
    throw CaloCond::IndexOutOfRange("CaloCondBlobDat::getAddress(channel)",channel,getNChans());
  }
  if(adc>=getNGains()){
    throw CaloCond::IndexOutOfRange("CaloCondBlobDat::getAddress(gain)",adc,getNGains());
  }
  
  const unsigned int idx = channel*getNGains() + adc;
  return static_cast<const T*>(CaloCondBlobBase::getAddress(idx));
}
 
//
//______________________________________________________________
template<class T> T* 
CaloCondBlobDat<T>::getAddress(const unsigned int channel, const unsigned int adc)
{
  //=== check for out of bounds
  if(channel >= getNChans()){
    throw CaloCond::IndexOutOfRange("CaloCondBlobDat::getAddress(channel)",channel,getNChans());
  }
  if(adc>=getNGains()){
    throw CaloCond::IndexOutOfRange("CaloCondBlobDat::getAddress(gain)",adc,getNGains());
  }
  
  const unsigned int idx = channel*getNGains() + adc;
  return static_cast<T*>(CaloCondBlobBase::getAddress(idx));
}
 
//
//______________________________________________________________
template<class T> void 
CaloCondBlobDat<T>::dump(std::ostream& stm) const
{
  CaloCondBlobBase::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