TileCalibDrawerOfc.h File Reference

#include "TileCalibBlobObjs/TileCalibDrawerBase.h"
#include "TileCalibBlobObjs/TileCalibType.h"
#include "TileCalibBlobObjs/TileCalibUtils.h"
#include "CoralBase/Blob.h"
#include <stdint.h>
#include <iostream>
#include <vector>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <cmath>

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	TileCalibDrawerOfc

Macros
#define	PHASE_PRECISION   0.1
	Class for storing Optimal Filtering Coefficients (OFCs) in a coral::Blob.

Functions
	__attribute__ ((always_inline)) inline uint32_t TileCalibDrawerOfc

Macro Definition Documentation

PHASE_PRECISION

#define PHASE_PRECISION   0.1

Class for storing Optimal Filtering Coefficients (OFCs) in a coral::Blob.

Author

Nils Gollub nils..nosp@m.goll.nosp@m.ub@ce.nosp@m.rn.c.nosp@m.h

This class extends the header defined in TileCalibDrawerBase by two additional 32 bit words:

• nSamples: The number of samples used in OFC computation
• nPhases: The number of phases stored in the BLOB.

Directly after these two extra header words a list of phases is stored. The phases are encoded as integers so that exact comparisons are possible. Since phases are only needed with a resolution of 0.1ns, a good convention is to store int(10*phase).

If the nPhases is set to a negative value in initialization with init(...), only one list of phases common for all ADCs is stored.

Definition at line 38 of file TileCalibDrawerOfc.h.

Function Documentation

__attribute__()

__attribute__

(

(always_inline)

)

Definition at line 203 of file TileCalibDrawerOfc.h.

                                                      {
  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();
 
  memcpy(w_a, startAddress, allSamplesSize);
  startAddress += fieldSize;
  memcpy(w_b, startAddress, allSamplesSize);
  startAddress += fieldSize;
  memcpy(g, startAddress, allSamplesSize);
  startAddress += fieldSize;
  memcpy(w_c, startAddress, allSamplesSize);
  if (getNFields() > 4) {
    startAddress += fieldSize;
    memcpy(dg, startAddress, allSamplesSize);
  } else {
    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;
}