From 36ccc00c35490e82e02e2bc92eb3bde328c76993 Mon Sep 17 00:00:00 2001
From: Jure Bericic <bericic@jlab.org>
Date: Thu, 12 Jan 2017 09:34:04 -0500
Subject: [PATCH] Modified THcRawHodoHit to use THcRawAdcHit and THcRawTdcHit.
This makes the code nicer and with less duplication in logic.
Along with that I had to correct all the call sites to the RawHodoHit in all the
classes that use it.
---
src/THcAerogel.cxx | 25 ++-
src/THcCherenkov.cxx | 15 +-
src/THcHodoscope.cxx | 8 +-
src/THcRawAdcHit.cxx | 22 ++-
src/THcRawAdcHit.h | 2 +
src/THcRawHodoHit.cxx | 350 +++++++++++++++--------------------
src/THcRawHodoHit.h | 112 ++++-------
src/THcRawShowerHit.cxx | 28 +--
src/THcRawShowerHit.h | 1 +
src/THcRawTdcHit.cxx | 7 +
src/THcRawTdcHit.h | 2 +
src/THcScintillatorPlane.cxx | 45 +++--
12 files changed, 276 insertions(+), 341 deletions(-)
diff --git a/src/THcAerogel.cxx b/src/THcAerogel.cxx
index 8883d02..9417c16 100644
--- a/src/THcAerogel.cxx
+++ b/src/THcAerogel.cxx
@@ -335,27 +335,27 @@ Int_t THcAerogel::Decode( const THaEvData& evdata )
Int_t tdc_pos=-1;
Int_t tdc_neg=-1;
// TDC positive hit
- if(hit->fNRawHits[2] > 0) {
+ if(hit->GetRawTdcHitPos().GetNHits() > 0) {
THcSignalHit *sighit = (THcSignalHit*) fPosTDCHits->ConstructedAt(nPosTDCHits++);
- tdc_pos = hit->GetTDCPos()+fTdcOffset;
+ tdc_pos = hit->GetRawTdcHitPos().GetTime()+fTdcOffset;
sighit->Set(hit->fCounter, tdc_pos);
}
// TDC negative hit
- if(hit->fNRawHits[3] > 0) {
+ if(hit->GetRawTdcHitNeg().GetNHits() > 0) {
THcSignalHit *sighit = (THcSignalHit*) fNegTDCHits->ConstructedAt(nNegTDCHits++);
- tdc_neg = hit->GetTDCNeg()+fTdcOffset;
+ tdc_neg = hit->GetRawTdcHitNeg().GetTime()+fTdcOffset;
sighit->Set(hit->fCounter, tdc_neg);
}
// ADC positive hit
- if((adc_pos = hit->GetADCPos()) > 0) {
+ if((adc_pos = hit->GetRawAdcHitPos().GetPeakInt()) > 0) {
THcSignalHit *sighit = (THcSignalHit*) fPosADCHits->ConstructedAt(nPosADCHits++);
sighit->Set(hit->fCounter, adc_pos);
}
// ADC negative hit
- if((adc_neg = hit->GetADCNeg()) > 0) {
+ if((adc_neg = hit->GetRawAdcHitNeg().GetPeakInt()) > 0) {
THcSignalHit *sighit = (THcSignalHit*) fNegADCHits->ConstructedAt(nNegADCHits++);
sighit->Set(hit->fCounter, adc_neg);
}
@@ -363,15 +363,15 @@ Int_t THcAerogel::Decode( const THaEvData& evdata )
// For each TDC, identify the first hit that is positive.
tdc_pos = -1;
tdc_neg = -1;
- for(UInt_t thit=0; thit<hit->fNRawHits[2]; thit++) {
- Int_t tdc = hit->GetTDCPos(thit);
+ for(UInt_t thit=0; thit<hit->GetRawTdcHitPos().GetNHits(); thit++) {
+ Int_t tdc = hit->GetRawTdcHitPos().GetTime(thit);
if(tdc >=0 ) {
tdc_pos = tdc;
break;
}
}
- for(UInt_t thit=0; thit<hit->fNRawHits[3]; thit++) {
- Int_t tdc = hit->GetTDCNeg(thit);
+ for(UInt_t thit=0; thit<hit->GetRawTdcHitNeg().GetNHits(); thit++) {
+ Int_t tdc = hit->GetRawTdcHitNeg().GetTime(thit);
if(tdc >= 0) {
tdc_neg = tdc;
break;
@@ -532,8 +532,8 @@ void THcAerogel::AccumulatePedestals(TClonesArray* rawhits)
THcAerogelHit* hit = (THcAerogelHit *) rawhits->At(ihit);
Int_t element = hit->fCounter - 1;
- Int_t adcpos = hit->GetADCPos();
- Int_t adcneg = hit->GetADCNeg();
+ Int_t adcpos = hit->GetRawAdcHitPos().GetPeakInt();
+ Int_t adcneg = hit->GetRawAdcHitNeg().GetPeakInt();
if(adcpos <= fPosPedLimit[element]) {
fPosPedSum[element] += adcpos;
fPosPedSum2[element] += adcpos*adcpos;
@@ -608,4 +608,3 @@ void THcAerogel::Print( const Option_t* opt) const {
ClassImp(THcAerogel)
////////////////////////////////////////////////////////////////////////////////
-
diff --git a/src/THcCherenkov.cxx b/src/THcCherenkov.cxx
index f5d5c95..0a22560 100644
--- a/src/THcCherenkov.cxx
+++ b/src/THcCherenkov.cxx
@@ -293,9 +293,9 @@ Int_t THcCherenkov::Decode( const THaEvData& evdata )
THcCherenkovHit* hit = (THcCherenkovHit *) fRawHitList->At(ihit);
// ADC hit
- if(hit->GetADCPos() > 0) {
+ if(hit->GetRawAdcHitPos().GetPeakIntRaw() > 0) {
THcSignalHit *sighit = (THcSignalHit*) fADCHits->ConstructedAt(nADCHits++);
- sighit->Set(hit->fCounter, hit->GetADCPos());
+ sighit->Set(hit->fCounter, hit->GetRawAdcHitPos().GetPeakIntRaw());
}
ihit++;
@@ -329,13 +329,13 @@ Int_t THcCherenkov::CoarseProcess( TClonesArray& ) //tracks
cout << "ihit != npmt " << endl;
fNPMT[npmt] = hit->fCounter;
- fADC[npmt] = hit->GetADCPos();
- fADC_P[npmt] = hit->GetADCPos() - fPedMean[npmt];
+ fADC[npmt] = hit->GetRawAdcHitPos().GetPeakIntRaw();
+ fADC_P[npmt] = hit->GetRawAdcHitPos().GetPeakIntRaw() - fPedMean[npmt];
- if ( ( fADC_P[npmt] > fCerWidth[npmt] ) && ( hit->GetADCPos() < 8000 ) ) {
+ if ( ( fADC_P[npmt] > fCerWidth[npmt] ) && ( hit->GetRawAdcHitPos().GetPeakIntRaw() < 8000 ) ) {
fNPE[npmt] = fGain[npmt]*fADC_P[npmt];
fNCherHit ++;
- } else if ( hit->GetADCPos() > 8000 ) {
+ } else if ( hit->GetRawAdcHitPos().GetPeakIntRaw() > 8000 ) {
fNPE[npmt] = 100.0;
} else {
fNPE[npmt] = 0.0;
@@ -432,7 +432,7 @@ void THcCherenkov::AccumulatePedestals(TClonesArray* rawhits)
THcCherenkovHit* hit = (THcCherenkovHit *) rawhits->At(ihit);
Int_t element = hit->fCounter - 1;
- Int_t nadc = hit->GetADCPos();
+ Int_t nadc = hit->GetRawAdcHitPos().GetPeakIntRaw();
if(nadc <= fPedLimit[element]) {
fPedSum[element] += nadc;
fPedSum2[element] += nadc*nadc;
@@ -508,4 +508,3 @@ Double_t THcCherenkov::GetCerNPE() {
ClassImp(THcCherenkov)
////////////////////////////////////////////////////////////////////////////////
-
diff --git a/src/THcHodoscope.cxx b/src/THcHodoscope.cxx
index eadc24e..7a5fcb8 100644
--- a/src/THcHodoscope.cxx
+++ b/src/THcHodoscope.cxx
@@ -620,10 +620,10 @@ Int_t THcHodoscope::Decode( const THaEvData& evdata )
if (fdebugprintscinraw == 1) {
cout << " Event number = " << evdata.GetEvNum()<<endl;
for(UInt_t ihit = 0; ihit < fNRawHits ; ihit++) {
- THcRawHodoHit* hit = (THcRawHodoHit *) fRawHitList->At(ihit);
- cout << ihit << " : " << hit->fPlane << ":" << hit->fCounter << " : "
- << hit->fADC_pos << " " << hit->fADC_neg << " " << hit->fTDC_pos
- << " " << hit->fTDC_neg << endl;
+// THcRawHodoHit* hit = (THcRawHodoHit *) fRawHitList->At(ihit);
+// cout << ihit << " : " << hit->fPlane << ":" << hit->fCounter << " : "
+// << hit->fADC_pos << " " << hit->fADC_neg << " " << hit->fTDC_pos
+// << " " << hit->fTDC_neg << endl;
}
cout << endl;
}
diff --git a/src/THcRawAdcHit.cxx b/src/THcRawAdcHit.cxx
index 93f8fdb..8a4c275 100644
--- a/src/THcRawAdcHit.cxx
+++ b/src/THcRawAdcHit.cxx
@@ -97,9 +97,9 @@ void THcRawAdcHit::SetDataTimePedestalPeak(
);
}
fAdc[fNPulses] = data;
- fAdcTime[fNPulses] = data;
- fAdcPedestal[fNPulses] = data;
- fAdcPeak[fNPulses] = data;
+ fAdcTime[fNPulses] = time;
+ fAdcPedestal[fNPulses] = pedestal;
+ fAdcPeak[fNPulses] = peak;
fHasMulti = kTRUE;
++fNPulses;
}
@@ -278,4 +278,20 @@ Double_t THcRawAdcHit::GetPeakAmp(UInt_t iPulse) {
}
+Int_t THcRawAdcHit::GetSampleIntRaw() {
+ Int_t integral = 0;
+
+ for (UInt_t iSample=0; iSample<fNSamples; ++iSample) {
+ integral += fAdcSample[iSample];
+ }
+
+ return integral;
+}
+
+
+Double_t THcRawAdcHit::GetSampleInt() {
+ return GetSampleIntRaw() - GetPed()*fNSamples;
+}
+
+
ClassImp(THcRawAdcHit)
diff --git a/src/THcRawAdcHit.h b/src/THcRawAdcHit.h
index 4fb94a7..83a09e8 100644
--- a/src/THcRawAdcHit.h
+++ b/src/THcRawAdcHit.h
@@ -45,6 +45,8 @@ class THcRawAdcHit : public TObject {
Double_t GetPeakAmp(UInt_t iPulse=0);
//Double_t GetPeakTime(UInt_t iPulse=0);
+ Int_t GetSampleIntRaw();
+ Double_t GetSampleInt();
protected:
static const UInt_t fMaxNPulses = 4;
diff --git a/src/THcRawHodoHit.cxx b/src/THcRawHodoHit.cxx
index 7051cbc..df78910 100644
--- a/src/THcRawHodoHit.cxx
+++ b/src/THcRawHodoHit.cxx
@@ -1,247 +1,201 @@
-/** \class THcRawHodoHit
- \ingroup DetSupport
-
-Raw Hodoscope Hit Info
-
-Class representing a single raw hit for a hodoscope paddle
-
- Contains plane, counter and pos/neg adc and tdc values
+/**
+\class THcRawHodoHit
+\ingroup DetSupport
+\brief Class representing a single raw hit for a hodoscope paddle.
+ - `signal 0` is ADC pos
+ - `signal 1` is ADC neg
+ - `signal 2` is TDC pos
+ - `signal 3` is TDC neg
*/
-#include <cstring>
-#include <cstdio>
-#include <cstdlib>
+#include "THcRawHodoHit.h"
+
#include <iostream>
-#include <cassert>
#include <stdexcept>
-#include "TString.h"
-#include "THcRawHodoHit.h"
+THcRawHodoHit::THcRawHodoHit(Int_t plane, Int_t counter) :
+ fAdcHits(), fTdcHits()
+{}
-using namespace std;
-void THcRawHodoHit::SetData(Int_t signal, Int_t data) {
- if(signal==0) {
- if (fNRawHits[0] >= fMaxNPulsesADC) {throw std::runtime_error("Too many samples for `THcRawHodoHit` ADC+!");}
- fADC_pos[fNRawHits[0]++] = data;
- } else if (signal==1) {
- if (fNRawHits[1] >= fMaxNPulsesADC) {throw std::runtime_error("Too many samples for `THcRawHodoHit` ADC-!");}
- fADC_neg[fNRawHits[1]++] = data;
- } else if(signal==2) {
- if (fNRawHits[2] >= fMaxNHitsTDC) {throw std::runtime_error("Too many samples for `THcRawHodoHit` TDC+!");}
- fTDC_pos[fNRawHits[2]++] = data;
- } else if (signal==3) {
- if (fNRawHits[3] >= fMaxNHitsTDC) {throw std::runtime_error("Too many samples for `THcRawHodoHit` TDC-!");}
- fTDC_neg[fNRawHits[3]++] = data;
- }
-}
-
-void THcRawHodoHit::SetDataTimePedestalPeak(Int_t signal, Int_t data, Int_t time,
- Int_t pedestal, Int_t peak) {
- if(signal==0) {
- if (fNRawHits[0] >= fMaxNPulsesADC) {throw std::runtime_error("Too many samples for `THcRawHodoHit` ADC+!");}
- fADC_pos[fNRawHits[0]] = data;
- fADC_Time_pos[fNRawHits[0]] = time;
- fADC_Pedestal_pos[fNRawHits[0]] = pedestal;
- fADC_Peak_pos[fNRawHits[0]++] = peak;
- fHasMulti[signal]=kTRUE;
- // cout << fPlane << "/" << fCounter << "+ " << fNRawHits[0] << " " <<
- // data << "/" << time << "/" << pedestal << "/" << peak << endl;
- } else if (signal==1) {
- if (fNRawHits[1] >= fMaxNPulsesADC) {throw std::runtime_error("Too many samples for `THcRawHodoHit` ADC-!");}
- fADC_neg[fNRawHits[1]] = data;
- fADC_Time_neg[fNRawHits[1]] = time;
- fADC_Pedestal_neg[fNRawHits[1]] = pedestal;
- fADC_Peak_neg[fNRawHits[1]++] = peak;
- fHasMulti[signal]=kTRUE;
- // cout << fPlane << "/" << fCounter << "- " << fNRawHits[0] << " " <<
- // data << "/" << time << "/" << pedestal << "/" << peak << endl;
+THcRawHodoHit& THcRawHodoHit::operator=(const THcRawHodoHit& right) {
+ THcRawHit::operator=(right);
+
+ if (this != &right) {
+ for (Int_t iAdcSig=0; iAdcSig<fNAdcSignals; ++iAdcSig) {
+ fAdcHits[iAdcSig] = right.fAdcHits[iAdcSig];
+ }
+ for (Int_t iTdcSig=0; iTdcSig<fNTdcSignals; ++iTdcSig) {
+ fTdcHits[iTdcSig] = right.fTdcHits[iTdcSig];
+ }
}
+
+ return *this;
}
-void THcRawHodoHit::SetSample(Int_t signal, Int_t data) {
- if(signal==0) {
- if (fNRawSamplesPos >= fMaxNSamplesADC) {throw std::runtime_error("Too many samples for `THcRawHodoHit` ADC+!");}
- fADC_Samples_pos[fNRawSamplesPos++] = data;
- } else if (signal==1) {
- if (fNRawSamplesNeg >= fMaxNSamplesADC) {throw std::runtime_error("Too many samples for `THcRawHodoHit` ADC-!");}
- fADC_Samples_neg[fNRawSamplesNeg++] = data;
+
+THcRawHodoHit::~THcRawHodoHit() {}
+
+
+void THcRawHodoHit::Clear(Option_t* opt) {
+ THcRawHit::Clear(opt);
+
+ for (Int_t iAdcSig=0; iAdcSig<fNAdcSignals; ++iAdcSig) {
+ fAdcHits[iAdcSig].Clear();
+ }
+ for (Int_t iTdcSig=0; iTdcSig<fNTdcSignals; ++iTdcSig) {
+ fTdcHits[iTdcSig].Clear();
}
}
-Int_t THcRawHodoHit::GetIntegralPos() {
- Int_t sum=0;
- for(UInt_t i=0;i<fNRawSamplesPos;i++) {
- sum += fADC_Samples_pos[i];
+
+void THcRawHodoHit::SetData(Int_t signal, Int_t data) {
+ if (0 <= signal && signal < fNAdcSignals) {
+ fAdcHits[signal].SetData(data);
+ }
+ else if (fNAdcSignals <= signal && signal < fNAdcSignals+fNTdcSignals) {
+ fTdcHits[signal-fNAdcSignals].SetTime(data);
+ }
+ else {
+ throw std::out_of_range(
+ "`THcRawHodoHit::SetData`: only signals `0` to `3` available!"
+ );
}
- return(sum);
}
-Int_t THcRawHodoHit::GetIntegralNeg() {
- Int_t sum=0;
- for(UInt_t i=0;i<fNRawSamplesNeg;i++) {
- sum += fADC_Samples_neg[i];
+
+void THcRawHodoHit::SetSample(Int_t signal, Int_t data) {
+ if (0 <= signal && signal < fNAdcSignals) {
+ fAdcHits[signal].SetSample(data);
+ }
+ else {
+ throw std::out_of_range(
+ "`THcRawHodoHit::SetSample`: only signals `0` and `1` available!"
+ );
}
- return(sum);
}
-Int_t THcRawHodoHit::GetPedestalPos() {
- if(fHasMulti[0] && fNRawHits[0]>0) {
- return(fADC_Pedestal_pos[0]);
- } else {
- return(0);
+
+void THcRawHodoHit::SetDataTimePedestalPeak(
+ Int_t signal, Int_t data, Int_t time, Int_t pedestal, Int_t peak
+) {
+ if (0 <= signal && signal < fNAdcSignals) {
+ fAdcHits[signal].SetDataTimePedestalPeak(data, time, pedestal, peak);
+ }
+ else {
+ throw std::out_of_range(
+ "`THcRawHodoHit::SetDataTimePedestalPeak`: only signals `0` and `1` available!"
+ );
}
}
-Int_t THcRawHodoHit::GetPedestalNeg() {
- if(fHasMulti[1] && fNRawHits[1]>0) {
- return(fADC_Pedestal_neg[0]);
- } else {
- return(0);
+
+void THcRawHodoHit::SetReference(Int_t signal, Int_t reference) {
+ if (fNAdcSignals <= signal && signal < fNAdcSignals+fNTdcSignals) {
+ fTdcHits[signal-fNAdcSignals].SetRefTime(reference);
+ }
+ else {
+ throw std::out_of_range(
+ "`THcRawHodoHit::SetReference`: only signals `2` and `3` available!"
+ );
}
}
+
Int_t THcRawHodoHit::GetData(Int_t signal) {
- return(GetData(signal,0));
-}
-Int_t THcRawHodoHit::GetData(Int_t signal, UInt_t ihit) {
- Int_t value;
- if(ihit>= fNRawHits[signal]) {
- if(ihit==0) {
- // We were not doing this, before, so we could have been sending
- // stale data for missing tdc or adc hits
- return(0);
- }
- cout << "THcRawHodoHit::GetData(): requested hit #" << ihit << " out of range: "
- << fNRawHits[signal] << endl;
- return(-1);
- }
- if(signal==0) {
- value = fADC_pos[ihit];
- } else if (signal==1) {
- value = fADC_neg[ihit];
- } else if (signal==2) {
- value = fTDC_pos[ihit];
- } else if (signal==3) {
- value = fTDC_neg[ihit];
- } else {
- TString msg = TString::Format(
- "THcRawHodoHit::GetData(): requested invalid signal #%d.",
- signal
- );
- throw std::out_of_range(msg.Data());
+ if (0 <= signal && signal < fNAdcSignals) {
+ return fAdcHits[signal].GetPeakInt();
}
- if(fHasRef[signal] && (signal == 2 || signal == 3)) {
- value -= fReferenceTime[signal];
+ else if (fNAdcSignals <= signal && signal < fNAdcSignals+fNTdcSignals) {
+ return fTdcHits[signal-fNAdcSignals].GetTime();
+ }
+ else {
+ throw std::out_of_range(
+ "`THcRawHodoHit::GetData`: only signals `0` to `3` available!"
+ );
}
- return(value);
}
+
Int_t THcRawHodoHit::GetRawData(Int_t signal) {
- return(GetRawData(signal,0));
-}
-
-// Return a requested raw hit
-Int_t THcRawHodoHit::GetRawData(Int_t signal, UInt_t ihit) {
- if(ihit>= fNRawHits[signal]) {
- cout << "THcRawHodoHit::GetRawData(): requested hit #" << ihit << " out of "
- << fNRawHits[signal] << endl;
- return(-1);
- }
- if(signal==0) {
- return(fADC_pos[ihit]);
- } else if (signal==1) {
- return(fADC_neg[ihit]);
- } else if (signal==2) {
- return(fTDC_pos[ihit]);
- } else if (signal==3) {
- return(fTDC_neg[ihit]);
- } else {
- TString msg = TString::Format(
- "THcRawHodoHit::GetRawData(): requested invalid signal #%d.",
- signal
+ if (0 <= signal && signal < fNAdcSignals) {
+ return fAdcHits[signal].GetPeakIntRaw();
+ }
+ else if (fNAdcSignals <= signal && signal < fNAdcSignals+fNTdcSignals) {
+ return fTdcHits[signal-fNAdcSignals].GetTimeRaw();
+ }
+ else {
+ throw std::out_of_range(
+ "`THcRawHodoHit::GetRawData`: only signals `0` to `3` available!"
);
- throw std::out_of_range(msg.Data());
}
}
-// Set the reference time
-void THcRawHodoHit::SetReference(Int_t signal, Int_t reference) {
- if (signal == 2 || signal == 3) {
- fReferenceTime[signal] = reference;
- fHasRef[signal] = kTRUE;
- } else if (signal == 0 || signal == 1) {
- std::cerr
- << "Warning:"
- << " THcRawHodoHit::SetReference():"
- << " signals 0 and 1 (ADC) should not have reference time!"
- << " Check map file!";
+
+Int_t THcRawHodoHit::GetReference(Int_t signal) {
+ if (fNAdcSignals <= signal && signal < fNAdcSignals+fNTdcSignals) {
+ return fTdcHits[signal-fNAdcSignals].GetRefTime();
+ }
+ else {
+ throw std::out_of_range(
+ "`THcRawHodoHit::GetReference`: only signals `2` and `3` available!"
+ );
}
}
-Int_t THcRawHodoHit::GetReference(Int_t signal) {
- if(fHasRef[signal]) {
- return(fReferenceTime[signal]);
- } else {
- return(0);
+
+
+THcRawHit::ESignalType THcRawHodoHit::GetSignalType(Int_t signal) {
+ if (0 <= signal && signal < fNAdcSignals) {
+ return kADC;
+ }
+ else if (fNAdcSignals <= signal && signal < fNAdcSignals+fNTdcSignals) {
+ return kTDC;
+ }
+ else {
+ throw std::out_of_range(
+ "`THcRawHodoHit::GetSignalType`: only signals `0` to `3` available!"
+ );
}
}
-Bool_t THcRawHodoHit::HasReference(Int_t signal) {
- return(fHasRef[signal]);
-}
-Bool_t THcRawHodoHit::HasMulti(Int_t signal) {
- return(fHasMulti[signal]);
-}
-
- // Do we use this?
-//_____________________________________________________________________________
-THcRawHodoHit& THcRawHodoHit::operator=( const THcRawHodoHit& rhs )
-{
- // Assignment operator.
-
- cout << "operator=" << endl;
- THcRawHit::operator=(rhs);
- if ( this != &rhs ) {
- for(Int_t is=0;is<4;is++) {
- fReferenceTime[is] = rhs.fReferenceTime[is];
- fNRawHits[is] = rhs.fNRawHits[is];
- fHasRef[is] = rhs.fHasRef[is];
- fHasMulti[is] = rhs.fHasMulti[is];
- }
- for(UInt_t ih=0;ih<fNRawHits[0];ih++) {
- fADC_pos[ih] = rhs.fADC_pos[ih];
- fADC_Time_pos[ih] = rhs.fADC_Time_pos[ih];
- fADC_Pedestal_pos[ih] = rhs.fADC_Pedestal_pos[ih];
- fADC_Peak_pos[ih] = rhs.fADC_Peak_pos[ih];
- }
- for(UInt_t ih=0;ih<fNRawHits[1];ih++) {
- fADC_neg[ih] = rhs.fADC_neg[ih];
- fADC_Time_neg[ih] = rhs.fADC_Time_neg[ih];
- fADC_Pedestal_neg[ih] = rhs.fADC_Pedestal_neg[ih];
- fADC_Peak_neg[ih] = rhs.fADC_Peak_neg[ih];
- }
- for(UInt_t ih=0;ih<fNRawHits[2];ih++) {
- fTDC_pos[ih] = rhs.fTDC_pos[ih];
- }
- for(UInt_t ih=0;ih<fNRawHits[3];ih++) {
- fTDC_neg[ih] = rhs.fTDC_neg[ih];
- }
- fNRawSamplesPos = rhs.fNRawSamplesPos;
- fNRawSamplesNeg = rhs.fNRawSamplesNeg;
- for(UInt_t is=0;is<fNRawSamplesPos;is++) {
- fADC_Samples_pos[is] = rhs.fADC_Samples_pos[is];
- }
- for(UInt_t is=0;is<fNRawSamplesNeg;is++) {
- fADC_Samples_neg[is] = rhs.fADC_Samples_neg[is];
- }
+Int_t THcRawHodoHit::GetNSignals() {
+ return fNAdcSignals + fNTdcSignals;
+}
+
+Bool_t THcRawHodoHit::HasReference(Int_t signal) {
+ if (fNAdcSignals <= signal && signal < fNAdcSignals+fNTdcSignals) {
+ return fTdcHits[signal-fNAdcSignals].HasRefTime();
}
- return *this;
+ else {
+ throw std::out_of_range(
+ "`THcRawHodoHit::HasReference`: only signals `2` and `3` available!"
+ );
+ }
+}
+
+
+THcRawAdcHit& THcRawHodoHit::GetRawAdcHitPos() {
+ return fAdcHits[0];
+}
+
+
+THcRawAdcHit& THcRawHodoHit::GetRawAdcHitNeg() {
+ return fAdcHits[1];
+}
+
+
+THcRawTdcHit& THcRawHodoHit::GetRawTdcHitPos() {
+ return fTdcHits[0];
+}
+
+
+THcRawTdcHit& THcRawHodoHit::GetRawTdcHitNeg() {
+ return fTdcHits[1];
}
-//////////////////////////////////////////////////////////////////////////
ClassImp(THcRawHodoHit)
diff --git a/src/THcRawHodoHit.h b/src/THcRawHodoHit.h
index 786bf28..679d36f 100644
--- a/src/THcRawHodoHit.h
+++ b/src/THcRawHodoHit.h
@@ -1,98 +1,54 @@
#ifndef ROOT_THcRawHodoHit
#define ROOT_THcRawHodoHit
+#include "THcRawAdcHit.h"
#include "THcRawHit.h"
+#include "THcRawTdcHit.h"
-class THcRawHodoHit : public THcRawHit {
- public:
+class THcRawHodoHit : public THcRawHit {
friend class THcScintillatorPlane;
friend class THcHodoscope;
friend class THcHodoHit;
- THcRawHodoHit(Int_t plane=0, Int_t counter=0) : THcRawHit(plane, counter) {
- for(Int_t i=0;i<4;i++) {
- fHasRef[i] = kFALSE;
- fHasMulti[i] = kFALSE;
- fNRawHits[i] = 0;
- }
- fNRawSamplesPos = 0;
- fNRawSamplesNeg = 0;
- }
- THcRawHodoHit& operator=( const THcRawHodoHit& );
- virtual ~THcRawHodoHit() {}
+ public:
- virtual void Clear( Option_t* opt="" ) {
- for(Int_t i=0;i<4;i++) {
- fHasRef[i] = kFALSE;
- fHasMulti[i] = kFALSE;
- fNRawHits[i] = 0;
- }
- fNRawSamplesPos = 0;
- fNRawSamplesNeg = 0;
- }
- void SetData(Int_t signal, Int_t data);
- void SetDataTimePedestalPeak(Int_t signal, Int_t data, Int_t time,
- Int_t pedestal, Int_t peak);
- void SetSample(Int_t signal, Int_t data);
- void SetReference(Int_t signal, Int_t reference);
- Int_t GetData(Int_t signal);
- Int_t GetData(Int_t signal, UInt_t ihit);
- Int_t GetRawData(Int_t signal);
- Int_t GetRawData(Int_t signal, UInt_t ihit);
- Int_t GetReference(Int_t signal);
- Bool_t HasReference(Int_t signal);
- Bool_t HasMulti(Int_t signal);
+ THcRawHodoHit(Int_t plane=0, Int_t counter=0);
+ THcRawHodoHit& operator=(const THcRawHodoHit& right);
+ virtual ~THcRawHodoHit();
- // virtual Bool_t IsSortable () const {return kTRUE; }
- // virtual Int_t Compare(const TObject* obj) const;
- UInt_t GetMaxNSamplesADC() {return fMaxNSamplesADC;}
- Int_t GetADCPos() {return GetData(0, 0);}
- Int_t GetADCNeg() {return GetData(1, 0);}
- Int_t GetTDCPos() {return GetData(2, 0);}
- Int_t GetTDCNeg() {return GetData(3, 0);}
+ virtual void Clear(Option_t* opt="");
- UInt_t GetMaxNSamplesTDC() {return fMaxNHitsTDC;}
- Int_t GetTDCPos(UInt_t ihit) {return GetData(2, ihit);}
- Int_t GetTDCNeg(UInt_t ihit) {return GetData(3, ihit);}
+ virtual void SetData(Int_t signal, Int_t data);
+ virtual void SetSample(Int_t signal, Int_t data);
+ virtual void SetDataTimePedestalPeak(
+ Int_t signal, Int_t data, Int_t time, Int_t pedestal, Int_t peak
+ );
+ virtual void SetReference(Int_t signal, Int_t reference);
- Int_t GetIntegralPos();
- Int_t GetIntegralNeg();
- Int_t GetPedestalPos();
- Int_t GetPedestalNeg();
+ virtual Int_t GetData(Int_t signal);
+ virtual Int_t GetRawData(Int_t signal);
+ virtual Int_t GetReference(Int_t signal);
+ virtual ESignalType GetSignalType(Int_t signal);
+ virtual Int_t GetNSignals();
- Int_t GetNSignals() { return 4;}
- ESignalType GetSignalType(Int_t signal) {
- if(signal==0||signal==1) {return kADC;}
- else {return kTDC;}
- }
+ virtual Bool_t HasReference(Int_t signal);
- protected:
- static const UInt_t fMaxNSamplesADC = 511;
- static const UInt_t fMaxNPulsesADC = 4;
- static const UInt_t fMaxNHitsTDC = 16;
- Int_t fADC_pos[fMaxNPulsesADC];
- Int_t fADC_neg[fMaxNPulsesADC];
- Int_t fTDC_pos[fMaxNHitsTDC];
- Int_t fTDC_neg[fMaxNHitsTDC];
- Int_t fADC_Time_pos[fMaxNPulsesADC];
- Int_t fADC_Time_neg[fMaxNPulsesADC];
- Int_t fADC_Pedestal_pos[fMaxNPulsesADC];
- Int_t fADC_Pedestal_neg[fMaxNPulsesADC];
- Int_t fADC_Peak_pos[fMaxNPulsesADC];
- Int_t fADC_Peak_neg[fMaxNPulsesADC];
- Int_t fADC_Samples_pos[fMaxNSamplesADC];
- Int_t fADC_Samples_neg[fMaxNSamplesADC];
- Int_t fReferenceTime[4];
- Bool_t fHasRef[4];
- Bool_t fHasMulti[4];
- UInt_t fNRawHits[4];
- UInt_t fNRawSamplesPos;
- UInt_t fNRawSamplesNeg;
+ THcRawAdcHit& GetRawAdcHitPos();
+ THcRawAdcHit& GetRawAdcHitNeg();
+ THcRawTdcHit& GetRawTdcHitPos();
+ THcRawTdcHit& GetRawTdcHitNeg();
- private:
+ protected:
+ static const Int_t fNAdcSignals = 2;
+ static const Int_t fNTdcSignals = 2;
- ClassDef(THcRawHodoHit, 0); // Raw Hodoscope hit
+ THcRawAdcHit fAdcHits[fNAdcSignals];
+ THcRawTdcHit fTdcHits[fNTdcSignals];
+
+ private:
+ ClassDef(THcRawHodoHit, 0); // Raw Hodoscope hit
};
-#endif
+
+#endif // ROOT_THcRawHodoHit
diff --git a/src/THcRawShowerHit.cxx b/src/THcRawShowerHit.cxx
index 9068c16..165a749 100644
--- a/src/THcRawShowerHit.cxx
+++ b/src/THcRawShowerHit.cxx
@@ -2,7 +2,7 @@
\class THcRawShowerHit
\ingroup DetSupport
-\brief Class representing a single raw hit for a hodoscope paddle.
+\brief Class representing a single raw hit for a shower paddle.
- `signal 0` is ADC pos
- `signal 1` is ADC neg
@@ -23,7 +23,7 @@ THcRawShowerHit& THcRawShowerHit::operator=(const THcRawShowerHit& right) {
THcRawHit::operator=(right);
if (this != &right) {
- for (UInt_t iAdcSig=0; iAdcSig<fNAdcSignals; ++iAdcSig) {
+ for (Int_t iAdcSig=0; iAdcSig<fNAdcSignals; ++iAdcSig) {
fAdcHits[iAdcSig] = right.fAdcHits[iAdcSig];
}
}
@@ -45,24 +45,24 @@ void THcRawShowerHit::Clear(Option_t* opt) {
void THcRawShowerHit::SetData(Int_t signal, Int_t data) {
- if (signal < fNAdcSignals) {
+ if (0 <= signal && signal < fNAdcSignals) {
fAdcHits[signal].SetData(data);
}
else {
throw std::out_of_range(
- "`THcTrigRawHit::GetData`: only signals `0` and `1` available!"
+ "`THcRawShowerHit::SetData`: only signals `0` and `1` available!"
);
}
}
void THcRawShowerHit::SetSample(Int_t signal, Int_t data) {
- if (signal < fNAdcSignals) {
+ if (0 <= signal && signal < fNAdcSignals) {
fAdcHits[signal].SetSample(data);
}
else {
throw std::out_of_range(
- "`THcTrigRawHit::GetData`: only signals `0` and `1` available!"
+ "`THcRawShowerHit::SetSample`: only signals `0` and `1` available!"
);
}
}
@@ -71,12 +71,12 @@ void THcRawShowerHit::SetSample(Int_t signal, Int_t data) {
void THcRawShowerHit::SetDataTimePedestalPeak(
Int_t signal, Int_t data, Int_t time, Int_t pedestal, Int_t peak
) {
- if (signal < fNAdcSignals) {
+ if (0 <= signal && signal < fNAdcSignals) {
fAdcHits[signal].SetDataTimePedestalPeak(data, time, pedestal, peak);
}
else {
throw std::out_of_range(
- "`THcTrigRawHit::GetData`: only signals `0` and `1` available!"
+ "`THcRawShowerHit::SetDataTimePedestalPeak`: only signals `0` and `1` available!"
);
}
}
@@ -92,36 +92,36 @@ void THcRawShowerHit::SetReference(Int_t signal, Int_t reference) {
Int_t THcRawShowerHit::GetData(Int_t signal) {
- if (signal < fNAdcSignals) {
+ if (0 <= signal && signal < fNAdcSignals) {
return fAdcHits[signal].GetRawData();
}
else {
throw std::out_of_range(
- "`THcTrigRawHit::GetData`: only signals `0` and `1` available!"
+ "`THcRawShowerHit::GetData`: only signals `0` and `1` available!"
);
}
}
Int_t THcRawShowerHit::GetRawData(Int_t signal) {
- if (signal < fNAdcSignals) {
+ if (0 <= signal && signal < fNAdcSignals) {
return fAdcHits[signal].GetRawData();
}
else {
throw std::out_of_range(
- "`THcTrigRawHit::GetData`: only signals `0` and `1` available!"
+ "`THcRawShowerHit::GetRawData`: only signals `0` and `1` available!"
);
}
}
THcRawHit::ESignalType THcRawShowerHit::GetSignalType(Int_t signal) {
- if (signal < fNAdcSignals) {
+ if (0 <= signal && signal < fNAdcSignals) {
return kADC;
}
else {
throw std::out_of_range(
- "`THcTrigRawHit::GetData`: only signals `0` and `1` available!"
+ "`THcRawShowerHit::GetSignalType`: only signals `0` and `1` available!"
);
}
}
diff --git a/src/THcRawShowerHit.h b/src/THcRawShowerHit.h
index 04d2c9e..a70af83 100644
--- a/src/THcRawShowerHit.h
+++ b/src/THcRawShowerHit.h
@@ -40,4 +40,5 @@ class THcRawShowerHit : public THcRawHit {
ClassDef(THcRawShowerHit, 0); // Raw Shower counter hit
};
+
#endif
diff --git a/src/THcRawTdcHit.cxx b/src/THcRawTdcHit.cxx
index 634cd4a..8fa1937 100644
--- a/src/THcRawTdcHit.cxx
+++ b/src/THcRawTdcHit.cxx
@@ -69,6 +69,7 @@ void THcRawTdcHit::SetRefTime(Int_t refTime) {
fHasRefTime = kTRUE;
}
+
Int_t THcRawTdcHit::GetTimeRaw(UInt_t iHit) const {
if (iHit < fNHits) {
return fTime[iHit];
@@ -107,9 +108,15 @@ Int_t THcRawTdcHit::GetRefTime() const {
}
}
+
Int_t THcRawTdcHit::HasRefTime() const {
return fHasRefTime;
}
+UInt_t THcRawTdcHit::GetNHits() const {
+ return fNHits;
+}
+
+
ClassImp(THcRawTdcHit)
diff --git a/src/THcRawTdcHit.h b/src/THcRawTdcHit.h
index 7c3124f..e04dad3 100644
--- a/src/THcRawTdcHit.h
+++ b/src/THcRawTdcHit.h
@@ -21,6 +21,8 @@ class THcRawTdcHit : public TObject {
Int_t HasRefTime() const;
+ UInt_t GetNHits() const;
+
protected:
static const UInt_t fMaxNHits = 16;
diff --git a/src/THcScintillatorPlane.cxx b/src/THcScintillatorPlane.cxx
index 9bbaef6..9b511f9 100644
--- a/src/THcScintillatorPlane.cxx
+++ b/src/THcScintillatorPlane.cxx
@@ -384,10 +384,10 @@ Int_t THcScintillatorPlane::ProcessHits(TClonesArray* rawhits, Int_t nexthit)
Int_t index=padnum-1;
// Need to be finding first hit in TDC range, not the first hit overall
- if (hit->fNRawHits[2] > 0)
- ((THcSignalHit*) frPosTDCHits->ConstructedAt(nrPosTDCHits++))->Set(padnum, hit->GetTDCPos()+fTdcOffset);
- if (hit->fNRawHits[3] > 0)
- ((THcSignalHit*) frNegTDCHits->ConstructedAt(nrNegTDCHits++))->Set(padnum, hit->GetTDCNeg()+fTdcOffset);
+ if (hit->GetRawTdcHitPos().GetNHits() > 0)
+ ((THcSignalHit*) frPosTDCHits->ConstructedAt(nrPosTDCHits++))->Set(padnum, hit->GetRawTdcHitPos().GetTime()+fTdcOffset);
+ if (hit->GetRawTdcHitNeg().GetNHits() > 0)
+ ((THcSignalHit*) frNegTDCHits->ConstructedAt(nrNegTDCHits++))->Set(padnum, hit->GetRawTdcHitNeg().GetTime()+fTdcOffset);
// For making hit maps, we use >= 50 cut
// For making raw hists, we don't want the cut
// We can use a flag to turn on and off these without 50 cut
@@ -395,29 +395,29 @@ Int_t THcScintillatorPlane::ProcessHits(TClonesArray* rawhits, Int_t nexthit)
Double_t adc_pos;
Double_t adc_neg;
if(fADCMode == kADCDynamicPedestal) {
- adc_pos = hit->GetADCPos()-hit->GetPedestalPos()*fADCPedScaleFactor;
- adc_neg = hit->GetADCNeg()-hit->GetPedestalNeg()*fADCPedScaleFactor;
+ adc_pos = hit->GetRawAdcHitPos().GetPeakInt();
+ adc_neg = hit->GetRawAdcHitNeg().GetPeakInt();
} else if (fADCMode == kADCSampleIntegral) {
- adc_pos = hit->GetIntegralPos()-fPosPed[index];
- adc_neg = hit->GetIntegralNeg()-fNegPed[index];
+ adc_pos = hit->GetRawAdcHitPos().GetSampleIntRaw() - fPosPed[index];
+ adc_neg = hit->GetRawAdcHitNeg().GetSampleIntRaw() - fNegPed[index];
} else if (fADCMode == kADCSampIntDynPed) {
- adc_pos = hit->GetIntegralPos()-hit->GetPedestalPos()*fADCPedScaleFactor;
- adc_neg = hit->GetIntegralNeg()-hit->GetPedestalNeg()*fADCPedScaleFactor;
+ adc_pos = hit->GetRawAdcHitPos().GetSampleInt();
+ adc_neg = hit->GetRawAdcHitNeg().GetSampleInt();
} else {
- adc_pos = hit->GetADCPos()-fPosPed[index];
- adc_neg = hit->GetADCNeg()-fNegPed[index];
+ adc_pos = hit->GetRawAdcHitPos().GetPeakIntRaw()-fPosPed[index];
+ adc_neg = hit->GetRawAdcHitNeg().GetPeakIntRaw()-fNegPed[index];
}
if (adc_pos >= fADCDiagCut) {
((THcSignalHit*) frPosADCHits->ConstructedAt(nrPosADCHits))->Set(padnum, adc_pos);
- Double_t samplesum=hit->GetIntegralPos();
- Double_t pedestal=hit->GetPedestalPos();
+ Double_t samplesum=hit->GetRawAdcHitPos().GetSampleIntRaw();
+ Double_t pedestal=hit->GetRawAdcHitPos().GetPedRaw();
((THcSignalHit*) frPosADCSums->ConstructedAt(nrPosADCHits))->Set(padnum, samplesum);
((THcSignalHit*) frPosADCPeds->ConstructedAt(nrPosADCHits++))->Set(padnum, pedestal);
}
if (adc_neg >= fADCDiagCut) {
((THcSignalHit*) frNegADCHits->ConstructedAt(nrNegADCHits))->Set(padnum, adc_neg);
- Double_t samplesum=hit->GetIntegralNeg();
- Double_t pedestal=hit->GetPedestalNeg();
+ Double_t samplesum=hit->GetRawAdcHitNeg().GetSampleIntRaw();
+ Double_t pedestal=hit->GetRawAdcHitNeg().GetPedRaw();
((THcSignalHit*) frNegADCSums->ConstructedAt(nrNegADCHits))->Set(padnum, samplesum);
((THcSignalHit*) frNegADCPeds->ConstructedAt(nrNegADCHits++))->Set(padnum, pedestal);
}
@@ -427,15 +427,15 @@ Int_t THcScintillatorPlane::ProcessHits(TClonesArray* rawhits, Int_t nexthit)
Int_t tdc_pos=-99;
Int_t tdc_neg=-99;
// Find first in range hit from multihit tdc
- for(UInt_t thit=0; thit<hit->fNRawHits[2]; thit++) {
- tdc_pos = hit->GetTDCPos(thit)+fTdcOffset;
+ for(UInt_t thit=0; thit<hit->GetRawTdcHitPos().GetNHits(); thit++) {
+ tdc_pos = hit->GetRawTdcHitPos().GetTime(thit)+fTdcOffset;
if(tdc_pos >= fScinTdcMin && tdc_pos <= fScinTdcMax) {
btdcraw_pos = kTRUE;
break;
}
}
- for(UInt_t thit=0; thit<hit->fNRawHits[3]; thit++) {
- tdc_neg = hit->GetTDCNeg(thit)+fTdcOffset;
+ for(UInt_t thit=0; thit<hit->GetRawTdcHitNeg().GetNHits(); thit++) {
+ tdc_neg = hit->GetRawTdcHitNeg().GetTime(thit)+fTdcOffset;
if(tdc_neg >= fScinTdcMin && tdc_neg <= fScinTdcMax) {
btdcraw_neg = kTRUE;
break;
@@ -525,8 +525,8 @@ Int_t THcScintillatorPlane::AccumulatePedestals(TClonesArray* rawhits, Int_t nex
break;
}
Int_t element = hit->fCounter - 1; // Should check if in range
- Int_t adcpos = hit->GetADCPos();
- Int_t adcneg = hit->GetADCNeg();
+ Int_t adcpos = hit->GetRawAdcHitPos().GetPeakIntRaw();
+ Int_t adcneg = hit->GetRawAdcHitNeg().GetPeakIntRaw();
if(adcpos <= fPosPedLimit[element]) {
fPosPedSum[element] += adcpos;
@@ -613,4 +613,3 @@ void THcScintillatorPlane::InitializePedestals( )
//____________________________________________________________________________
ClassImp(THcScintillatorPlane)
////////////////////////////////////////////////////////////////////////////////
-
--
GitLab