diff --git a/src/THcHodoscope.cxx b/src/THcHodoscope.cxx
index 36ae845b6f33ca7ec78d0d42f09607351c5b02f9..ac85bd85fac0cbe330cc1a3aa85120c08a91a6d9 100644
--- a/src/THcHodoscope.cxx
+++ b/src/THcHodoscope.cxx
@@ -29,6 +29,7 @@
#include <cstdio>
#include <cstdlib>
#include <iostream>
+#include <fstream>
using namespace std;
@@ -65,17 +66,26 @@ void THcHodoscope::Setup(const char* name, const char* description)
if( IsZombie()) return;
fDebug = 1; // Keep this at one while we're working on the code
- fNPlanes = 4; // Should get this from parameters
+ // reading the number of planes from a param list! Still kludgy but it works
+ system("rm tmp.txt; cat PARAM/hhodo.param |grep hhodo_slop|wc -w>tmp.txt");
+ ifstream tmpfile;
+ tmpfile.open("tmp.txt");
+ tmpfile >> fNPlanes;
+ tmpfile.close();
+ fNPlanes = fNPlanes-2;
+ cout << "fNPlanes = " << fNPlanes << endl;
+ // fNPlanes = 4; // Should get this from parameters -> Now we do! GN
+ // Plane names
fPlaneNames = new char* [fNPlanes];
for(Int_t i=0;i<fNPlanes;i++) {fPlaneNames[i] = new char[3];}
// Should get the plane names from parameters.
+ // could try this: grep _zpos PARAM/hhodo.pos | sed 's/\_/\ /g' | awk '{print $2}'
strcpy(fPlaneNames[0],"1x");
strcpy(fPlaneNames[1],"1y");
strcpy(fPlaneNames[2],"2x");
strcpy(fPlaneNames[3],"2y");
- cout << "fNPlanes = " << fNPlanes << endl;
// Probably shouldn't assume that description is defined
char* desc = new char[strlen(description)+50];
fPlanes = new THcScintillatorPlane* [fNPlanes];
@@ -83,8 +93,8 @@ void THcHodoscope::Setup(const char* name, const char* description)
strcpy(desc, description);
strcat(desc, " Plane ");
strcat(desc, fPlaneNames[i]);
-
- fPlanes[i] = new THcScintillatorPlane(fPlaneNames[i], desc, i+1, this);
+ fPlanes[i] = new THcScintillatorPlane(fPlaneNames[i], desc, i+1,fNPlanes, this);
+ //fPlanes[i] = new THcScintillatorPlane(fPlaneNames[i], desc, i+1, this);
cout << "Created Scintillator Plane " << fPlaneNames[i] << ", " << desc << endl;
}
}
@@ -292,8 +302,8 @@ Int_t THcHodoscope::ReadDatabase( const TDatime& date )
Int_t plen=strlen(parname);
fNPaddle = new Int_t [fNPlanes];
- fSpacing = new Double_t [fNPlanes];
- fCenter = new Double_t* [fNPlanes];
+ // fSpacing = new Double_t [fNPlanes];
+ //fCenter = new Double_t* [fNPlanes];
// An alternate way to get these variables
// Can add Xscin_P_center when LoadParmValues supports arrays
@@ -311,27 +321,7 @@ Int_t THcHodoscope::ReadDatabase( const TDatime& date )
gHcParms->LoadParmValues((DBRequest*)&list,prefix);
}
- for(Int_t i=0;i<fNPlanes;i++) {
- fCenter[i] = new Double_t[fNPaddle[i]];
- DBRequest list[]={
- {Form("scin_%s_spacing",fPlaneNames[i]), &fSpacing[i], kDouble},
- {Form("scin_%s_center",fPlaneNames[i]), fCenter[i], kDouble, fNPaddle[i]},
- {0}
- };
- gHcParms->LoadParmValues((DBRequest*)&list,prefix);
- }
-
- if(fDebug>=1) {
- cout << "Plane: " << " nr spacing" << endl;
- for(Int_t i=0;i<fNPlanes;i++) {
- cout << fPlaneNames[i] << " " << fNPaddle[i] << " " << fSpacing[i] <<endl;
- for(Int_t ip=0;ip<fNPaddle[i];ip++) {
- cout << " " << fCenter[i][ip];
- }
- cout << endl;
- }
- }
-
+/*
#if 0
fCenter = new Double_t* [fNPlanes];
for(Int_t i=0;i<fNPlanes;i++) {
@@ -349,11 +339,37 @@ Int_t THcHodoscope::ReadDatabase( const TDatime& date )
if (fDebug>=1) cout << endl;
}
#endif
+*/
// GN added
// reading variables from *hodo.param
- prefix[1]='\0';
-
+ fMaxScinPerPlane=fNPaddle[0];
+ for (Int_t i=1;i<fNPlanes;i++) {
+ fMaxScinPerPlane=(fMaxScinPerPlane > fNPaddle[i])? fMaxScinPerPlane : fNPaddle[i];
+ }
+// need this for "padded arrays" i.e. 4x16 lists of parameters (GN)
+ fMaxHodoScin=fMaxScinPerPlane*fNPlanes;
+ if (fDebug>=1) cout <<"fMaxScinPerPlane = "<<fMaxScinPerPlane<<" fMaxHodoScin = "<<fMaxHodoScin<<endl;
+
+ Double_t fHodoVelLight[fMaxHodoScin];
+ Double_t fHodoPosSigma[fMaxHodoScin];
+ Double_t fHodoNegSigma[fMaxHodoScin];
+ Double_t fHodoPosMinPh[fMaxHodoScin];
+ Double_t fHodoNegMinPh[fMaxHodoScin];
+ Double_t fHodoPosPhcCoeff[fMaxHodoScin];
+ Double_t fHodoNegPhcCoeff[fMaxHodoScin];
+ Double_t fHodoPosTimeOffset[fMaxHodoScin];
+ Double_t fHodoNegTimeOffset[fMaxHodoScin];
+ Int_t fHodoPosPedLimit[fMaxHodoScin];
+ Int_t fHodoNegPedLimit[fMaxHodoScin];
+ Int_t fTofUsingInvAdc;
+ Double_t fHodoPosInvAdcOffset[fMaxHodoScin];
+ Double_t fHodoNegInvAdcOffset[fMaxHodoScin];
+ Double_t fHodoPosInvAdcLinear[fMaxHodoScin];
+ Double_t fHodoNegInvAdcLinear[fMaxHodoScin];
+ Double_t fHodoPosInvAdcAdc[fMaxHodoScin];
+ Double_t fHodoNegInvAdcAdc[fMaxHodoScin];
+ prefix[1]='\0';
DBRequest list[]={
{"start_time_center", &fStartTimeCenter, kDouble},
{"start_time_slop", &fStartTimeSlop, kDouble},
@@ -361,66 +377,47 @@ Int_t THcHodoscope::ReadDatabase( const TDatime& date )
{"scin_tdc_min", &fScinTdcMin, kDouble},
{"scin_tdc_max", &fScinTdcMax, kDouble},
{"tof_tolerance", &fTofTolerance, kDouble},
+ {"pathlength_central", &fPathLengthCentral, kDouble},
+ {"hodo_vel_light",&fHodoVelLight[0],kDouble,fMaxHodoScin},
+ {"hodo_pos_sigma",&fHodoPosSigma[0],kDouble,fMaxHodoScin},
+ {"hodo_neg_sigma",&fHodoNegSigma[0],kDouble,fMaxHodoScin},
+ {"hodo_pos_minph",&fHodoPosMinPh[0],kDouble,fMaxHodoScin},
+ {"hodo_neg_minph",&fHodoNegMinPh[0],kDouble,fMaxHodoScin},
+ {"hodo_pos_phc_coeff",&fHodoPosPhcCoeff[0],kDouble,fMaxHodoScin},
+ {"hodo_neg_phc_coeff",&fHodoNegPhcCoeff[0],kDouble,fMaxHodoScin},
+ {"hodo_pos_time_offset",&fHodoPosTimeOffset[0],kDouble,fMaxHodoScin},
+ {"hodo_neg_time_offset",&fHodoNegTimeOffset[0],kDouble,fMaxHodoScin},
+ {"hodo_pos_ped_limit",&fHodoPosPedLimit[0],kInt,fMaxHodoScin},
+ {"hodo_neg_ped_limit",&fHodoNegPedLimit[0],kInt,fMaxHodoScin},
+ {"tofusinginvadc",&fTofUsingInvAdc,kInt},
+ {"hodo_pos_invadc_offset",&fHodoPosInvAdcOffset[0],kDouble,fMaxHodoScin},
+ {"hodo_neg_invadc_offset",&fHodoNegInvAdcOffset[0],kDouble,fMaxHodoScin},
+ {"hodo_pos_invadc_linear",&fHodoPosInvAdcLinear[0],kDouble,fMaxHodoScin},
+ {"hodo_neg_invadc_linear",&fHodoNegInvAdcLinear[0],kDouble,fMaxHodoScin},
+ {"hodo_pos_invadc_adc",&fHodoPosInvAdcAdc[0],kDouble,fMaxHodoScin},
+ {"hodo_neg_invadc_adc",&fHodoNegInvAdcAdc[0],kDouble,fMaxHodoScin},
{0}
};
gHcParms->LoadParmValues((DBRequest*)&list,prefix);
- cout <<"******* Testing *** "<<fStartTimeCenter<<" "<<fStartTimeSlop;
- cout <<" "<<fScinTdcToTime;
- cout <<" "<<fScinTdcMin;
- cout <<" "<<fScinTdcMax;
- cout <<" "<<fTofTolerance;
- cout <<endl<<endl;
- // fStartTimeCenter=DefineDoubleVariable("start_time_center");
- // fStartTimeSlop=DefineDoubleVariable("start_time_slop");
- //fScinTdcToTime=DefineDoubleVariable("scin_tdc_to_time");
- //fScinTdcMin=DefineIntVariable("scin_tdc_min");
- //fScinTdcMax=DefineIntVariable("scin_tdc_max");
- //fTofTolerance=DefineDoubleVariable("tof_tolerance");
- fHodoSlop = new Double_t [fNPlanes];
- DefineArray("hodo_slop",fNPlanes, &fHodoSlop[0]);
- /* if (fDebug>=1) {
- cout <<"testing hodo_slop ";
- for(Int_t i=0;i<fNPlanes;i++) {
- if (fDebug>=1) cout << " " << fHodoSlop[i];
- }
- if (fDebug>=1) cout << endl;
- }
- */
-
- /* try to read *hodo_vel_light
- NOTE: for HMS these were assigned as a 4x16 array (so we need to pad the planes
- that have less than 16 paddles per
- */
- Int_t max_paddles=fNPaddle[0];
- for (Int_t i=1;i<fNPlanes;i++) {
- max_paddles=(max_paddles > fNPaddle[i])? max_paddles : fNPaddle[i];
- }
- cout <<"maxpaddles = "<<max_paddles<<endl;
- fHodoVelLight = new Double_t* [max_paddles];
- prefix[1]='\0';
- strcpy(parname,prefix);
- strcat(parname,"hodo_vel_light");
- Int_t k=0;
- if (gHcParms->Find(parname)) {
- Double_t* p = (Double_t *)gHcParms->Find(parname)->GetValuePointer();
- cout <<parname<<" ";
- for(Int_t i=0;i<max_paddles;i++) {
- fHodoVelLight[i] = new Double_t [fNPlanes];
- for(Int_t j=0;j<fNPlanes;j++) {
- // cout <<"i = "<<i<<" j = "<<j;
- fHodoVelLight[i][j] = p[k];
- k++;
- if (fDebug>=1) cout << " " << fHodoVelLight[i][j]<<endl;
+ if (fDebug >=1) {
+ cout <<"******* Testing Hodoscope Parameter Reading ***\n";
+ cout<<"StarTimeCenter = "<<fStartTimeCenter<<endl;
+ cout<<"StartTimeSlop = "<<fStartTimeSlop<<endl;
+ cout <<"ScintTdcToTime = "<<fScinTdcToTime<<endl;
+ cout <<"TdcMin = "<<fScinTdcMin<<" TdcMax = "<<fScinTdcMax<<endl;
+ cout <<"TofTolerance = "<<fTofTolerance<<endl;
+ cout <<"*** VelLight ***\n";
+ for (int i1=1;i1<=fNPlanes;i1++) {
+ cout<<"Plane "<<i1<<endl;
+ for (int i2=0;i2<fMaxScinPerPlane;i2++) {
+ cout<<fHodoVelLight[GetScinIndex(i1,i2)]<<" ";
}
- if (fDebug>=1) cout << endl;
+ cout <<endl;
}
+
+ cout <<endl<<endl;
}
- else {
- cout <<"Could not find "<<parname<<" in the DataBase!!!\n";
- }
-
fIsInit = true;
-
return kOK;
}
@@ -428,9 +425,7 @@ Int_t THcHodoscope::ReadDatabase( const TDatime& date )
Int_t THcHodoscope::DefineVariables( EMode mode )
{
// Initialize global variables and lookup table for decoder
-
cout << "THcHodoscope::DefineVariables called " << GetName() << endl;
-
if( mode == kDefine && fIsSetup ) return kOK;
fIsSetup = ( mode == kDefine );
@@ -497,9 +492,9 @@ void THcHodoscope::DeleteArrays()
{
// Delete member arrays. Used by destructor.
- delete [] fNPaddle; fNPaddle = NULL;
- delete [] fSpacing; fSpacing = NULL;
- delete [] fCenter; fCenter = NULL; // This 2D. What is correct way to delete?
+ delete [] fNPaddle; fNPaddle = NULL;
+ // delete [] fSpacing; fSpacing = NULL;
+ //delete [] fCenter; fCenter = NULL; // This 2D. What is correct way to delete?
// delete [] fRA_c; fRA_c = NULL;
// delete [] fRA_p; fRA_p = NULL;
@@ -623,6 +618,20 @@ Int_t THcHodoscope::FineProcess( TClonesArray& tracks )
return 0;
}
-
+//_____________________________________________________________________________
+Int_t THcHodoscope::GetScinIndex( Int_t nPlane, Int_t nPaddle ) {
+ // Return the index of a scintillator given the plane # and the paddle #
+ // This assumes that planes start counting from 1
+ // and paddles start counting from 0! (not ideal but that's what I have for now)
+ return fNPlanes*nPaddle+nPlane-1;
+}
+//_____________________________________________________________________________
+Int_t THcHodoscope::GetScinIndex( Int_t nSide, Int_t nPlane, Int_t nPaddle ) {
+ return nSide*fMaxHodoScin+fNPlanes*nPaddle+nPlane-1;
+}
+//_____________________________________________________________________________
+Double_t THcHodoscope::GetPathLengthCentral() {
+ return fPathLengthCentral;
+}
ClassImp(THcHodoscope)
////////////////////////////////////////////////////////////////////////////////
diff --git a/src/THcHodoscope.h b/src/THcHodoscope.h
index 2b8c8d86d6e3cd9c285f25940a898f03abeca95d..609b8ed853bd035f5b8ce14aef5728f7ea6265e8 100644
--- a/src/THcHodoscope.h
+++ b/src/THcHodoscope.h
@@ -32,7 +32,10 @@ public:
virtual Int_t ApplyCorrections( void );
// Int_t GetNHits() const { return fNhit; }
-
+ Int_t GetScinIndex(Int_t nPlane, Int_t nPaddle);
+ Int_t GetScinIndex(Int_t nSide, Int_t nPlane, Int_t nPaddle);
+ Double_t GetPathLengthCentral();
+
Int_t GetNTracks() const { return fTrackProj->GetLast()+1; }
const TClonesArray* GetTrackHits() const { return fTrackProj; }
@@ -49,19 +52,33 @@ protected:
// Potential Hall C parameters. Mostly here for demonstration
- Int_t fNPlanes;
+ Int_t fNPlanes,fMaxScinPerPlane,fMaxHodoScin; // number of planes; max number of scin/plane; product of the first two
Double_t fStartTimeCenter, fStartTimeSlop, fScinTdcToTime;
Double_t fTofTolerance;
+ Double_t fPathLengthCentral;
Int_t fScinTdcMin, fScinTdcMax; // min and max TDC values
- Double_t* fHodoSlop;
- Double_t** fHodoVelLight;
- Double_t** fHodoPosSigma;
- Double_t** fHodoNegSigma;
-
char** fPlaneNames;
Int_t* fNPaddle; // Number of paddles per plane
- Double_t* fSpacing; // Paddle spacing in cm
- Double_t** fCenter; // Center position of each paddle
+
+ Double_t* fHodoVelLight;
+ Double_t* fHodoPosSigma;
+ Double_t* fHodoNegSigma;
+
+ Double_t* fHodoPosMinPh;
+ Double_t* fHodoNegMinPh;
+ Double_t* fHodoPosPhcCoeff;
+ Double_t* fHodoNegPhcCoeff;
+ Double_t* fHodoPosTimeOffset;
+ Double_t* fHodoNegTimeOffset;
+ Int_t* fHodoPosPedLimit;
+ Int_t* fHodoNegPedLimit;
+ Int_t fTofUsingInvAdc;
+ Double_t* fHodoPosInvAdcOffset;
+ Double_t* fHodoNegInvAdcOffset;
+ Double_t* fHodoPosInvAdcLinear;
+ Double_t* fHodoNegInvAdcLinear;
+ Double_t* fHodoPosInvAdcAdc;
+ Double_t* fHodoNegInvAdcAdc;
THcScintillatorPlane** fPlanes; // List of plane objects
diff --git a/src/THcScintillatorPlane.cxx b/src/THcScintillatorPlane.cxx
index aaf6bd22c4c087bcc5791ce5bf31feef908ddcf3..774f8d34ad6cea7f1235e46ded6ab19866769644 100644
--- a/src/THcScintillatorPlane.cxx
+++ b/src/THcScintillatorPlane.cxx
@@ -37,6 +37,23 @@ THcScintillatorPlane::THcScintillatorPlane( const char* name,
fPosADCHits = new TClonesArray("THcSignalHit",16);
fNegADCHits = new TClonesArray("THcSignalHit",16);
fPlaneNum = planenum;
+ fTotPlanes = planenum;
+}
+//______________________________________________________________________________
+THcScintillatorPlane::THcScintillatorPlane( const char* name,
+ const char* description,
+ const Int_t planenum,
+ const Int_t totplanes,
+ THaDetectorBase* parent )
+ : THaSubDetector(name,description,parent)
+{
+ // Normal constructor with name and description
+ fPosTDCHits = new TClonesArray("THcSignalHit",16);
+ fNegTDCHits = new TClonesArray("THcSignalHit",16);
+ fPosADCHits = new TClonesArray("THcSignalHit",16);
+ fNegADCHits = new TClonesArray("THcSignalHit",16);
+ fPlaneNum = planenum;
+ fTotPlanes = totplanes;
}
//______________________________________________________________________________
@@ -88,7 +105,7 @@ Int_t THcScintillatorPlane::ReadDatabase( const TDatime& date )
prefix[0]=tolower(GetParent()->GetPrefix()[0]);
prefix[1]='\0';
- strcpy(parname,prefix);
+ /* strcpy(parname,prefix);
strcat(parname,"scin_");
strcat(parname,GetName());
Int_t plen=strlen(parname);
@@ -101,11 +118,73 @@ Int_t THcScintillatorPlane::ReadDatabase( const TDatime& date )
strcat(parname,"_spacing");
fSpacing = gHcParms->Find(parname)->GetValue(0);
-
+ cout <<"fSpacing = "<<fSpacing<<endl;
+ */
+
+ // need this further down so read them first! GN
+ strcpy(parname,prefix);
+ strcat(parname,"scin_");
+ strcat(parname,GetName());
+ Int_t plen=strlen(parname);
+ strcat(parname,"_nr");
+ fNelem = *(Int_t *)gHcParms->Find(parname)->GetValuePointer();
+ //
+ char *tmpleft, *tmpright;
+ if (fPlaneNum==1 || fPlaneNum==3) {
+ tmpleft="left";
+ tmpright="right";
+ }
+ else {
+ tmpleft="top";
+ tmpright="bot";
+ }
+
+ Double_t tmpdouble[fTotPlanes];
+ DBRequest list[]={
+ {Form("scin_%s_zpos",GetName()), &fZpos, kDouble},
+ {Form("scin_%s_dzpos",GetName()), &fDzpos, kDouble},
+ {Form("scin_%s_size",GetName()), &fSize, kDouble},
+ {Form("scin_%s_spacing",GetName()), &fSpacing, kDouble},
+ {Form("scin_%s_%s",GetName(),tmpleft), &fPosLeft,kDouble},
+ {Form("scin_%s_%s",GetName(),tmpright), &fPosRight,kDouble},
+ {Form("scin_%s_offset",GetName()), &fPosOffset, kDouble},
+ {Form("scin_%s_center",GetName()), &fPosCenter[0],kDouble,fNelem},
+ // this is from Xhodo.param...
+ {"hodo_slop",&tmpdouble[0],kDouble,fTotPlanes},
+ {0}
+ };
+ gHcParms->LoadParmValues((DBRequest*)&list,prefix);
+ // fetch the parameter from the temporary list
+ fHodoSlop=tmpdouble[fPlaneNum-1];
+ cout <<" plane num = "<<fPlaneNum<<endl;
+ cout <<" nelem = "<<fNelem<<endl;
+ cout <<" zpos = "<<fZpos<<endl;
+ cout <<" dzpos = "<<fDzpos<<endl;
+ cout <<" spacing = "<<fSpacing<<endl;
+ cout <<" size = "<<fSize<<endl;
+ cout <<" hodoslop = "<<fHodoSlop<<endl;
+ cout <<"PosLeft = "<<fPosLeft<<endl;
+ cout <<"PosRight = "<<fPosRight<<endl;
+ cout <<"PosOffset = "<<fPosOffset<<endl;
+ cout <<"PosCenter[0] = "<<fPosCenter[0]<<endl;
+
+
+ /* for(Int_t i=0;i<fNPlanes;i++) {
+ fCenter[i] = new Double_t[fNPaddle[i]];
+ DBRequest list[]={
+ {Form("scin_%s_spacing",fPlaneNames[i]), &fSpacing[i], kDouble},
+ {Form("scin_%s_center",fPlaneNames[i]), fCenter[i], kDouble, fNPaddle[i]},
+ {0}
+ };
+ gHcParms->LoadParmValues((DBRequest*)&list,prefix);
+ }
+ */
+ /// Int_t tmpint = new Int_t [GetParent()->GetNPlanes()];
+ /// cout<<"Nplanes in scintplane!! = "<<fTotPlanes <<endl;
+
// First letter of GetParent()->GetPrefix() tells us what prefix to
// use on parameter names.
-
// Find the number of elements
// Think we will make special methods to pass most
@@ -333,4 +412,53 @@ void THcScintillatorPlane::InitializePedestals( )
fNegPedCount[i] = 0;
}
}
+//____________________________________________________________________________
+Int_t THcScintillatorPlane::GetNelem()
+{
+ return fNelem;
+}
+//____________________________________________________________________________
+Double_t THcScintillatorPlane::GetSpacing()
+{
+ return fSpacing;
+}
+//____________________________________________________________________________
+Double_t THcScintillatorPlane::GetSize()
+{
+ return fSize;
+}
+//____________________________________________________________________________
+Double_t THcScintillatorPlane::GetHodoSlop()
+{
+ return fHodoSlop;
+}
+//____________________________________________________________________________
+Double_t THcScintillatorPlane::GetZpos()
+{
+ return fZpos;
+}
+//____________________________________________________________________________
+Double_t THcScintillatorPlane::GetDzpos()
+{
+ return fDzpos;
+}
+//____________________________________________________________________________
+Double_t THcScintillatorPlane::GetPosLeft() {
+ return fPosLeft;
+}
+//____________________________________________________________________________
+Double_t THcScintillatorPlane::GetPosRight() {
+ return fPosRight;
+}
+//____________________________________________________________________________
+Double_t THcScintillatorPlane::GetPosOffset() {
+ return fPosOffset;
+}
+//____________________________________________________________________________
+Double_t THcScintillatorPlane::GetPosCenter(Int_t PaddleNo) {
+ return fPosCenter[PaddleNo];
+}
+//____________________________________________________________________________
+ClassImp(THcScintillatorPlane)
+////////////////////////////////////////////////////////////////////////////////
diff --git a/src/THcScintillatorPlane.h b/src/THcScintillatorPlane.h
index eefae3e258a40cce25ac37676b4b355dda4e84d7..7cb205c2fe91f51a2eafdf4cae4b174e414a6df2 100644
--- a/src/THcScintillatorPlane.h
+++ b/src/THcScintillatorPlane.h
@@ -23,6 +23,8 @@ class THcScintillatorPlane : public THaSubDetector {
public:
THcScintillatorPlane( const char* name, const char* description,
Int_t planenum, THaDetectorBase* parent = NULL);
+ THcScintillatorPlane( const char* name, const char* description,
+ Int_t planenum, Int_t totplanes, THaDetectorBase* parent = NULL);
virtual ~THcScintillatorPlane();
virtual void Clear( Option_t* opt="" );
@@ -38,7 +40,16 @@ class THcScintillatorPlane : public THaSubDetector {
virtual Int_t AccumulatePedestals(TClonesArray* rawhits, Int_t nexthit);
virtual void CalculatePedestals( );
- Double_t fSpacing;
+ Int_t GetNelem(); // return number of paddles in this plane
+ Double_t GetSpacing(); // return the spacing of paddles
+ Double_t GetSize(); // return paddle size
+ Double_t GetHodoSlop(); // return the hodo slop
+ Double_t GetZpos(); //return the z position
+ Double_t GetDzpos();
+ Double_t GetPosLeft();
+ Double_t GetPosRight();
+ Double_t GetPosOffset();
+ Double_t GetPosCenter(Int_t PaddleNo); // here we're counting from zero!
TClonesArray* fParentHitList;
@@ -50,8 +61,20 @@ class THcScintillatorPlane : public THaSubDetector {
TClonesArray* fNegADCHits;
Int_t fPlaneNum; /* Which plane am I 1-4 */
+ Int_t fTotPlanes; /* so we can read variables that are not indexed by plane id */
Int_t fNelem; /* Need since we don't inherit from
detector base class */
+ Double_t fSpacing; /* paddle spacing */
+ Double_t fSize; /* paddle size */
+ Double_t fZpos; /* z position */
+ Double_t fDzpos;
+ Double_t fHodoSlop; /* max allowed slop for this plane */
+ Double_t fPosLeft; /* NOTE: "left" = "top" for a Y scintillator */
+ Double_t fPosRight; /* NOTE: "right" = "bottom" for a Y scintillator */
+ Double_t fPosOffset;
+ Double_t fPosCenter[16]; /* array with centers for all scintillators in the plane */
+
+ /* Pedestal Quantities */
Int_t fNPedestalEvents; /* Number of pedestal events */
Int_t fMinPeds; /* Only analyze/update if num events > */
Int_t *fPosPedSum; /* Accumulators for pedestals */