Skip to content
Snippets Groups Projects
Commit 0dc7956d authored by Gabriel Niculescu's avatar Gabriel Niculescu
Browse files

GN: Added variables and procedures for reading hodoscope parameters found in: 

xhodo.pos and xhodo.param
THcHodoscope generally holds:
- singular variables (i.e. central path through the spectrometer, min/max limits for the ADCs, TDCs, etc.)
- "padded arrays" (i.e. look at the plane with the most scintillators, allocate and array that has max_no_scint * no_of_planes - these are mostly found in the .param file)
THcScintillatorPlane generally holds:
- simple variables containing plane-specific info (z-position, scintillator size and spacing)
- arrays sized appropirately for the specific plane (i.e. individual x (or y) positions for all scintillators in a plane, signal propagation speed in the paddle, etc.)
parent 56ef6033
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
src/THcHodoscope.cxx
+ 97
− 88
View file @ 0dc7956d
......@@ -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)
////////////////////////////////////////////////////////////////////////////////
src/THcHodoscope.h
+ 26
− 9
View file @ 0dc7956d
......@@ -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
......
src/THcScintillatorPlane.cxx
+ 131
− 3
View file @ 0dc7956d
......@@ -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)
////////////////////////////////////////////////////////////////////////////////
src/THcScintillatorPlane.h
+ 24
− 1
View file @ 0dc7956d
......@@ -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 */
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment