From 6e184a5a0c117cb8acfdf3f28b53141440547d1a Mon Sep 17 00:00:00 2001
From: Jure Bericic <bericic@jlab.org>
Date: Mon, 12 Dec 2016 17:30:23 -0500
Subject: [PATCH] Added THcRawAdcHit and included it in THcRawShowerHit.
The new class THcRawAdcHit is meant to represent the raw ADC hits. The
logic with dealing with ADCs has become quite complex now and it would
have to be multiplicated across all detectors that have ADC
channels. While this by itself is not such a big problem, fixing
possible bugs in multiple places is.
I also redesigned the THcRawShowerHit class to use the new
THcRawAdcHit. The redesign was due anyway, so I took the opportunity.
I also had to modify THcShowerArray and THcShowerPlane. They still
need some work to use the the new flash 250 data, but changes were
necessary anyway.
Minor fix 01.
---
SConscript.py | 1 +
src/HallC_LinkDef.h | 1 +
src/SConscript.py | 1 +
src/THcRawAdcHit.cxx | 203 +++++++++++++++++++++++++++++++
src/THcRawAdcHit.h | 51 ++++++++
src/THcRawShowerHit.cxx | 261 +++++++++++++++++++---------------------
src/THcRawShowerHit.h | 67 +++++------
src/THcShowerArray.cxx | 20 +--
src/THcShowerPlane.cxx | 12 +-
src/THcTrigRawHit.cxx | 3 +-
10 files changed, 419 insertions(+), 201 deletions(-)
create mode 100644 src/THcRawAdcHit.cxx
create mode 100644 src/THcRawAdcHit.h
diff --git a/SConscript.py b/SConscript.py
index fdc3df8..75e8fe8 100644
--- a/SConscript.py
+++ b/SConscript.py
@@ -23,6 +23,7 @@ src/THcGlobals.h src/THcDCTrack.h src/THcFormula.h
src/THcRaster.h src/THcRasteredBeam.h src/THcRasterRawHit.h src/THcScalerEvtHandler.h
src/THcHodoEff.h
src/THcTrigApp.h src/THcTrigDet.h src/THcTrigRawHit.h
+src/THcRawAdcHit.h
src/THcDummySpectrometer.h
src/HallC_LinkDef.h
""")
diff --git a/src/HallC_LinkDef.h b/src/HallC_LinkDef.h
index 0eedcda..038d603 100644
--- a/src/HallC_LinkDef.h
+++ b/src/HallC_LinkDef.h
@@ -60,6 +60,7 @@
#pragma link C++ class THcTrigApp+;
#pragma link C++ class THcTrigDet+;
#pragma link C++ class THcTrigRawHit+;
+#pragma link C++ class THcRawAdcHit+;
#pragma link C++ class THcDummySpectrometer+;
#endif
diff --git a/src/SConscript.py b/src/SConscript.py
index 91acb04..e786435 100644
--- a/src/SConscript.py
+++ b/src/SConscript.py
@@ -28,6 +28,7 @@ THcFormula.cxx
THcRaster.cxx THcRasteredBeam.cxx THcRasterRawHit.cxx
THcScalerEvtHandler.cxx
THcTrigApp.cxx THcTrigDet.cxx THcTrigRawHit.cxx
+THcRawAdcHit.cxx
THcDummySpectrometer.cxx
THcHodoEff.cxx
""")
diff --git a/src/THcRawAdcHit.cxx b/src/THcRawAdcHit.cxx
new file mode 100644
index 0000000..b104b17
--- /dev/null
+++ b/src/THcRawAdcHit.cxx
@@ -0,0 +1,203 @@
+/**
+\class THcTrigRawHit
+\ingroup DetSupport
+
+\brief Class representing a single raw ADC hit.
+
+It supports rich data from flash 250 ADC modules.
+*/
+
+#include "THcRawAdcHit.h"
+
+#include <stdexcept>
+
+#include "TString.h"
+
+
+THcRawAdcHit::THcRawAdcHit() :
+ TObject(),
+ fAdc(), fAdcTime(), fAdcPedestal(), fAdcPeak(), fAdcSample(),
+ fHasMulti(kFALSE), fNPulses(0), fNSamples(0)
+{}
+
+
+THcRawAdcHit& THcRawAdcHit::operator=(const THcRawAdcHit& right) {
+ TObject::operator=(right);
+
+ if (this != &right) {
+ for (UInt_t i=0; i<fMaxNPulses; ++i) {
+ fAdc[i] = right.fAdc[i];
+ fAdcTime[i] = right.fAdcTime[i];
+ fAdcPedestal[i] = right.fAdcPedestal[i];
+ fAdcPeak[i] = right.fAdcPeak[i];
+ }
+ for (UInt_t i=0; i<fMaxNSamples; ++i) {
+ fAdcSample[i] = right.fAdcSample[i];
+ }
+ fHasMulti = right.fHasMulti;
+ fNPulses = right.fNPulses;
+ fNSamples = right.fNSamples;
+ }
+
+ return *this;
+}
+
+
+THcRawAdcHit::~THcRawAdcHit() {}
+
+
+void THcRawAdcHit::Clear(Option_t* opt) {
+ TObject::Clear(opt);
+
+ //for (UInt_t i=0; i<fMaxNPulses; ++i) {
+ // fAdc[i] = 0;
+ // fAdcTime[i] = 0;
+ // fAdcPedestal[i] = 0;
+ // fAdcPeak[i] = 0;
+ //}
+ //for (UInt_t i=0; i<fMaxNSamples; ++i) {
+ // fAdcSample[i] = 0 ;
+ //}
+ fHasMulti = kFALSE;
+ fNPulses = 0;
+ fNSamples = 0;
+}
+
+
+void THcRawAdcHit::SetData(Int_t data) {
+ if (fNPulses >= fMaxNPulses) {
+ throw std::out_of_range(
+ "`THcRawAdcHit::SetData`: too many pulses!"
+ );
+ }
+ fAdc[fNPulses] = data;
+ ++fNPulses;
+}
+
+
+void THcRawAdcHit::SetSample(Int_t data) {
+ if (fNSamples >= fMaxNSamples) {
+ throw std::out_of_range(
+ "`THcRawAdcHit::SetSample`: too many samples!"
+ );
+ }
+ fAdcSample[fNSamples] = data;
+ ++fNSamples;
+}
+
+
+void THcRawAdcHit::SetDataTimePedestalPeak(
+ Int_t data, Int_t time, Int_t pedestal, Int_t peak
+) {
+ if (fNPulses >= fMaxNPulses) {
+ throw std::out_of_range(
+ "`THcRawAdcHit::SetData`: too many pulses!"
+ );
+ }
+ fAdc[fNPulses] = data;
+ fAdcTime[fNPulses] = data;
+ fAdcPedestal[fNPulses] = data;
+ fAdcPeak[fNPulses] = data;
+ fHasMulti = kTRUE;
+ ++fNPulses;
+}
+
+
+Int_t THcRawAdcHit::GetRawData(UInt_t iPulse) {
+ if (iPulse >= fNPulses && iPulse != 0) {
+ TString msg = TString::Format(
+ "`THcRawAdcHit::GetRawData`: requested pulse %d where only %d pulses available!",
+ iPulse, fNPulses
+ );
+ throw std::out_of_range(msg.Data());
+ }
+ else if (iPulse >= fNPulses && iPulse == 0) {
+ return 0;
+ }
+ else {
+ return fAdc[iPulse];
+ }
+}
+
+
+Int_t THcRawAdcHit::GetAdcTime(UInt_t iPulse) {
+ if (iPulse >= fNPulses && iPulse != 0) {
+ TString msg = TString::Format(
+ "`THcRawAdcHit::GetAdcTime`: requested pulse %d where only %d pulses available!",
+ iPulse, fNPulses
+ );
+ throw std::out_of_range(msg.Data());
+ }
+ else if (fHasMulti) {
+ return fAdcTime[iPulse];
+ }
+ else {
+ return 0;
+ }
+}
+
+
+Int_t THcRawAdcHit::GetAdcPedestal(UInt_t iPulse) {
+ if (iPulse >= fNPulses && iPulse != 0) {
+ TString msg = TString::Format(
+ "`THcRawAdcHit::GetAdcPedestal`: requested pulse %d where only %d pulses available!",
+ iPulse, fNPulses
+ );
+ throw std::out_of_range(msg.Data());
+ }
+ else if (fHasMulti) {
+ return fAdcPedestal[iPulse];
+ }
+ else {
+ return 0;
+ }
+}
+
+
+Int_t THcRawAdcHit::GetAdcPeak(UInt_t iPulse) {
+ if (iPulse >= fNPulses && iPulse != 0) {
+ TString msg = TString::Format(
+ "`THcRawAdcHit::GetAdcPeak`: requested pulse %d where only %d pulses available!",
+ iPulse, fNPulses
+ );
+ throw std::out_of_range(msg.Data());
+ }
+ else if (fHasMulti) {
+ return fAdcPeak[iPulse];
+ }
+ else {
+ return 0;
+ }
+}
+
+
+Int_t THcRawAdcHit::GetSample(UInt_t iSample) {
+ if (iSample >= fNSamples && iSample != 0) {
+ TString msg = TString::Format(
+ "`THcRawAdcHit::GetSample`: requested sample %d where only %d sample available!",
+ iSample, fNSamples
+ );
+ throw std::out_of_range(msg.Data());
+ }
+ else {
+ return fAdcSample[iSample];
+ }
+}
+
+
+UInt_t THcRawAdcHit::GetNPulses() {
+ return fNPulses;
+}
+
+
+UInt_t THcRawAdcHit::GetNSamples() {
+ return fNSamples;
+}
+
+
+Bool_t THcRawAdcHit::HasMulti() {
+ return fHasMulti;
+}
+
+
+ClassImp(THcRawAdcHit)
diff --git a/src/THcRawAdcHit.h b/src/THcRawAdcHit.h
new file mode 100644
index 0000000..09d77bf
--- /dev/null
+++ b/src/THcRawAdcHit.h
@@ -0,0 +1,51 @@
+#ifndef ROOT_THcRawAdcHit
+#define ROOT_THcRawAdcHit
+
+#include "TObject.h"
+
+
+class THcRawAdcHit : public TObject {
+ public:
+ THcRawAdcHit();
+ THcRawAdcHit& operator=(const THcRawAdcHit& right);
+ virtual ~THcRawAdcHit();
+
+ virtual void Clear(Option_t* opt="");
+
+ void SetData(Int_t data);
+ void SetSample(Int_t data);
+ void SetDataTimePedestalPeak(
+ Int_t data, Int_t time, Int_t pedestal, Int_t peak
+ );
+
+ Int_t GetRawData(UInt_t iPulse=0);
+ Int_t GetAdcTime(UInt_t iPulse=0);
+ Int_t GetAdcPedestal(UInt_t iPulse=0);
+ Int_t GetAdcPeak(UInt_t iPulse=0);
+ Int_t GetSample(UInt_t iSample);
+
+ UInt_t GetNPulses();
+ UInt_t GetNSamples();
+
+ Bool_t HasMulti();
+
+ protected:
+ static const UInt_t fMaxNPulses = 4;
+ static const UInt_t fMaxNSamples = 160;
+
+ Int_t fAdc[fMaxNPulses];
+ Int_t fAdcTime[fMaxNPulses];
+ Int_t fAdcPedestal[fMaxNPulses];
+ Int_t fAdcPeak[fMaxNPulses];
+ Int_t fAdcSample[fMaxNSamples];
+
+ Bool_t fHasMulti;
+ UInt_t fNPulses;
+ UInt_t fNSamples;
+
+ private:
+ ClassDef(THcRawAdcHit, 0)
+};
+
+
+#endif // ROOT_THcRawAdcHit
diff --git a/src/THcRawShowerHit.cxx b/src/THcRawShowerHit.cxx
index 653c1df..6fd0d27 100644
--- a/src/THcRawShowerHit.cxx
+++ b/src/THcRawShowerHit.cxx
@@ -1,167 +1,152 @@
-/** \class THcRawShowerHit
- \ingroup DetSupport
+/**
+\class THcRawShowerHit
+\ingroup DetSupport
- Class representing a single raw hit for a hodoscope paddle
-
- Contains plane, counter and pos/neg adc and tdc values
-
- Enhanced to work with FADC250 data samples. If fNPosSamples/fNNegSamples
- is greater than 1, assume that the data held in the hit is the sampled
- waveform. Signals 0,1 will return the integrated pulse with dynamic
- pedestal subtraction (first four samples comprise the pedestal). Signals
- 2,3 are reserved for time information. Signals 4,5 are pedestals and
- 6 and 7 are the straight sum of all the samples.
+\brief Class representing a single raw hit for a hodoscope paddle.
+ - `signal 0` is ADC pos
+ - `signal 1` is ADC neg
*/
#include "THcRawShowerHit.h"
+
#include <iostream>
-#include <cassert>
+#include <stdexcept>
-using namespace std;
+THcRawShowerHit::THcRawShowerHit(Int_t plane, Int_t counter) :
+ fAdcPos(), fAdcNeg()
+{}
-void THcRawShowerHit::SetData(Int_t signal, Int_t data) {
- if(signal==0) {
- fADC_pos[fNPosSamples++] = data;
- } else if (signal==1) {
- fADC_neg[fNNegSamples++] = data;
+
+THcRawShowerHit& THcRawShowerHit::operator=(const THcRawShowerHit& right) {
+ THcRawHit::operator=(right);
+
+ if (this != &right) {
+ fAdcPos = right.fAdcPos;
+ fAdcNeg = right.fAdcNeg;
}
+
+ return *this;
}
-Int_t THcRawShowerHit::GetData(Int_t signal, Int_t isamplow, Int_t isamphigh,
- Int_t iintegrallow, Int_t iintegralhigh) {
- Int_t adcsum=0;
- Double_t pedestal=0.0;
-
- if(signal==0 || signal == 1) {
- pedestal = GetPedestal(signal, isamplow, isamphigh);
-
-#if 0
- for(Int_t i=0;i<fNPosSamples;i++) {
- cout << fCounter << " " << i;
- if(i >= isamplow && i<=isamphigh) {
- cout << "P ";
- } else if (i >= iintegrallow && i<=iintegralhigh) {
- cout << "D ";
- } else {
- cout << " ";
- }
- cout << fADC_pos[i] << " " << fADC_pos[i] - pedestal << endl;
- }
-#endif
- }
- if(signal==4 || signal==5) {
- pedestal = GetPedestal(signal-4, isamplow, isamphigh);
- return(pedestal);
- }
- if(signal==0 || signal==6) {
- assert(iintegralhigh<(Int_t) fNPosSamples);
- for(UInt_t isample=iintegrallow;isample<=iintegralhigh;isample++) {
- adcsum += fADC_pos[isample] - pedestal;
- }
- return(adcsum);
- } else if (signal==1 || signal==7) {
- assert(iintegralhigh<(Int_t) fNNegSamples);
- for(UInt_t isample=iintegrallow;isample<=iintegralhigh;isample++) {
- adcsum += fADC_neg[isample] - pedestal;
- }
- return(adcsum);
- }
- return(-1); // Actually should throw exception
+
+THcRawShowerHit::~THcRawShowerHit() {}
+
+
+void THcRawShowerHit::Clear(Option_t* opt) {
+ THcRawHit::Clear(opt);
+
+ fAdcPos.Clear();
+ fAdcNeg.Clear();
}
-// Return sum of samples
-// For Fastbus ADC, this will simply be the hardware ADC value as there
-// is just one sample. For Flash ADCs, this should return the
-// integrated ADC value if the FADC provided that, otherwise the sum
-// of all the samples
-Int_t THcRawShowerHit::GetData(Int_t signal) {
- Int_t adcsum=0;
-
- if(signal==0) {
- for(UInt_t isample=0;isample<fNPosSamples;isample++) {
- adcsum += fADC_pos[isample];
- }
- return(adcsum);
- } else if (signal==1) {
- for(UInt_t isample=0;isample<fNNegSamples;isample++) {
- adcsum += fADC_neg[isample];
- }
- return(adcsum);
- }
- return(-1); // Actually should throw exception
+
+void THcRawShowerHit::SetData(Int_t signal, Int_t data) {
+ if (signal == 0) {
+ fAdcPos.SetData(data);
+ }
+ else if (signal == 1) {
+ fAdcNeg.SetData(data);
+ }
+ else {
+ throw std::out_of_range(
+ "`THcTrigRawHit::GetData`: only signals `0` and `1` available!"
+ );
+ }
+}
+
+
+void THcRawShowerHit::SetSample(Int_t signal, Int_t data) {
+ if (signal == 0) {
+ fAdcPos.SetSample(data);
+ }
+ else if (signal == 1) {
+ fAdcNeg.SetSample(data);
+ }
+ else {
+ throw std::out_of_range(
+ "`THcTrigRawHit::GetData`: only signals `0` and `1` available!"
+ );
+ }
}
-// Return a requested sample
-Int_t THcRawShowerHit::GetSample(Int_t signal, UInt_t isample) {
- if(signal==0) {
- if(isample < fNPosSamples) {
- return(fADC_pos[isample]);
- }
- } else if (signal==1) {
- if(isample < fNNegSamples) {
- return(fADC_neg[isample]);
- }
- }
- return(-1);
+
+void THcRawShowerHit::SetDataTimePedestalPeak(
+ Int_t signal, Int_t data, Int_t time, Int_t pedestal, Int_t peak
+) {
+ if (signal == 0) {
+ fAdcPos.SetDataTimePedestalPeak(data, time, pedestal, peak);
+ }
+ else if (signal == 1) {
+ fAdcNeg.SetDataTimePedestalPeak(data, time, pedestal, peak);
+ }
+ else {
+ throw std::out_of_range(
+ "`THcTrigRawHit::GetData`: only signals `0` and `1` available!"
+ );
+ }
}
-Double_t THcRawShowerHit::GetPedestal(Int_t signal, Int_t isamplow, Int_t isamphigh) {
- // No error checking on pedestal range
- Double_t pedestal=0.0;
- if(signal==0 && fNPosSamples > 1) {
- if(fNPosSamples > isamphigh) {
- for(Int_t i = isamplow;i<=isamphigh;i++) {
- pedestal += fADC_pos[i];
- }
- return(pedestal/(isamphigh-isamplow+1));
- }
- } else if (signal==1 && fNNegSamples > 1) {
- if(fNNegSamples > isamphigh) {
- for(Int_t i = isamplow;i<=isamphigh;i++) {
- pedestal += fADC_neg[i];
- }
- return(pedestal/(isamphigh-isamplow+1));
- }
- }
- return(pedestal);
+
+void THcRawShowerHit::SetReference(Int_t signal, Int_t reference) {
+ std::cerr
+ << "Warning:"
+ << " `THcRawShowerHit::SetReference`:"
+ << " ADC signal should not have reference time!"
+ << std::endl;
}
-// Return the number of samples
-Int_t THcRawShowerHit::GetNSamples(Int_t signal) {
- if(signal==0) {
- return(fNPosSamples);
- } else if (signal==1) {
- return(fNNegSamples);
+
+Int_t THcRawShowerHit::GetData(Int_t signal) {
+ if (signal == 0) {
+ return fAdcPos.GetRawData();
+ }
+ else if (signal == 1) {
+ return fAdcNeg.GetRawData();
+ }
+ else {
+ throw std::out_of_range(
+ "`THcTrigRawHit::GetData`: only signals `0` and `1` available!"
+ );
}
- return(-1);
}
-//_____________________________________________________________________________
-THcRawShowerHit& THcRawShowerHit::operator=( const THcRawShowerHit& rhs )
-{
- // Assignment operator.
-
- cout << "YES THIS HAPPENS" << endl;
- THcRawHit::operator=(rhs);
- if ( this != &rhs ) {
- fPlane = rhs.fPlane;
- fCounter = rhs.fCounter;
- for(UInt_t isample=0;isample<fNPosSamples;isample++) {
- fADC_pos[isample] = rhs.fADC_pos[isample];
- }
- for(UInt_t isample=0;isample<fNNegSamples;isample++) {
- fADC_pos[isample] = rhs.fADC_pos[isample];
- }
- fNPosSamples = rhs.fNPosSamples;
- fNNegSamples = rhs.fNNegSamples;
+
+Int_t THcRawShowerHit::GetRawData(Int_t signal) {
+ if (signal == 0) {
+ return fAdcPos.GetRawData();
+ }
+ else if (signal == 1) {
+ return fAdcNeg.GetRawData();
+ }
+ else {
+ throw std::out_of_range(
+ "`THcTrigRawHit::GetData`: only signals `0` and `1` available!"
+ );
}
- return *this;
}
-//////////////////////////////////////////////////////////////////////////
-ClassImp(THcRawShowerHit)
+THcRawHit::ESignalType THcRawShowerHit::GetSignalType(Int_t signal) {
+ return kADC;
+}
+
+
+Int_t THcRawShowerHit::GetNSignals() {
+ return 2;
+}
+
+
+THcRawAdcHit& THcRawShowerHit::GetRawAdcHitPos() {
+ return fAdcPos;
+}
+
+
+THcRawAdcHit& THcRawShowerHit::GetRawAdcHitNeg() {
+ return fAdcNeg;
+}
+
+ClassImp(THcRawShowerHit)
diff --git a/src/THcRawShowerHit.h b/src/THcRawShowerHit.h
index 93b325c..832d758 100644
--- a/src/THcRawShowerHit.h
+++ b/src/THcRawShowerHit.h
@@ -1,51 +1,42 @@
#ifndef ROOT_THcRawShowerHit
#define ROOT_THcRawShowerHit
+#include "THcRawAdcHit.h"
#include "THcRawHit.h"
-#define MAXSAMPLES 126
class THcRawShowerHit : public THcRawHit {
-
- public:
friend class THcShowerPlane;
friend class THcShowerArray;
- THcRawShowerHit(Int_t plane=0, Int_t counter=0) :
- THcRawHit(plane, counter), fNPosSamples(0), fNNegSamples(0) {
- }
- THcRawShowerHit& operator=( const THcRawShowerHit& );
- virtual ~THcRawShowerHit() {}
-
- virtual void Clear( Option_t* opt="" )
- { fNPosSamples=0; fNNegSamples=0;}
-
- void SetData(Int_t signal, Int_t data);
- Int_t GetData(Int_t signal);
- Int_t GetData(Int_t signal, Int_t isamplow, Int_t isamphigh,
- Int_t iintegrallow, Int_t iintegralhigh);
- Int_t GetSample(Int_t signal, UInt_t isample);
- Double_t GetPedestal(Int_t signal, Int_t isamplow, Int_t isamphigh);
- Int_t GetNSamples(Int_t signal);
-
- Int_t GetNSignals() { return 2;}
- ESignalType GetSignalType(Int_t signal) {
- return kADC;
- }
- // virtual Bool_t IsSortable () const {return kTRUE; }
- // virtual Int_t Compare(const TObject* obj) const;
-
- protected:
- UInt_t fNPosSamples;
- UInt_t fNNegSamples;
- // Is there a way we could pass sample size from the detector initialization
- Int_t fADC_pos[MAXSAMPLES];
- Int_t fADC_neg[MAXSAMPLES];
-
- private:
-
- ClassDef(THcRawShowerHit, 0); // Raw Shower counter hit
+ public:
+ THcRawShowerHit(Int_t plane=0, Int_t counter=0);
+ THcRawShowerHit& operator=(const THcRawShowerHit& right);
+ virtual ~THcRawShowerHit();
+
+ virtual void Clear(Option_t* opt="");
+
+ 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);
+
+ virtual Int_t GetData(Int_t signal);
+ virtual Int_t GetRawData(Int_t signal);
+ virtual ESignalType GetSignalType(Int_t signal);
+ virtual Int_t GetNSignals();
+
+ THcRawAdcHit& GetRawAdcHitPos();
+ THcRawAdcHit& GetRawAdcHitNeg();
+
+ protected:
+ THcRawAdcHit fAdcPos;
+ THcRawAdcHit fAdcNeg;
+
+ private:
+ ClassDef(THcRawShowerHit, 0); // Raw Shower counter hit
};
#endif
-
diff --git a/src/THcShowerArray.cxx b/src/THcShowerArray.cxx
index e594968..da9008d 100644
--- a/src/THcShowerArray.cxx
+++ b/src/THcShowerArray.cxx
@@ -642,13 +642,8 @@ Int_t THcShowerArray::ProcessHits(TClonesArray* rawhits, Int_t nexthit)
}
// Should probably check that counter # is in range
- if(fUsingFADC) {
- fA[hit->fCounter-1] = hit->GetData(0,fPedSampLow,fPedSampHigh,
- fDataSampLow,fDataSampHigh);
- fP[hit->fCounter-1] = hit->GetPedestal(0,fPedSampLow,fPedSampHigh);
- } else {
- fA[hit->fCounter-1] = hit->GetData(0);
- }
+ // TODO: Need to include rich FADC data if available.
+ fA[hit->fCounter-1] = hit->GetData(0);
if(fA[hit->fCounter-1] > threshold) {
ngood++;
@@ -787,10 +782,8 @@ Int_t THcShowerArray::AccumulatePedestals(TClonesArray* rawhits, Int_t nexthit)
Int_t element = hit->fCounter - 1; // Should check if in range
- Int_t adc = fUsingFADC ?
- hit->GetData(0,fPedSampLow,fPedSampHigh,fDataSampLow,fDataSampHigh)
- :
- hit->GetData(0);
+ // TODO: Need to include rich FADC data if available.
+ Int_t adc = hit->GetData(0);
if(adc <= fPedLimit[element]) {
fPedSum[element] += adc;
@@ -822,10 +815,7 @@ Int_t THcShowerArray::AccumulatePedestals(TClonesArray* rawhits, Int_t nexthit)
break;
}
- Int_t adc = fUsingFADC ?
- hit->GetData(0,fPedSampLow,fPedSampHigh,fDataSampLow,fDataSampHigh)
- :
- hit->GetData(0);
+ Int_t adc = hit->GetData(0);
cout << " hit " << ih << ":"
<< " plane = " << hit->fPlane
diff --git a/src/THcShowerPlane.cxx b/src/THcShowerPlane.cxx
index 2ff44bb..f673f6a 100644
--- a/src/THcShowerPlane.cxx
+++ b/src/THcShowerPlane.cxx
@@ -322,15 +322,9 @@ Int_t THcShowerPlane::ProcessHits(TClonesArray* rawhits, Int_t nexthit)
}
// Should probably check that counter # is in range
- if(fUsingFADC) {
- fA_Pos[hit->fCounter-1] = hit->GetData(0,fPedSampLow,fPedSampHigh,
- fDataSampLow,fDataSampHigh);
- fA_Neg[hit->fCounter-1] = hit->GetData(1,fPedSampLow,fPedSampHigh,
- fDataSampLow,fDataSampHigh);
- } else {
- fA_Pos[hit->fCounter-1] = hit->GetData(0);
- fA_Neg[hit->fCounter-1] = hit->GetData(1);
- }
+ // TODO: Need to include rich FADC data if available.
+ fA_Pos[hit->fCounter-1] = hit->GetData(0);
+ fA_Neg[hit->fCounter-1] = hit->GetData(1);
// Sparsify positive side hits, fill the hit list, compute the
// energy depostion from positive side for the counter.
diff --git a/src/THcTrigRawHit.cxx b/src/THcTrigRawHit.cxx
index 43b36ac..342ac00 100644
--- a/src/THcTrigRawHit.cxx
+++ b/src/THcTrigRawHit.cxx
@@ -352,7 +352,8 @@ void THcTrigRawHit::SetReference(Int_t signal, Int_t reference) {
<< "Warning:"
<< " `THcTrigRawHit::SetReference`:"
<< " signal 0 (ADC) should not have reference time!"
- << " Check map file!";
+ << " Check map file!"
+ << std::endl;
}
else if (signal == 1) {
fReferenceTime[signal] = reference;
--
GitLab