THiDetector.cxx

Go to the documentation of this file.

//  THiDetector.cxx.
#include <iostream>

#include <TCutG.h>
#include <TH2F.h>

#include "THiDetector.h"
#include "TCalibration.h"
#include "TSubEvent.h"

using std::cout;
using std::endl;

THiDetector::THiDetector(const Char_t *name, UInt_t channels)
  : TDetector(name, channels), fCalib(channels)
{
  fAdcs.reserve(channels);
  fTdcs.reserve(channels);
}

THiDetector::THiDetector(const THiDetector &rhs) : TDetector(rhs)
{
  fAdcs  = rhs.fAdcs;
  fTdcs  = rhs.fTdcs;
  fCalib = rhs.fCalib;
}

THiDetector::~THiDetector()
{
}

THiDetector & THiDetector::operator=(const THiDetector &rhs)
{
  if (&rhs != this) {
    TDetector::operator=(rhs);
    fAdcs  = rhs.fAdcs;
    fTdcs  = rhs.fTdcs;
    fCalib = rhs.fCalib;
  }
  return *this;
}

void THiDetector::Clear(const Char_t *option)
{
  TDetector::Clear();
  fAdcs.clear();
  fTdcs.clear();
}

void THiDetector::Print(const Char_t *option) const
{
  TDetector::Print(option);
  fCalib.Print(option);
  if (option[0] == 'a')
    PrintData();
}

void THiDetector::PrintData() const
{
  cout << "THiDetector data:" << endl;
  for (vector<const TDataItem<UShort_t> *>::const_iterator it =
         fAdcs.begin(), end = fAdcs.end(); it < end; it++)
    (*it)->Print("adc:    ");
  for (vector<const TDataItem<UShort_t> *>::const_iterator it =
         fTdcs.begin(), end = fTdcs.end(); it < end; it++)
    (*it)->Print("tdc:    ");
  for (vector<const TDataItem<Float_t> *>::const_iterator it = 
         fEnergies.begin(), end = fEnergies.end(); it < end; it++)
    (*it)->Print("energy: ");
  for (vector<const TDataItem<Float_t> *>::const_iterator it =
         fTimes.begin(), end = fTimes.end(); it < end; it++)
    (*it)->Print("time:   ");
}

void THiDetector::SetSignals(const TSubEvent &subEvent)
{
}

void THiDetector::Calibrate()
{
  fCalib.GetAdc().Calibrate(fAdcs, fEnergies);
  fCalib.GetTdc().Calibrate(fTdcs, fTimes);
}

Bool_t
THiDetector::PlotEnergies(TH2F *hist, const TCutG *cut, Bool_t option) const
{
  Bool_t status = false;

  for (UInt_t i = 0; i < fEnergies.size(); i++) {
    Float_t val = fEnergies[i]->GetValue();
    UShort_t chan = fCalib.GetAdc().GetHistogramMap(fEnergies[i]->GetChannel());
    if (cut && cut->IsInside(val, chan))
      status = true;
    if (option || status)
      hist->Fill(val, chan);
  }
  return status;
}

Bool_t THiDetector::PlotTimes(TH2F *hist, const TCutG *cut, Bool_t option) const
{
  Bool_t status = false;

  for (UInt_t i = 0; i < fTimes.size(); i++) {
    Float_t val = fTimes[i]->GetValue();
    UShort_t chan = fCalib.GetTdc().GetHistogramMap(fTimes[i]->GetChannel());
    if (cut && cut->IsInside(val, chan))
      status = true;
    if (option || status)
      hist->Fill(val, chan);
  }
  return status;
}

Bool_t THiDetector::PlotEvT(TH2F *hist, Float_t time, const TCutG *cut,
                            Bool_t option) const
{
  Bool_t status = false;

  for (UInt_t i = 0; i < fEnergies.size(); i++) {
    Float_t val = fEnergies[i]->GetValue();
    if (cut && cut->IsInside(time, val))
      status = true;
    if (option || status)
      hist->Fill(time, val);
  }
  return status;
}

---