TDsssdDetector.cxx

Go to the documentation of this file.

//  TDsssdDetector.cxx.
#include <iostream>

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

#include "TDsssdDetector.h"
#include "TSubEvent.h"
#include "THit.h"

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

TDsssdDetector::TDsssdDetector(const Char_t *name, UInt_t channels,
                               Float_t stripWidth, Float_t stripSpacing)
  : THiDetector(name, channels), fStripWidth(stripWidth),
    fStripSpacing(stripSpacing)
{
}

TDsssdDetector::~TDsssdDetector()
{
}

void TDsssdDetector::Print(const Char_t *option) const
{
  cout <<"DSSSD detector:" << endl;
  THiDetector::Print(option);
}

void TDsssdDetector::SetSignals(const TSubEvent &subEvent)
{
  const vector<TDataItem<UShort_t> > &adcs = subEvent.GetAdcs();
  const vector<TDataItem<UShort_t> > &tdcs = subEvent.GetTdcs();

  for (UInt_t i = 0; i < adcs.size(); i++)
    if (fCalib.GetAdc().TestChannel(adcs[i].GetChannel())) {
      fAdcs.push_back(&adcs[i]);
      fHit = true;
    }
  for (UInt_t i = 0; i < tdcs.size(); i++)
    if (fCalib.GetTdc().TestChannel(tdcs[i].GetChannel())) {
      fTdcs.push_back(&tdcs[i]);
    }
}

void TDsssdDetector::FindHits(vector<THit> *hits) const
{
  //
  // channel number _has_ to be less than the number of channels
  // (0-based indexing).
  //
  UShort_t chansOneSide = GetChannels() / 2;
  THit p;

  //
  // split energy vector according to front and back
  // channels then sort energies according to size
  //
  vector<const TDataItem<Float_t> *> hitsB;
  vector<const TDataItem<Float_t> *> hitsF;

  for (UInt_t i = 0; i < fEnergies.size(); i++)
    fEnergies[i]->GetChannel() < chansOneSide ?
      hitsF.push_back(fEnergies[i]) : hitsB.push_back(fEnergies[i]);
  sort(hitsF.begin(), hitsF.end(), GreaterValue<Float_t>());
  sort(hitsB.begin(), hitsB.end(), GreaterValue<Float_t>());

  //
  // now assume front and back hits are paired by energy and
  // must have a front and back signal to count as a real hit
  //
  for (UInt_t i = 0; i < hitsF.size(); i++) {
    p.SetDetector(GetName());
    p.SetEnergy(hitsF[i]->GetValue());
    for (UInt_t j = 0; j < fTimes.size(); j++)
      if (fTimes[j]->GetChannel() == hitsF[i]->GetChannel()) {
        p.SetTime(fTimes[j]->GetValue());
        break;
      }
    if (i < hitsB.size()) {
      TVector3 xyz = GetPosition(hitsF[i]->GetChannel(),
                                 hitsB[i]->GetChannel() - chansOneSide);
      p.SetPosition(xyz.x(), xyz.y(), xyz.z());
    }
    hits->push_back(p);
  }
}

void TDsssdDetector::GetStripsXY(vector<UShort_t> &stripsX,
                                 vector<UShort_t> &stripsY) const
{
  for (UInt_t i = 0; i < fEnergies.size(); i++)
    if (fEnergies[i]->GetChannel() < GetChannels() / 2)
      stripsX.push_back(fEnergies[i]->GetChannel());
  for (UInt_t i = 0; i < fEnergies.size(); i++)
    if (fEnergies[i]->GetChannel() >= GetChannels() / 2) 
      stripsY.push_back(fEnergies[i]->GetChannel());
}

TVector3 TDsssdDetector::GetPosition(UShort_t stripF,
                                     UShort_t stripB) const
{
  Float_t x = (stripF + 0.5) * fStripWidth + stripF * fStripSpacing;
  Float_t y = (stripB + 0.5) * fStripWidth + stripB * fStripSpacing;
  Float_t z = fCoordinates.Z();
  UShort_t frontStrips = GetChannels() / 2;
  Float_t width = frontStrips * fStripWidth + (frontStrips - 1) * fStripSpacing;

  x -= width / 2 + fCoordinates.X();
  y -= width / 2 + fCoordinates.Y();
  return TVector3(x, y, z);
}

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

  for (UInt_t i = 0; i < fEnergies.size(); i++)
    for (UInt_t j = 0; j < fTimes.size(); j++) {
      UInt_t x = fCalib.GetTdc().GetHistogramMap(fTimes[j]->GetChannel());
      UInt_t y = fCalib.GetAdc().GetHistogramMap(fEnergies[i]->GetChannel());
      if (cut && cut->IsInside(x, y))
        status = true;
      if (option || status)
        hist->Fill(x, y);
    }
  return status;
}

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

  for (UInt_t i = 0; i < fEnergies.size(); i++) {
    UInt_t x;
    UInt_t y;
    if ((x = fCalib.GetAdc().GetHistogramMap(fEnergies[i]->GetChannel())) <
        GetChannels() / 2)
      for (UInt_t j = 0; j < fEnergies.size(); j++)
        if ((y = fCalib.GetAdc().GetHistogramMap(fEnergies[j]->GetChannel()))
            >= GetChannels() / 2) {
          if (cut && cut->IsInside(x, y))
            status = true;
          if (option || status)
            hist->Fill(x, y);
        }
  }
  return status;
}

Bool_t TDsssdDetector::PlotFrontEvT(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++) 
    if (fEnergies[i]->GetChannel() < GetChannels() / 2) {
      Float_t energy = fEnergies[i]->GetValue();
      if (cut && cut->IsInside(time, energy))
        status = true;
      if (option || status)
        hist->Fill(time, energy);
    }
  return status;
}

void TDsssdDetector::PlotAdcNAdcPEnergyP(TH3F *hist) const
{
  for (UInt_t i = 0; i < fEnergies.size(); i++)
    if (fCalib.GetAdc().GetHistogramMap(fEnergies[i]->GetChannel()) <
        GetChannels() / 2)
      for (UInt_t j = 0; j < fEnergies.size(); j++)
        if (fCalib.GetAdc().GetHistogramMap(fEnergies[j]->GetChannel()) >=
            GetChannels() / 2)
          hist->Fill(
            fCalib.GetAdc().GetHistogramMap(fEnergies[i]->GetChannel()),
            fCalib.GetAdc().GetHistogramMap(fEnergies[j]->GetChannel()),
            fEnergies[i]->GetValue());
}

---