diff --git a/SConscript.py b/SConscript.py
index fdc3df87ed982e08e64fde383fc78a85857e624e..75e8fe887f5fdec019afaee8f47a86d06ae7a193 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 0eedcdaf90a173f7c0fb7b3c07b58ab079a1a1ef..038d603f4d02adba6f77e30316f256ae75bd32cd 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 91acb0403c82766d6f3b9c21308d59053adb0337..e78643521448f6b4a590f46c358e3a6de40805aa 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 0000000000000000000000000000000000000000..b104b17f3eb630e5676043331d12c7b341e27932
--- /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 0000000000000000000000000000000000000000..09d77bf1f1ffc872414aac18581191219898bf82
--- /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 653c1df6d6e1632cb611c7b179cce78db114c085..6fd0d279459d8e07537166b72f30187c3e3691dc 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 93b325cf838b320923ba5996d003a24f8b13d5fd..832d7586503bb9ccc0b848fc19404eb311f439d7 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 e59496881ecea88669d5a5acb29832d0ae65e1c2..da9008df3c7439a057a15f64525bdcf7a888f355 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 2ff44bbbfe65868e43af16e35a0071bada236e4f..f673f6a2a09a46e691151f22ce9e6f64e4025e5e 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 43b36acbf724db00614af255e6f929ffaf826da1..342ac0009067f0c3e2bb35b16daf71cb77cf1eef 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;