diff --git a/.gitignore b/.gitignore
index 08ecc3688a6ee92e92c47442fe06d32aa5fa904c..f2300f29cfaed309d48dc65edd240f7ac7012723 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,7 +14,6 @@ THaDecDict.C
THaDecDict.h
haDict.h
haDict.C
-hcana
src/HallC_LinkDef.h
src/hc_compiledata.h
diff --git a/src/THcCherenkov.cxx b/src/THcCherenkov.cxx
index 33d4571642f548e5d7a45259b4ca9246e5dfe946..87d94235160cc8e143633e7a8456f577a35e8caa 100644
--- a/src/THcCherenkov.cxx
+++ b/src/THcCherenkov.cxx
@@ -6,78 +6,73 @@
*/
#include "THcCherenkov.h"
-#include "THcHodoscope.h"
#include "TClonesArray.h"
-#include "THcSignalHit.h"
-#include "THaEvData.h"
+#include "THaApparatus.h"
+#include "THaCutList.h"
#include "THaDetMap.h"
+#include "THaEvData.h"
+#include "THaTrack.h"
+#include "THaTrackProj.h"
#include "THcDetectorMap.h"
#include "THcGlobals.h"
-#include "THaCutList.h"
-#include "THcParmList.h"
+#include "THcHallCSpectrometer.h"
#include "THcHitList.h"
-#include "THaApparatus.h"
+#include "THcHodoscope.h"
+#include "THcParmList.h"
+#include "THcSignalHit.h"
+#include "TMath.h"
#include "VarDef.h"
#include "VarType.h"
-#include "THaTrack.h"
-#include "TClonesArray.h"
-#include "TMath.h"
-#include "THaTrackProj.h"
-#include "THcHallCSpectrometer.h"
#include <algorithm>
-#include <cstring>
#include <cstdio>
#include <cstdlib>
+#include <cstring>
+#include <iomanip>
#include <iostream>
#include <string>
-#include <iomanip>
-
using namespace std;
-using std::cout;
using std::cin;
+using std::cout;
using std::endl;
-using std::setw;
using std::setprecision;
+using std::setw;
//_____________________________________________________________________________
-THcCherenkov::THcCherenkov( const char* name, const char* description,
- THaApparatus* apparatus ) :
- THaNonTrackingDetector(name,description,apparatus)
-{
+THcCherenkov::THcCherenkov(const char* name, const char* description, THaApparatus* apparatus)
+ : THaNonTrackingDetector(name, description, apparatus) {
// Normal constructor with name and description
- frAdcPedRaw = new TClonesArray("THcSignalHit", MaxNumCerPmt*MaxNumAdcPulse);
- frAdcPulseIntRaw = new TClonesArray("THcSignalHit", MaxNumCerPmt*MaxNumAdcPulse);
- frAdcPulseAmpRaw = new TClonesArray("THcSignalHit", MaxNumCerPmt*MaxNumAdcPulse);
- frAdcPulseTimeRaw = new TClonesArray("THcSignalHit", MaxNumCerPmt*MaxNumAdcPulse);
- frAdcPed = new TClonesArray("THcSignalHit", MaxNumCerPmt*MaxNumAdcPulse);
- frAdcPulseInt = new TClonesArray("THcSignalHit", MaxNumCerPmt*MaxNumAdcPulse);
- frAdcPulseAmp = new TClonesArray("THcSignalHit", MaxNumCerPmt*MaxNumAdcPulse);
- frAdcPulseTime = new TClonesArray("THcSignalHit", MaxNumCerPmt*MaxNumAdcPulse);
- fAdcErrorFlag = new TClonesArray("THcSignalHit", MaxNumCerPmt*MaxNumAdcPulse);
-
- fNumAdcHits = vector<Int_t> (MaxNumCerPmt, 0.0);
- fNumGoodAdcHits = vector<Int_t> (MaxNumCerPmt, 0.0);
- fNumTracksMatched = vector<Int_t> (MaxNumCerPmt, 0.0);
- fNumTracksFired = vector<Int_t> (MaxNumCerPmt, 0.0);
- fNpe = vector<Double_t> (MaxNumCerPmt, 0.0);
- fGoodAdcPed = vector<Double_t> (MaxNumCerPmt, 0.0);
- fGoodAdcMult = vector<Double_t> (MaxNumCerPmt, 0.0);
- fGoodAdcHitUsed = vector<Double_t> (MaxNumCerPmt, 0.0);
- fGoodAdcPulseInt = vector<Double_t> (MaxNumCerPmt, 0.0);
- fGoodAdcPulseIntRaw = vector<Double_t> (MaxNumCerPmt, 0.0);
- fGoodAdcPulseAmp = vector<Double_t> (MaxNumCerPmt, 0.0);
- fGoodAdcPulseTime = vector<Double_t> (MaxNumCerPmt, 0.0);
- fGoodAdcTdcDiffTime = vector<Double_t> (MaxNumCerPmt, 0.0);
+ frAdcPedRaw = new TClonesArray("THcSignalHit", MaxNumCerPmt * MaxNumAdcPulse);
+ frAdcPulseIntRaw = new TClonesArray("THcSignalHit", MaxNumCerPmt * MaxNumAdcPulse);
+ frAdcPulseAmpRaw = new TClonesArray("THcSignalHit", MaxNumCerPmt * MaxNumAdcPulse);
+ frAdcPulseTimeRaw = new TClonesArray("THcSignalHit", MaxNumCerPmt * MaxNumAdcPulse);
+ frAdcPed = new TClonesArray("THcSignalHit", MaxNumCerPmt * MaxNumAdcPulse);
+ frAdcPulseInt = new TClonesArray("THcSignalHit", MaxNumCerPmt * MaxNumAdcPulse);
+ frAdcPulseAmp = new TClonesArray("THcSignalHit", MaxNumCerPmt * MaxNumAdcPulse);
+ frAdcPulseTime = new TClonesArray("THcSignalHit", MaxNumCerPmt * MaxNumAdcPulse);
+ fAdcErrorFlag = new TClonesArray("THcSignalHit", MaxNumCerPmt * MaxNumAdcPulse);
+
+ fNumAdcHits = vector<Int_t>(MaxNumCerPmt, 0.0);
+ fNumGoodAdcHits = vector<Int_t>(MaxNumCerPmt, 0.0);
+ fNumTracksMatched = vector<Int_t>(MaxNumCerPmt, 0.0);
+ fNumTracksFired = vector<Int_t>(MaxNumCerPmt, 0.0);
+ fNpe = vector<Double_t>(MaxNumCerPmt, 0.0);
+ fGoodAdcPed = vector<Double_t>(MaxNumCerPmt, 0.0);
+ fGoodAdcMult = vector<Double_t>(MaxNumCerPmt, 0.0);
+ fGoodAdcHitUsed = vector<Double_t>(MaxNumCerPmt, 0.0);
+ fGoodAdcPulseInt = vector<Double_t>(MaxNumCerPmt, 0.0);
+ fGoodAdcPulseIntRaw = vector<Double_t>(MaxNumCerPmt, 0.0);
+ fGoodAdcPulseAmp = vector<Double_t>(MaxNumCerPmt, 0.0);
+ fGoodAdcPulseTime = vector<Double_t>(MaxNumCerPmt, 0.0);
+ fGoodAdcTdcDiffTime = vector<Double_t>(MaxNumCerPmt, 0.0);
InitArrays();
}
//_____________________________________________________________________________
-THcCherenkov::THcCherenkov( )
-{
+THcCherenkov::THcCherenkov() {
// Constructor
frAdcPedRaw = NULL;
frAdcPulseIntRaw = NULL;
@@ -93,25 +88,32 @@ THcCherenkov::THcCherenkov( )
}
//_____________________________________________________________________________
-THcCherenkov::~THcCherenkov()
-{
+THcCherenkov::~THcCherenkov() {
// Destructor
- delete frAdcPedRaw; frAdcPedRaw = NULL;
- delete frAdcPulseIntRaw; frAdcPulseIntRaw = NULL;
- delete frAdcPulseAmpRaw; frAdcPulseAmpRaw = NULL;
- delete frAdcPulseTimeRaw; frAdcPulseTimeRaw = NULL;
- delete frAdcPed; frAdcPed = NULL;
- delete frAdcPulseInt; frAdcPulseInt = NULL;
- delete frAdcPulseAmp; frAdcPulseAmp = NULL;
- delete frAdcPulseTime; frAdcPulseTime = NULL;
- delete fAdcErrorFlag; fAdcErrorFlag = NULL;
+ delete frAdcPedRaw;
+ frAdcPedRaw = NULL;
+ delete frAdcPulseIntRaw;
+ frAdcPulseIntRaw = NULL;
+ delete frAdcPulseAmpRaw;
+ frAdcPulseAmpRaw = NULL;
+ delete frAdcPulseTimeRaw;
+ frAdcPulseTimeRaw = NULL;
+ delete frAdcPed;
+ frAdcPed = NULL;
+ delete frAdcPulseInt;
+ frAdcPulseInt = NULL;
+ delete frAdcPulseAmp;
+ frAdcPulseAmp = NULL;
+ delete frAdcPulseTime;
+ frAdcPulseTime = NULL;
+ delete fAdcErrorFlag;
+ fAdcErrorFlag = NULL;
DeleteArrays();
}
//_____________________________________________________________________________
-void THcCherenkov::InitArrays()
-{
+void THcCherenkov::InitArrays() {
fGain = NULL;
fPedSum = NULL;
fPedSum2 = NULL;
@@ -122,64 +124,70 @@ void THcCherenkov::InitArrays()
fThresh = NULL;
}
//_____________________________________________________________________________
-void THcCherenkov::DeleteArrays()
-{
- delete [] fGain; fGain = NULL;
+void THcCherenkov::DeleteArrays() {
+ delete[] fGain;
+ fGain = NULL;
// 6 Gev variables
- delete [] fPedSum; fPedSum = NULL;
- delete [] fPedSum2; fPedSum2 = NULL;
- delete [] fPedLimit; fPedLimit = NULL;
- delete [] fPedMean; fPedMean = NULL;
- delete [] fPedCount; fPedCount = NULL;
- delete [] fPed; fPed = NULL;
- delete [] fThresh; fThresh = NULL;
-
- delete [] fAdcTimeWindowMin; fAdcTimeWindowMin = 0;
- delete [] fAdcTimeWindowMax; fAdcTimeWindowMax = 0;
- delete [] fRegionValue; fRegionValue = 0;
+ delete[] fPedSum;
+ fPedSum = NULL;
+ delete[] fPedSum2;
+ fPedSum2 = NULL;
+ delete[] fPedLimit;
+ fPedLimit = NULL;
+ delete[] fPedMean;
+ fPedMean = NULL;
+ delete[] fPedCount;
+ fPedCount = NULL;
+ delete[] fPed;
+ fPed = NULL;
+ delete[] fThresh;
+ fThresh = NULL;
+
+ delete[] fAdcTimeWindowMin;
+ fAdcTimeWindowMin = 0;
+ delete[] fAdcTimeWindowMax;
+ fAdcTimeWindowMax = 0;
+ delete[] fRegionValue;
+ fRegionValue = 0;
}
//_____________________________________________________________________________
-THaAnalysisObject::EStatus THcCherenkov::Init( const TDatime& date )
-{
+THaAnalysisObject::EStatus THcCherenkov::Init(const TDatime& date) {
// cout << "THcCherenkov::Init for: " << GetName() << endl;
string EngineDID = string(GetApparatus()->GetName()).substr(0, 1) + GetName();
std::transform(EngineDID.begin(), EngineDID.end(), EngineDID.begin(), ::toupper);
- if(gHcDetectorMap->FillMap(fDetMap, EngineDID.c_str()) < 0) {
+ if (gHcDetectorMap->FillMap(fDetMap, EngineDID.c_str()) < 0) {
static const char* const here = "Init()";
Error(Here(here), "Error filling detectormap for %s.", EngineDID.c_str());
return kInitError;
}
EStatus status;
- if((status = THaNonTrackingDetector::Init( date )))
- return fStatus=status;
+ if ((status = THaNonTrackingDetector::Init(date)))
+ return fStatus = status;
// Should probably put this in ReadDatabase as we will know the
// maximum number of hits after setting up the detector map
- InitHitList(fDetMap, "THcCherenkovHit", fDetMap->GetTotNumChan()+1,
- 0, fADC_RefTimeCut);
+ InitHitList(fDetMap, "THcCherenkovHit", fDetMap->GetTotNumChan() + 1, 0, fADC_RefTimeCut);
- THcHallCSpectrometer *app=dynamic_cast<THcHallCSpectrometer*>(GetApparatus());
- if( !app ||
- !(fglHod = dynamic_cast<THcHodoscope*>(app->GetDetector("hod"))) ) {
+ THcHallCSpectrometer* app = dynamic_cast<THcHallCSpectrometer*>(GetApparatus());
+ if (!app || !(fglHod = dynamic_cast<THcHodoscope*>(app->GetDetector("hod")))) {
static const char* const here = "ReadDatabase()";
- Warning(Here(here),"Hodoscope \"%s\" not found. ","hod");
+ Warning(Here(here), "Hodoscope \"%s\" not found. ", "hod");
}
- fPresentP = 0;
- THaVar* vpresent = gHaVars->Find(Form("%s.present",GetApparatus()->GetName()));
- if(vpresent) {
- fPresentP = (Bool_t *) vpresent->GetValuePointer();
+ fPresentP = 0;
+ THaVar* vpresent = gHaVars->Find(Form("%s.present", GetApparatus()->GetName()));
+ if (vpresent) {
+ fPresentP = (Bool_t*)vpresent->GetValuePointer();
}
return fStatus = kOK;
}
//_____________________________________________________________________________
-Int_t THcCherenkov::ReadDatabase( const TDatime& date )
-{
+Int_t THcCherenkov::ReadDatabase(const TDatime& date) {
// This function is called by THaDetectorBase::Init() once at the beginning
// of the analysis.
@@ -190,59 +198,54 @@ Int_t THcCherenkov::ReadDatabase( const TDatime& date )
CreateMissReportParms(prefix.c_str());
- fNRegions = 4; // Defualt if not set in paramter file
+ fNRegions = 4; // Defualt if not set in paramter file
- DBRequest list_1[] = {
- {"_tot_pmts", &fNelem, kInt},
- {"_num_regions", &fNRegions, kInt},
- {0}
- };
+ DBRequest list_1[] = {{"_tot_pmts", &fNelem, kInt}, {"_num_regions", &fNRegions, kInt}, {0}};
gHcParms->LoadParmValues(list_1, prefix.c_str());
Bool_t optional = true;
- _det_logger->info("Created Cherenkov detector {}.{} with {} PMTs",GetApparatus()->GetName(), GetName(), fNelem);
- //cout << "Created Cherenkov detector " << GetApparatus()->GetName() << "."
+ _det_logger->info("Created Cherenkov detector {}.{} with {} PMTs", GetApparatus()->GetName(),
+ GetName(), fNelem);
+ // cout << "Created Cherenkov detector " << GetApparatus()->GetName() << "."
// << GetName() << " with " << fNelem << " PMTs" << endl;
// 6 GeV pedestal paramters
- fPedLimit = new Int_t[fNelem];
- fGain = new Double_t[fNelem];
- fPedMean = new Double_t[fNelem];
- fAdcTimeWindowMin = new Double_t[fNelem];
- fAdcTimeWindowMax= new Double_t[fNelem];
+ fPedLimit = new Int_t[fNelem];
+ fGain = new Double_t[fNelem];
+ fPedMean = new Double_t[fNelem];
+ fAdcTimeWindowMin = new Double_t[fNelem];
+ fAdcTimeWindowMax = new Double_t[fNelem];
// Region parameters
fRegionsValueMax = fNRegions * 8;
fRegionValue = new Double_t[fRegionsValueMax];
- DBRequest list[]={
- {"_ped_limit", fPedLimit, kInt, (UInt_t) fNelem, optional},
- {"_adc_to_npe", fGain, kDouble, (UInt_t) fNelem},
- {"_red_chi2_min", &fRedChi2Min, kDouble},
- {"_red_chi2_max", &fRedChi2Max, kDouble},
- {"_beta_min", &fBetaMin, kDouble},
- {"_beta_max", &fBetaMax, kDouble},
- {"_enorm_min", &fENormMin, kDouble},
- {"_enorm_max", &fENormMax, kDouble},
- {"_dp_min", &fDpMin, kDouble},
- {"_dp_max", &fDpMax, kDouble},
- {"_mirror_zpos", &fMirrorZPos, kDouble},
- {"_npe_thresh", &fNpeThresh, kDouble},
- {"_debug_adc", &fDebugAdc, kInt, 0, 1},
- {"_adcTimeWindowMin", fAdcTimeWindowMin, kDouble,(UInt_t) fNelem,1},
- {"_adcTimeWindowMax", fAdcTimeWindowMax, kDouble, (UInt_t) fNelem,1},
- {"_adc_tdc_offset", &fAdcTdcOffset, kDouble, 0, 1},
- {"_region", &fRegionValue[0], kDouble, (UInt_t) fRegionsValueMax},
- {"_adcrefcut", &fADC_RefTimeCut, kInt, 0, 1},
- {0}
- };
- for (Int_t i=0;i<fNelem;i++) {
- fAdcTimeWindowMin[i]=-1000.;
- fAdcTimeWindowMax[i]=1000.;
+ DBRequest list[] = {{"_ped_limit", fPedLimit, kInt, (UInt_t)fNelem, optional},
+ {"_adc_to_npe", fGain, kDouble, (UInt_t)fNelem},
+ {"_red_chi2_min", &fRedChi2Min, kDouble},
+ {"_red_chi2_max", &fRedChi2Max, kDouble},
+ {"_beta_min", &fBetaMin, kDouble},
+ {"_beta_max", &fBetaMax, kDouble},
+ {"_enorm_min", &fENormMin, kDouble},
+ {"_enorm_max", &fENormMax, kDouble},
+ {"_dp_min", &fDpMin, kDouble},
+ {"_dp_max", &fDpMax, kDouble},
+ {"_mirror_zpos", &fMirrorZPos, kDouble},
+ {"_npe_thresh", &fNpeThresh, kDouble},
+ {"_debug_adc", &fDebugAdc, kInt, 0, 1},
+ {"_adcTimeWindowMin", fAdcTimeWindowMin, kDouble, (UInt_t)fNelem, 1},
+ {"_adcTimeWindowMax", fAdcTimeWindowMax, kDouble, (UInt_t)fNelem, 1},
+ {"_adc_tdc_offset", &fAdcTdcOffset, kDouble, 0, 1},
+ {"_region", &fRegionValue[0], kDouble, (UInt_t)fRegionsValueMax},
+ {"_adcrefcut", &fADC_RefTimeCut, kInt, 0, 1},
+ {0}};
+ for (Int_t i = 0; i < fNelem; i++) {
+ fAdcTimeWindowMin[i] = -1000.;
+ fAdcTimeWindowMax[i] = 1000.;
}
- fDebugAdc = 0; // Set ADC debug parameter to false unless set in parameter file
- fAdcTdcOffset = 0.0;
+ fDebugAdc = 0; // Set ADC debug parameter to false unless set in parameter file
+ fAdcTdcOffset = 0.0;
fADC_RefTimeCut = 0;
gHcParms->LoadParmValues((DBRequest*)&list, prefix.c_str());
@@ -266,66 +269,84 @@ Int_t THcCherenkov::ReadDatabase( const TDatime& date )
}
//_____________________________________________________________________________
-Int_t THcCherenkov::DefineVariables( EMode mode )
-{
+Int_t THcCherenkov::DefineVariables(EMode mode) {
// Initialize global variables for histogramming and tree
// cout << "THcCherenkov::DefineVariables called for: " << GetName() << endl;
- if( mode == kDefine && fIsSetup ) return kOK;
- fIsSetup = ( mode == kDefine );
+ if (mode == kDefine && fIsSetup)
+ return kOK;
+ fIsSetup = (mode == kDefine);
// Register variables in global list
if (fDebugAdc) {
RVarDef vars[] = {
- {"numAdcHits", "Number of ADC Hits Per PMT", "fNumAdcHits"}, // Cherenkov occupancy
- {"totNumAdcHits", "Total Number of ADC Hits", "fTotNumAdcHits"}, // Cherenkov multiplicity
- {"adcPedRaw", "Raw ADC pedestals", "frAdcPedRaw.THcSignalHit.GetData()"},
- {"adcPulseIntRaw", "Raw ADC pulse integrals", "frAdcPulseIntRaw.THcSignalHit.GetData()"},
- {"adcPulseAmpRaw", "Raw ADC pulse amplitudes", "frAdcPulseAmpRaw.THcSignalHit.GetData()"},
- {"adcPulseTimeRaw", "Raw ADC pulse times", "frAdcPulseTimeRaw.THcSignalHit.GetData()"},
- {"adcPed", "ADC pedestals", "frAdcPed.THcSignalHit.GetData()"},
- {"adcPulseInt", "ADC pulse integrals", "frAdcPulseInt.THcSignalHit.GetData()"},
- {"adcPulseAmp", "ADC pulse amplitudes", "frAdcPulseAmp.THcSignalHit.GetData()"},
- {"adcPulseTime", "ADC pulse times", "frAdcPulseTime.THcSignalHit.GetData()"},
- { 0 }
- };
- DefineVarsFromList( vars, mode);
- } //end debug statement
+ {"numAdcHits", "Number of ADC Hits Per PMT", "fNumAdcHits"}, // Cherenkov occupancy
+ {"totNumAdcHits", "Total Number of ADC Hits", "fTotNumAdcHits"}, // Cherenkov multiplicity
+ {"adcPedRaw", "Raw ADC pedestals", "frAdcPedRaw.THcSignalHit.GetData()"},
+ {"adcPulseIntRaw", "Raw ADC pulse integrals", "frAdcPulseIntRaw.THcSignalHit.GetData()"},
+ {"adcPulseAmpRaw", "Raw ADC pulse amplitudes", "frAdcPulseAmpRaw.THcSignalHit.GetData()"},
+ {"adcPulseTimeRaw", "Raw ADC pulse times", "frAdcPulseTimeRaw.THcSignalHit.GetData()"},
+ {"adcPed", "ADC pedestals", "frAdcPed.THcSignalHit.GetData()"},
+ {"adcPulseInt", "ADC pulse integrals", "frAdcPulseInt.THcSignalHit.GetData()"},
+ {"adcPulseAmp", "ADC pulse amplitudes", "frAdcPulseAmp.THcSignalHit.GetData()"},
+ {"adcPulseTime", "ADC pulse times", "frAdcPulseTime.THcSignalHit.GetData()"},
+ {0}};
+ DefineVarsFromList(vars, mode);
+ } // end debug statement
RVarDef vars[] = {
- {"adcCounter", "ADC counter numbers", "frAdcPulseIntRaw.THcSignalHit.GetPaddleNumber()"},
- {"adcErrorFlag", "Error Flag for When FPGA Fails", "fAdcErrorFlag.THcSignalHit.GetData()"},
- {"numGoodAdcHits", "Number of Good ADC Hits Per PMT", "fNumGoodAdcHits"}, // Cherenkov occupancy
- {"totNumGoodAdcHits", "Total Number of Good ADC Hits", "fTotNumGoodAdcHits"}, // Cherenkov multiplicity
- {"numTracksMatched", "Number of Tracks Matched Per Region", "fNumTracksMatched"},
- {"numTracksFired", "Number of Tracks that Fired Per Region", "fNumTracksFired"},
- {"totNumTracksMatched", "Total Number of Tracks Matched Per Region", "fTotNumTracksMatched"},
- {"totNumTracksFired", "Total Number of Tracks that Fired", "fTotNumTracksFired"},
-
- {"xAtCer", "Track X at Cherenkov mirror", "fXAtCer"},
- {"yAtCer", "Track Y at Cherenkov mirror", "fYAtCer"},
-
- {"npe", "Number of PEs", "fNpe"},
- {"npeSum", "Total Number of PEs", "fNpeSum"},
-
- {"goodAdcPed", "Good ADC pedestals", "fGoodAdcPed"},
- {"goodAdcMult", "Good ADC Multiplicity", "fGoodAdcMult"},
- {"goodAdcHitUsed", "Good ADC Hit Used", "fGoodAdcHitUsed"},
- {"goodAdcPulseInt", "Good ADC pulse integrals", "fGoodAdcPulseInt"},
- {"goodAdcPulseIntRaw", "Good ADC raw pulse integrals", "fGoodAdcPulseIntRaw"},
- {"goodAdcPulseAmp", "Good ADC pulse amplitudes", "fGoodAdcPulseAmp"},
- {"goodAdcPulseTime", "Good ADC pulse times", "fGoodAdcPulseTime"},
- {"goodAdcTdcDiffTime", "Good Hodo Start - ADC pulse times", "fGoodAdcTdcDiffTime"},
- { 0 }
- };
+ {"adcCounter", "ADC counter numbers", "frAdcPulseIntRaw.THcSignalHit.GetPaddleNumber()"},
+ {"adcErrorFlag", "Error Flag for When FPGA Fails", "fAdcErrorFlag.THcSignalHit.GetData()"},
+ {"numGoodAdcHits", "Number of Good ADC Hits Per PMT",
+ "fNumGoodAdcHits"}, // Cherenkov occupancy
+ {"totNumGoodAdcHits", "Total Number of Good ADC Hits",
+ "fTotNumGoodAdcHits"}, // Cherenkov multiplicity
+ {"numTracksMatched", "Number of Tracks Matched Per Region", "fNumTracksMatched"},
+ {"numTracksFired", "Number of Tracks that Fired Per Region", "fNumTracksFired"},
+ {"totNumTracksMatched", "Total Number of Tracks Matched Per Region", "fTotNumTracksMatched"},
+ {"totNumTracksFired", "Total Number of Tracks that Fired", "fTotNumTracksFired"},
+
+ {"xAtCer", "Track X at Cherenkov mirror", "fXAtCer"},
+ {"yAtCer", "Track Y at Cherenkov mirror", "fYAtCer"},
+
+ {"npe", "Number of PEs", "fNpe"},
+ {"npeSum", "Total Number of PEs", "fNpeSum"},
+
+ {"goodAdcPed", "Good ADC pedestals", "fGoodAdcPed"},
+ {"goodAdcMult", "Good ADC Multiplicity", "fGoodAdcMult"},
+ {"goodAdcHitUsed", "Good ADC Hit Used", "fGoodAdcHitUsed"},
+ {"goodAdcPulseInt", "Good ADC pulse integrals", "fGoodAdcPulseInt"},
+ {"goodAdcPulseIntRaw", "Good ADC raw pulse integrals", "fGoodAdcPulseIntRaw"},
+ {"goodAdcPulseAmp", "Good ADC pulse amplitudes", "fGoodAdcPulseAmp"},
+ {"goodAdcPulseTime", "Good ADC pulse times", "fGoodAdcPulseTime"},
+ {"goodAdcTdcDiffTime", "Good Hodo Start - ADC pulse times", "fGoodAdcTdcDiffTime"},
+ {0}};
return DefineVarsFromList(vars, mode);
}
//_____________________________________________________________________________
-inline
-void THcCherenkov::Clear(Option_t* opt)
-{
+
+Int_t THcCherenkov::ManualInitTree(TTree* t) {
+ // The most direct path to the output tree!!!
+ std::string app_name = GetApparatus()->GetName();
+ std::string det_name = GetName();
+ // if (t) {
+ // std::string branch_name = (app_name + "_" + det_name + "_data");
+ // _det_logger->info("THcHodoscope::ManualInitTree : Adding branch, {}, to output tree",
+ // branch_name); t->Branch(branch_name.c_str(), &_basic_data, 32000, 99);
+ //}
+ if (t) {
+ std::string branch_name = (app_name + "_" + det_name + "_waveforms");
+ _det_logger->info("THcCherenkov::ManualInitTree : Adding branch, {}, to output tree",
+ branch_name);
+ t->Branch(branch_name.c_str(), &_waveforms, 32000, 99);
+ }
+ return 0;
+}
+//_____________________________________________________________________________
+
+void THcCherenkov::Clear(Option_t* opt) {
// Clear the hit lists
fNhits = 0;
fTotNumAdcHits = 0;
@@ -359,68 +380,75 @@ void THcCherenkov::Clear(Option_t* opt)
fNumTracksFired.at(ielem) = 0;
for (UInt_t ielem = 0; ielem < fGoodAdcPed.size(); ielem++) {
fGoodAdcPed.at(ielem) = 0.0;
- fGoodAdcMult.at(ielem) = 0.0;
- fGoodAdcHitUsed.at(ielem) = 0.0;
+ fGoodAdcMult.at(ielem) = 0.0;
+ fGoodAdcHitUsed.at(ielem) = 0.0;
fGoodAdcPulseInt.at(ielem) = 0.0;
fGoodAdcPulseIntRaw.at(ielem) = 0.0;
fGoodAdcPulseAmp.at(ielem) = 0.0;
fGoodAdcPulseTime.at(ielem) = kBig;
- fGoodAdcTdcDiffTime.at(ielem) = kBig;
+ fGoodAdcTdcDiffTime.at(ielem) = kBig;
fNpe.at(ielem) = 0.0;
}
-
}
//_____________________________________________________________________________
-Int_t THcCherenkov::Decode( const THaEvData& evdata )
-{
+
+Int_t THcCherenkov::Decode(const THaEvData& evdata) {
// Get the Hall C style hitlist (fRawHitList) for this event
- Bool_t present = kTRUE; // Suppress reference time warnings
- if(fPresentP) { // if this spectrometer not part of trigger
+ Bool_t present = kTRUE; // Suppress reference time warnings
+ if (fPresentP) { // if this spectrometer not part of trigger
present = *fPresentP;
}
fNhits = DecodeToHitList(evdata, !present);
- if(gHaCuts->Result("Pedestal_event")) {
+ if (gHaCuts->Result("Pedestal_event")) {
AccumulatePedestals(fRawHitList);
- fAnalyzePedestals = 1; // Analyze pedestals first normal events
- return(0);
+ fAnalyzePedestals = 1; // Analyze pedestals first normal events
+ return (0);
}
- if(fAnalyzePedestals) {
+ if (fAnalyzePedestals) {
CalculatePedestals();
- fAnalyzePedestals = 0; // Don't analyze pedestals next event
+ fAnalyzePedestals = 0; // Don't analyze pedestals next event
}
Int_t ihit = 0;
UInt_t nrAdcHits = 0;
- while(ihit < fNhits) {
+ while (ihit < fNhits) {
- THcCherenkovHit* hit = (THcCherenkovHit*) fRawHitList->At(ihit);
- Int_t npmt = hit->fCounter;
- THcRawAdcHit& rawAdcHit = hit->GetRawAdcHitPos();
+ THcCherenkovHit* hit = (THcCherenkovHit*)fRawHitList->At(ihit);
+ Int_t npmt = hit->fCounter;
+ THcRawAdcHit& rawAdcHit = hit->GetRawAdcHitPos();
for (UInt_t thit = 0; thit < rawAdcHit.GetNPulses(); thit++) {
- ((THcSignalHit*) frAdcPedRaw->ConstructedAt(nrAdcHits))->Set(npmt, rawAdcHit.GetPedRaw());
- ((THcSignalHit*) frAdcPed->ConstructedAt(nrAdcHits))->Set(npmt, rawAdcHit.GetPed());
+ ((THcSignalHit*)frAdcPedRaw->ConstructedAt(nrAdcHits))->Set(npmt, rawAdcHit.GetPedRaw());
+ ((THcSignalHit*)frAdcPed->ConstructedAt(nrAdcHits))->Set(npmt, rawAdcHit.GetPed());
- ((THcSignalHit*) frAdcPulseIntRaw->ConstructedAt(nrAdcHits))->Set(npmt, rawAdcHit.GetPulseIntRaw(thit));
- ((THcSignalHit*) frAdcPulseInt->ConstructedAt(nrAdcHits))->Set(npmt, rawAdcHit.GetPulseInt(thit));
+ ((THcSignalHit*)frAdcPulseIntRaw->ConstructedAt(nrAdcHits))
+ ->Set(npmt, rawAdcHit.GetPulseIntRaw(thit));
+ ((THcSignalHit*)frAdcPulseInt->ConstructedAt(nrAdcHits))
+ ->Set(npmt, rawAdcHit.GetPulseInt(thit));
- ((THcSignalHit*) frAdcPulseAmpRaw->ConstructedAt(nrAdcHits))->Set(npmt, rawAdcHit.GetPulseAmpRaw(thit));
- ((THcSignalHit*) frAdcPulseAmp->ConstructedAt(nrAdcHits))->Set(npmt, rawAdcHit.GetPulseAmp(thit));
+ ((THcSignalHit*)frAdcPulseAmpRaw->ConstructedAt(nrAdcHits))
+ ->Set(npmt, rawAdcHit.GetPulseAmpRaw(thit));
+ ((THcSignalHit*)frAdcPulseAmp->ConstructedAt(nrAdcHits))
+ ->Set(npmt, rawAdcHit.GetPulseAmp(thit));
- ((THcSignalHit*) frAdcPulseTimeRaw->ConstructedAt(nrAdcHits))->Set(npmt, rawAdcHit.GetPulseTimeRaw(thit));
- ((THcSignalHit*) frAdcPulseTime->ConstructedAt(nrAdcHits))->Set(npmt, rawAdcHit.GetPulseTime(thit)+fAdcTdcOffset);
+ ((THcSignalHit*)frAdcPulseTimeRaw->ConstructedAt(nrAdcHits))
+ ->Set(npmt, rawAdcHit.GetPulseTimeRaw(thit));
+ ((THcSignalHit*)frAdcPulseTime->ConstructedAt(nrAdcHits))
+ ->Set(npmt, rawAdcHit.GetPulseTime(thit) + fAdcTdcOffset);
- if (rawAdcHit.GetPulseAmpRaw(thit) > 0) ((THcSignalHit*) fAdcErrorFlag->ConstructedAt(nrAdcHits))->Set(npmt, 0);
- if (rawAdcHit.GetPulseAmpRaw(thit) <= 0) ((THcSignalHit*) fAdcErrorFlag->ConstructedAt(nrAdcHits))->Set(npmt, 1);
+ if (rawAdcHit.GetPulseAmpRaw(thit) > 0)
+ ((THcSignalHit*)fAdcErrorFlag->ConstructedAt(nrAdcHits))->Set(npmt, 0);
+ if (rawAdcHit.GetPulseAmpRaw(thit) <= 0)
+ ((THcSignalHit*)fAdcErrorFlag->ConstructedAt(nrAdcHits))->Set(npmt, 1);
++nrAdcHits;
fTotNumAdcHits++;
- fNumAdcHits.at(npmt-1) = npmt;
+ fNumAdcHits.at(npmt - 1) = npmt;
}
ihit++;
}
@@ -428,47 +456,43 @@ Int_t THcCherenkov::Decode( const THaEvData& evdata )
}
//_____________________________________________________________________________
-Int_t THcCherenkov::ApplyCorrections( void )
-{
- return(0);
-}
+Int_t THcCherenkov::ApplyCorrections(void) { return (0); }
//_____________________________________________________________________________
-Int_t THcCherenkov::CoarseProcess( TClonesArray& )
-{
+Int_t THcCherenkov::CoarseProcess(TClonesArray&) {
Double_t StartTime = 0.0;
- if( fglHod ) StartTime = fglHod->GetStartTime();
+ if (fglHod)
+ StartTime = fglHod->GetStartTime();
// Loop over the elements in the TClonesArray
- for(Int_t ielem = 0; ielem < frAdcPulseInt->GetEntries(); ielem++) {
-
- Int_t npmt = ((THcSignalHit*) frAdcPulseInt->ConstructedAt(ielem))->GetPaddleNumber() - 1;
- Double_t pulsePed = ((THcSignalHit*) frAdcPed->ConstructedAt(ielem))->GetData();
- Double_t pulseInt = ((THcSignalHit*) frAdcPulseInt->ConstructedAt(ielem))->GetData();
- Double_t pulseIntRaw = ((THcSignalHit*) frAdcPulseIntRaw->ConstructedAt(ielem))->GetData();
- Double_t pulseAmp = ((THcSignalHit*) frAdcPulseAmp->ConstructedAt(ielem))->GetData();
- Double_t pulseTime = ((THcSignalHit*) frAdcPulseTime->ConstructedAt(ielem))->GetData();
- Double_t adctdcdiffTime = StartTime-pulseTime;
- Bool_t errorFlag = ((THcSignalHit*) fAdcErrorFlag->ConstructedAt(ielem))->GetData();
- Bool_t pulseTimeCut = adctdcdiffTime > fAdcTimeWindowMin[npmt] && adctdcdiffTime < fAdcTimeWindowMax[npmt];
-
-
- if (!errorFlag)
- {
- fGoodAdcMult.at(npmt) += 1;
- }
+ for (Int_t ielem = 0; ielem < frAdcPulseInt->GetEntries(); ielem++) {
+
+ Int_t npmt = ((THcSignalHit*)frAdcPulseInt->ConstructedAt(ielem))->GetPaddleNumber() - 1;
+ Double_t pulsePed = ((THcSignalHit*)frAdcPed->ConstructedAt(ielem))->GetData();
+ Double_t pulseInt = ((THcSignalHit*)frAdcPulseInt->ConstructedAt(ielem))->GetData();
+ Double_t pulseIntRaw = ((THcSignalHit*)frAdcPulseIntRaw->ConstructedAt(ielem))->GetData();
+ Double_t pulseAmp = ((THcSignalHit*)frAdcPulseAmp->ConstructedAt(ielem))->GetData();
+ Double_t pulseTime = ((THcSignalHit*)frAdcPulseTime->ConstructedAt(ielem))->GetData();
+ Double_t adctdcdiffTime = StartTime - pulseTime;
+ Bool_t errorFlag = ((THcSignalHit*)fAdcErrorFlag->ConstructedAt(ielem))->GetData();
+ Bool_t pulseTimeCut =
+ adctdcdiffTime > fAdcTimeWindowMin[npmt] && adctdcdiffTime < fAdcTimeWindowMax[npmt];
+
+ if (!errorFlag) {
+ fGoodAdcMult.at(npmt) += 1;
+ }
// By default, the last hit within the timing cut will be considered "good"
if (!errorFlag && pulseTimeCut) {
fGoodAdcPed.at(npmt) = pulsePed;
- fGoodAdcHitUsed.at(npmt) = ielem+1;
+ fGoodAdcHitUsed.at(npmt) = ielem + 1;
fGoodAdcPulseInt.at(npmt) = pulseInt;
fGoodAdcPulseIntRaw.at(npmt) = pulseIntRaw;
fGoodAdcPulseAmp.at(npmt) = pulseAmp;
fGoodAdcPulseTime.at(npmt) = pulseTime;
- fGoodAdcTdcDiffTime.at(npmt) = adctdcdiffTime;
+ fGoodAdcTdcDiffTime.at(npmt) = adctdcdiffTime;
- fNpe.at(npmt) = fGain[npmt]*fGoodAdcPulseInt.at(npmt);
+ fNpe.at(npmt) = fGain[npmt] * fGoodAdcPulseInt.at(npmt);
fNpeSum += fNpe.at(npmt);
fTotNumGoodAdcHits++;
@@ -479,83 +503,88 @@ Int_t THcCherenkov::CoarseProcess( TClonesArray& )
}
//_____________________________________________________________________________
-Int_t THcCherenkov::FineProcess( TClonesArray& tracks )
-{
+Int_t THcCherenkov::FineProcess(TClonesArray& tracks) {
Int_t nTracks = tracks.GetLast() + 1;
for (Int_t itrack = 0; itrack < nTracks; itrack++) {
- THaTrack* track = dynamic_cast<THaTrack*> (tracks[itrack]);
- if (track->GetIndex() != 0) continue; // Select the best track
+ THaTrack* track = dynamic_cast<THaTrack*>(tracks[itrack]);
+ if (track->GetIndex() != 0)
+ continue; // Select the best track
Double_t trackChi2 = track->GetChi2();
Int_t trackNDoF = track->GetNDoF();
- Double_t trackRedChi2 = trackChi2/trackNDoF;
+ Double_t trackRedChi2 = trackChi2 / trackNDoF;
Double_t trackBeta = track->GetBeta();
Double_t trackEnergy = track->GetEnergy();
Double_t trackMom = track->GetP();
Double_t trackDp = track->GetDp();
- Double_t trackENorm = trackEnergy/trackMom;
+ Double_t trackENorm = trackEnergy / trackMom;
Double_t trackXfp = track->GetX();
Double_t trackYfp = track->GetY();
Double_t trackTheta = track->GetTheta();
Double_t trackPhi = track->GetPhi();
Bool_t trackRedChi2Cut = trackRedChi2 > fRedChi2Min && trackRedChi2 < fRedChi2Max;
- Bool_t trackBetaCut = trackBeta > fBetaMin && trackBeta < fBetaMax;
- Bool_t trackENormCut = trackENorm > fENormMin && trackENorm < fENormMax;
- Bool_t trackDpCut = trackDp > fDpMin && trackDp < fDpMax;
- fXAtCer = trackXfp + trackTheta * fMirrorZPos;
- fYAtCer = trackYfp + trackPhi * fMirrorZPos;
+ Bool_t trackBetaCut = trackBeta > fBetaMin && trackBeta < fBetaMax;
+ Bool_t trackENormCut = trackENorm > fENormMin && trackENorm < fENormMax;
+ Bool_t trackDpCut = trackDp > fDpMin && trackDp < fDpMax;
+ fXAtCer = trackXfp + trackTheta * fMirrorZPos;
+ fYAtCer = trackYfp + trackPhi * fMirrorZPos;
if (trackRedChi2Cut && trackBetaCut && trackENormCut && trackDpCut) {
- // Project the track to the Cherenkov mirror planes
-
- // cout << "Cherenkov Detector: " << GetName() << " has fNRegions = " << fNRegions << endl;
- // cout << "nTracks = " << nTracks << "\t" << "trackChi2 = " << trackChi2
- // << "\t" << "trackNDof = " << trackNDoF << "\t" << "trackRedChi2 = " << trackRedChi2 << endl;
- // cout << "trackBeta = " << trackBeta << "\t" << "trackEnergy = " << trackEnergy << "\t"
- // << "trackMom = " << trackMom << "\t" << "trackENorm = " << trackENorm << endl;
- // cout << "trackXfp = " << trackXfp << "\t" << "trackYfp = " << trackYfp << "\t"
- // << "trackTheta = " << trackTheta << "\t" << "trackPhi = " << trackPhi << endl;
- // cout << "fMirrorZPos = " << fMirrorZPos << "\t" << "fXAtCer = " << fXAtCer << "\t" << "fYAtCer = " << fYAtCer << endl;
- // cout << "=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:" << endl;
-
- for (Int_t iregion = 0; iregion < fNRegions; iregion++) {
-
- if ((TMath::Abs(fRegionValue[GetIndex(iregion, 0)] - fXAtCer) < fRegionValue[GetIndex(iregion, 4)]) &&
- (TMath::Abs(fRegionValue[GetIndex(iregion, 1)] - fYAtCer) < fRegionValue[GetIndex(iregion, 5)]) &&
- (TMath::Abs(fRegionValue[GetIndex(iregion, 2)] - trackTheta) < fRegionValue[GetIndex(iregion, 6)]) &&
- (TMath::Abs(fRegionValue[GetIndex(iregion, 3)] - trackPhi) < fRegionValue[GetIndex(iregion, 7)])) {
-
- fTotNumTracksMatched++;
- fNumTracksMatched.at(iregion) = iregion + 1;
-
- if (fNpeSum > fNpeThresh) {
- fTotNumTracksFired++;
- fNumTracksFired.at(iregion) = iregion + 1;
- } // NPE threshold cut
- } // Regional cuts
- } // Loop over regions
- } // Tracking cuts
- } // Track loop
+ // Project the track to the Cherenkov mirror planes
+
+ // cout << "Cherenkov Detector: " << GetName() << " has fNRegions = " << fNRegions << endl;
+ // cout << "nTracks = " << nTracks << "\t" << "trackChi2 = " << trackChi2
+ // << "\t" << "trackNDof = " << trackNDoF << "\t" << "trackRedChi2 = " <<
+ // trackRedChi2 << endl; cout << "trackBeta = " << trackBeta << "\t" << "trackEnergy = " <<
+ // trackEnergy << "\t"
+ // << "trackMom = " << trackMom << "\t" << "trackENorm = " << trackENorm << endl;
+ // cout << "trackXfp = " << trackXfp << "\t" << "trackYfp = " << trackYfp << "\t"
+ // << "trackTheta = " << trackTheta << "\t" << "trackPhi = " << trackPhi << endl;
+ // cout << "fMirrorZPos = " << fMirrorZPos << "\t" << "fXAtCer = " << fXAtCer << "\t" <<
+ // "fYAtCer = " << fYAtCer << endl; cout <<
+ // "=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:" << endl;
+
+ for (Int_t iregion = 0; iregion < fNRegions; iregion++) {
+
+ if ((TMath::Abs(fRegionValue[GetIndex(iregion, 0)] - fXAtCer) <
+ fRegionValue[GetIndex(iregion, 4)]) &&
+ (TMath::Abs(fRegionValue[GetIndex(iregion, 1)] - fYAtCer) <
+ fRegionValue[GetIndex(iregion, 5)]) &&
+ (TMath::Abs(fRegionValue[GetIndex(iregion, 2)] - trackTheta) <
+ fRegionValue[GetIndex(iregion, 6)]) &&
+ (TMath::Abs(fRegionValue[GetIndex(iregion, 3)] - trackPhi) <
+ fRegionValue[GetIndex(iregion, 7)])) {
+
+ fTotNumTracksMatched++;
+ fNumTracksMatched.at(iregion) = iregion + 1;
+
+ if (fNpeSum > fNpeThresh) {
+ fTotNumTracksFired++;
+ fNumTracksFired.at(iregion) = iregion + 1;
+ } // NPE threshold cut
+ } // Regional cuts
+ } // Loop over regions
+ } // Tracking cuts
+ } // Track loop
return 0;
}
//_____________________________________________________________________________
-void THcCherenkov::InitializePedestals()
-{
+void THcCherenkov::InitializePedestals() {
fNPedestalEvents = 0;
- fMinPeds = 500; // In engine, this is set in parameter file
- fPedSum = new Int_t [fNelem];
- fPedSum2 = new Int_t [fNelem];
- fPedCount = new Int_t [fNelem];
- fPed = new Double_t [fNelem];
- fThresh = new Double_t [fNelem];
- for(Int_t i = 0; i < fNelem; i++) {
+ fMinPeds = 500; // In engine, this is set in parameter file
+ fPedSum = new Int_t[fNelem];
+ fPedSum2 = new Int_t[fNelem];
+ fPedCount = new Int_t[fNelem];
+ fPed = new Double_t[fNelem];
+ fThresh = new Double_t[fNelem];
+ for (Int_t i = 0; i < fNelem; i++) {
fPedSum[i] = 0;
fPedSum2[i] = 0;
fPedCount[i] = 0;
@@ -563,25 +592,24 @@ void THcCherenkov::InitializePedestals()
}
//_____________________________________________________________________________
-void THcCherenkov::AccumulatePedestals(TClonesArray* rawhits)
-{
+void THcCherenkov::AccumulatePedestals(TClonesArray* rawhits) {
// Extract data from the hit list, accumulating into arrays for
// calculating pedestals
- Int_t nrawhits = rawhits->GetLast()+1;
+ Int_t nrawhits = rawhits->GetLast() + 1;
Int_t ihit = 0;
- while(ihit < nrawhits) {
- THcCherenkovHit* hit = (THcCherenkovHit *) rawhits->At(ihit);
+ while (ihit < nrawhits) {
+ THcCherenkovHit* hit = (THcCherenkovHit*)rawhits->At(ihit);
Int_t element = hit->fCounter - 1;
- Int_t nadc = hit->GetRawAdcHitPos().GetPulseIntRaw();
- if(nadc <= fPedLimit[element]) {
- fPedSum[element] += nadc;
- fPedSum2[element] += nadc*nadc;
+ Int_t nadc = hit->GetRawAdcHitPos().GetPulseIntRaw();
+ if (nadc <= fPedLimit[element]) {
+ fPedSum[element] += nadc;
+ fPedSum2[element] += nadc * nadc;
fPedCount[element]++;
- if(fPedCount[element] == fMinPeds/5) {
- fPedLimit[element] = 100 + fPedSum[element]/fPedCount[element];
+ if (fPedCount[element] == fMinPeds / 5) {
+ fPedLimit[element] = 100 + fPedSum[element] / fPedCount[element];
}
}
ihit++;
@@ -593,62 +621,51 @@ void THcCherenkov::AccumulatePedestals(TClonesArray* rawhits)
}
//_____________________________________________________________________________
-void THcCherenkov::CalculatePedestals()
-{
+void THcCherenkov::CalculatePedestals() {
// Use the accumulated pedestal data to calculate pedestals
// Later add check to see if pedestals have drifted ("Danger Will Robinson!")
// cout << "Plane: " << fPlaneNum << endl;
- for(Int_t i=0; i<fNelem;i++) {
+ for (Int_t i = 0; i < fNelem; i++) {
// PMT tubes
- fPed[i] = ((Double_t) fPedSum[i]) / TMath::Max(1, fPedCount[i]);
+ fPed[i] = ((Double_t)fPedSum[i]) / TMath::Max(1, fPedCount[i]);
fThresh[i] = fPed[i] + 15;
// Just a copy for now, but allow the possibility that fXXXPedMean is set
// in a parameter file and only overwritten if there is a sufficient number of
// pedestal events. (So that pedestals are sensible even if the pedestal events were
// not acquired.)
- if(fMinPeds > 0) {
- if(fPedCount[i] > fMinPeds) {
- fPedMean[i] = fPed[i];
+ if (fMinPeds > 0) {
+ if (fPedCount[i] > fMinPeds) {
+ fPedMean[i] = fPed[i];
}
}
}
// cout << " " << endl;
-
}
//_____________________________________________________________________________
-Int_t THcCherenkov::GetIndex(Int_t nRegion, Int_t nValue)
-{
- return fNRegions * nValue + nRegion;
-}
-
+Int_t THcCherenkov::GetIndex(Int_t nRegion, Int_t nValue) { return fNRegions * nValue + nRegion; }
//_____________________________________________________________________________
-void THcCherenkov::Print(const Option_t* opt) const
-{
+void THcCherenkov::Print(const Option_t* opt) const {
THaNonTrackingDetector::Print(opt);
// Print out the pedestals
cout << endl;
cout << "Cherenkov Pedestals" << endl;
// Ahmed
cout << "No. ADC" << endl;
- for(Int_t i=0; i<fNelem; i++)
+ for (Int_t i = 0; i < fNelem; i++)
cout << " " << i << " " << fPed[i] << endl;
cout << endl;
}
//_____________________________________________________________________________
-Double_t THcCherenkov::GetCerNPE()
-{
- return fNpeSum;
-}
+Double_t THcCherenkov::GetCerNPE() { return fNpeSum; }
//_____________________________________________________________________________
-Int_t THcCherenkov::End(THaRunBase* run)
-{
+Int_t THcCherenkov::End(THaRunBase* run) {
MissReport(Form("%s.%s", GetApparatus()->GetName(), GetName()));
return 0;
}
ClassImp(THcCherenkov)
-////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////
diff --git a/src/THcCherenkov.h b/src/THcCherenkov.h
index 53ff2d6921956f74fdfebe3157ba03a89f418766..12606074011646c0cba7048a243c7e4b249084c0 100644
--- a/src/THcCherenkov.h
+++ b/src/THcCherenkov.h
@@ -13,10 +13,14 @@
#include "THcCherenkovHit.h"
#include "hcana/Logger.h"
+#include "hcana/HallC_Data.h"
class THcHodoscope;
class THcCherenkov : public THaNonTrackingDetector, public THcHitList {
+public:
+
+ std::vector<hallc::data::PulseWaveForm> _waveforms;
using vec = std::vector<Double_t>;
@@ -31,6 +35,7 @@ class THcCherenkov : public THaNonTrackingDetector, public THcHitList {
virtual Int_t Decode(const THaEvData&);
virtual Int_t ReadDatabase(const TDatime& date);
virtual Int_t DefineVariables(EMode mode = kDefine);
+ virtual Int_t ManualInitTree( TTree* t );
virtual Int_t CoarseProcess(TClonesArray& tracks);
virtual Int_t FineProcess(TClonesArray& tracks);
virtual Int_t ApplyCorrections( void );
diff --git a/src/THcHodoscope.cxx b/src/THcHodoscope.cxx
index a4e4ce53fc3429f9041bddf5d451d3005085efa9..f1856c64372bc2df1ebf67cac57d991dfd94c2ee 100644
--- a/src/THcHodoscope.cxx
+++ b/src/THcHodoscope.cxx
@@ -574,8 +574,8 @@ Int_t THcHodoscope::ManualInitTree( TTree* t ){
std::string app_name = GetApparatus()->GetName();
std::string det_name = GetName();
std::string branch_name = (app_name + "_" + det_name + "_data");
- _det_logger->info("THcHodoscope::ManualInitTree : Adding branch, {}, to output tree", branch_name);
if (t) {
+ _det_logger->info("THcHodoscope::ManualInitTree : Adding branch, {}, to output tree", branch_name);
t->Branch(branch_name.c_str(), &_basic_data, 32000, 99);
}
return 0;
diff --git a/src/THcHodoscope.h b/src/THcHodoscope.h
index c7c0a1e3c182ff432854368c59e2ad6de1247447..8a0a1c55ef6d021f5a533f04181db84d74c2429c 100644
--- a/src/THcHodoscope.h
+++ b/src/THcHodoscope.h
@@ -32,12 +32,14 @@
#include <fstream>
#include "hcana/Logger.h"
+#include "hcana/HallC_Data.h"
class THaScCalib;
namespace hallc {
namespace data {
+
struct Hodoscope {
double fBeta = 0.0;
double fBetaNoTrk = 0.0;
diff --git a/src/include/HallC_LinkDef.h b/src/include/HallC_LinkDef.h
index aae86159850b50087293a930fe2d4fc6326aea25..2ffec3df0ab1969ae77aba7cc9a17fccc74055bd 100644
--- a/src/include/HallC_LinkDef.h
+++ b/src/include/HallC_LinkDef.h
@@ -17,6 +17,10 @@
#pragma link C++ class hallc::data::Hodoscope+;
#pragma link C++ class hallc::data::DriftChamber+;
+#pragma link C++ class hallc::data::PulseWaveForm+;
+#pragma link C++ class std::vector<hallc::data::PulseWaveForm>+;
+
+
#pragma link C++ global gHcParms;
#pragma link C++ global gHcDetectorMap;
diff --git a/src/include/hcana/HallC_Data.h b/src/include/hcana/HallC_Data.h
new file mode 100644
index 0000000000000000000000000000000000000000..dab221a32043ef56fac65bcdc6552420c84ba724
--- /dev/null
+++ b/src/include/hcana/HallC_Data.h
@@ -0,0 +1,17 @@
+#ifndef hallc_HallC_Data_HH
+#define hallc_HallC_Data_HH
+
+#include <array>
+
+namespace hallc {
+ namespace data {
+
+ struct PulseWaveForm {
+ std::array<float,200> _buffer;
+ ClassDef(PulseWaveForm,1)
+ };
+
+ }
+}
+
+#endif