TCalibration.cxx

Go to the documentation of this file.

//  TCalibration.cxx.
#include <iostream>
#include <iomanip>

#include "TCalibration.h"

using std::cout;
using std::cerr;
using std::endl;
using std::setw;
using std::setfill;
using std::hex;
using std::dec;

TCalibration::TCalibration(UShort_t channels)
  : fChannels(channels), fCalSet(false),
    fBits(sizeof(UInt_t) * 8), fMaskMax(0), fBitMask(0)
{
  SetChannels(channels);
}

TCalibration::TCalibration(const TCalibration &rhs)
{
  fChannels = rhs.fChannels;
  fCalSet   = rhs.fCalSet;
  fChannel  = rhs.fChannel;
  fMap      = rhs.fMap;
  fOffset   = rhs.fOffset;
  fGain     = rhs.fGain;
  fMapH     = rhs.fMapH;
  fBits     = rhs.fBits;
  fMaskMax  = rhs.fMaskMax;
  fBitMask  = new UInt_t[rhs.fMaskMax];
  for (UInt_t i = 0; i < rhs.fMaskMax; i++)
    fBitMask[i] = rhs.fBitMask[i];
}

TCalibration::~TCalibration()
{
  if (fBitMask) delete [] fBitMask;
}

TCalibration & TCalibration::operator=(const TCalibration &rhs)
{
  if (&rhs != this) {
    Clear();
    fChannels = rhs.fChannels;
    fCalSet   = rhs.fCalSet;
    fChannel  = rhs.fChannel;
    fMap      = rhs.fMap;
    fOffset   = rhs.fOffset;
    fGain     = rhs.fGain;
    fMapH     = rhs.fMapH;
    fBits     = rhs.fBits;
    fMaskMax  = rhs.fMaskMax;
    fBitMask  = new UInt_t[rhs.fMaskMax];
    for (UInt_t i = 0; i < rhs.fMaskMax; i++)
      fBitMask[i] = rhs.fBitMask[i];
  }
  return *this;
}

void TCalibration::Clear(const Char_t *option)
{
  fCalSet = false;
  if (! fMap.empty())    fMap.clear();
  if (! fGain.empty())   fGain.clear();
  if (! fOffset.empty()) fOffset.clear();
  if (! fMapH.empty())   fMapH.clear();
  if (fBitMask)
    delete [] fBitMask;
  fBitMask = 0;
}

void TCalibration::Print(const Char_t *option) const
{

  //
  // Note that spaces _and_ setw() calls are used, this is so that if
  // the value being printed exceeds the set width there is still a
  // space after the previous value.
  //
  if (fCalSet) {
    cout << "Channel:   Map:     Gain:   Offset:  Histogram Map:"  << endl;
    for (UShort_t i = 0; i < fChannels; i++)
      cout << setw(8)  << dec << i << " " << setw(6) << fMap[i]    << " "
           << setw(9)  << fGain[i] << " " << setw(9) << fOffset[i] << " "
           << setw(15) << fMapH[i] << endl;
    if (fBitMask) {
      cout << "Bit-mask = 0x";
      for (UInt_t i = 0; i < fMaskMax; i++)
        cout << hex << setw(4) << setfill('0') << fBitMask[i];
      cout << setfill(' ') << endl << "         = ";
      for (UInt_t i = 0; i < fMaskMax; i++) {
        for (UInt_t j = 0; j < fBits; j++) {
          Bool_t bit = (fBitMask[i] >> j & 1 ? 1 : 0);
          cout << dec << bit;
        }
        cout << " ";
      }
    }
    cout << endl;
  } else
    cerr << "Print: ERROR - no calibration set, using default" << endl;
}

void TCalibration::SetChannels(UInt_t channels)
{
  if (fCalSet == true) {
    cerr << "SetChannels: ERROR - calibration already set," << endl
         << "call Clear() first to enable resize"           << endl;
  } else {
    fChannel.resize(channels);
    fMap.resize(channels);
    fGain.resize(channels, 1);
    fOffset.resize(channels, 0);
    fMapH.resize(channels);
    for (UInt_t i = 0; i < channels; i++) {
      fChannel[i] = i;
      fMap[i]     = i;
      fMapH[i]    = i;
    }
    fChannels = channels;
    SetBitMask();
  }
}

void TCalibration::SetBitMask()
{
  UInt_t max = 0;

  if (fChannels > 0)
    max = *(max_element(fMap.begin(), fMap.end()));
  fMaskMax = max / fBits + 1;
  if (fBitMask)
    delete [] fBitMask;
  fBitMask = new UInt_t[fMaskMax];
  for (UInt_t i = 0; i < fMaskMax; i++)
    fBitMask[i] = 0;
  for (UInt_t i = 0; i < fMap.size(); i++)
    fBitMask[fMap[i] / fBits] |= (1 << fMap[i] % fBits);
  fCalSet = true;
}

void TCalibration::AddToChannel(UInt_t map, UShort_t channel)
{
  if (map >= fChannel.size())
    fChannel.resize(map + 1);
  fChannel[map] = channel;
}
 
void TCalibration::AddToMap(UInt_t channel, UShort_t map)
{
  fMap[channel] = map;
}
 
void TCalibration::AddToOffset(UInt_t channel, Short_t offset)
{
  fOffset[channel] = offset;
}
 
void TCalibration::AddToGain(UInt_t channel, Float_t gain)
{
  fGain[channel] = gain;
}

void TCalibration::AddToHistogramMap(UInt_t channel, UShort_t map)
{
  fMapH[channel] = map;
}

void
TCalibration::Calibrate(const vector<const TDataItem<UShort_t> *> &rawSignals,
                        vector<const TDataItem<Float_t> *> &calSignals) const
{
  for (UInt_t i = 0; i < rawSignals.size(); i++) {
    Short_t c = fChannel[rawSignals[i]->GetChannel()];
    Float_t v = fGain[c] * (rawSignals[i]->GetValue() - fOffset[c]);
    calSignals.push_back(new TDataItem<Float_t>(c, v));
  }
}

---