ToFdEdx_patch/inc/ToFdEdx_patch.h



/**
 * \file ToFdEdx_patch.h
 * \authors Rita Carbone & Lucia Consiglio & Wolfgang Menn
 */
#ifndef tofdEdx_patch_h
#define tofdEdx_patch_h

#include <PamLevel2.h>

#include <TTree.h>
#include <TFriendElement.h>
#include <TChain.h>
#include <TFile.h>
#include <TList.h>
#include <TF1.h>
#include <TKey.h>
#include <TSystemFile.h>
#include <TSystemDirectory.h>
#include <TSQLServer.h>

#include <iostream>

using namespace std;


class ToF_geometry : public TObject {

private:
  TArrayI  ePlane, eXY;

public:
  ToF_geometry() {
    int plane[24] = { 
      0, 0, 0, 0, 0, 0, 0, 0,
      1, 1, 1, 1, 1, 1, 
      2, 2,             
      3, 3,             
      4, 4, 4,
      5, 5, 5
    };
    int plXY[6]= {  2,  1,  1,  2,  2,  1 }; // X==1, Y==2 */
    ePlane.Set(24,plane);
    eXY.Set(6,plXY);
  }

  int GetPad(   int idpmt)  { return (int)((idpmt+0.5)/2.); }
  int GetPlane( int idpmt)  { return ePlane[ GetPad(idpmt) ];  }
  int GetXY(    int idpmt)  { return eXY[ GetPlane(idpmt) ]; }

   ClassDef(ToF_geometry,1);

};

/**
 *
 * Class to store and calculate variables useful for nuclei analysis
 */
class ToFdEdx_patch : public TObject {         //class definition

 private:
    //
    PamLevel2  *L2;
    Int_t      eNtr;   // number of tracker tracks
    const char*  trkAlg; 

    ToF_geometry  eGeom;  // ToF geometry
    //

    UInt_t OBT;
    UInt_t PKT;
    UInt_t atime;
    Int_t tr;
    
    Float_t  adc_he;
    
//  ToF track dependent
    TArrayF eDEDXpmt;  // 0-47  pmt dEdx
    TArrayF eZpmt;     // 0-47  pmt charge
    TArrayF eDEDXpad;  // 0-23  paddle dEdx
    TArrayF eZpad;     // 0-23  paddle charge
    TArrayF eDEDXlayer;  // 0-5 layer dEdx
    TArrayF eZlayer;     // 0-5 layer charge
    TArrayF eDEDXplane;  // 0-2 plane dEdx
    TArrayF eZplane;     // 0-2 plane charge

    TArrayF INFOpmt;  // 0-47 pmt status
    TArrayF INFOlayer;  //0-5 layer status
  

//  ToF standalone
    TArrayF eDEDXpmtstd;  // 0-47  pmt dEdx
    TArrayF eZpmtstd;     // 0-47  pmt charge
    TArrayF eDEDXpadstd;  // 0-23  paddle dEdx
    TArrayF eZpadstd;     // 0-23  paddle charge
    TArrayF eDEDXlayerstd;  // 0-5 layer dEdx
    TArrayF eZlayerstd;     // 0-5 layer charge
    TArrayF INFOpmtstd;  // 0-47 pmt status
    TArrayF INFOlayerstd;  //0-5 layer status   

    // parameters:
  TArrayF PMTsat;  // 0-47  saturation parameters


    TArrayF A0_array[100];  //  48 x 100  define an array of 48 elements per each time interval
    TArrayF A1_array[100];   
    TArrayF A2_array[100];
    TArrayF A3_array[100];
    TArrayF A4_array[100];
    TArrayF A5_array[100];

    Float_t A0[48];  
    Float_t A1[48];   
    Float_t A2[48];
    Float_t A3[48];
    Float_t A4[48];
    Float_t A5[48];

    UInt_t T_int_min[100];  
    UInt_t T_int_max[100];
    UInt_t tmin_atten,tmax_atten;
    Int_t ical_atten;

    TArrayF dedx_corr_mp[3500];  // 48 x 3500  define an array of 48 elements per each time interval
    TArrayF dedx_corr_mhe[3500];  // 48 x 3500  define an array of 48 elements per each time interval
    TArrayF dedx_corr_mc[3500];  // 48 x 3500  define an array of 48 elements per each time interval

    UInt_t mtime[3500];
    Int_t ical_2nd;
    UInt_t tmin_2nd,tmax_2nd;
    

//    TArrayF TDx[48];  // 200 x 48  define an array of 200 elements per each pmt
//    TArrayF TDy[48];
//    TArrayF parAtt[48];      // 48 x 6

    TArrayF parPos[48];      // 48 x 4
    TArrayF parDesatBB[48];  // 48 x 3
    TArrayF parBBneg[48];    // 48 x 3
    TArrayF parBBpos;        // 48 x 1
    TArrayF parBBpol4[48];   // 48 x 5  for pol4 parameters

   
 public:
    ToFdEdx_patch() {Clear();}   // class constructor
    ~ToFdEdx_patch(){ Delete(); };  // class distructor
    //
    void Clear(Option_t *option="");
    void Delete(Option_t *option="") { Clear(); }

//    void InitPar(const char *pardir);  // init parameters
    void InitPar(const char *pardir, const char  *param);  // init parameters

    void Define_PMTsat();
//    void ReadParTD( Int_t ipmt, const char *fname  );

    void ReadParAtt(const char *pardir, const char *param);
//    void ReadParAtt(            const char *fname, const char *param );
    void ReadParPos(            const char *fname  );
    void ReadParBBneg(          const char *fname  );
    void ReadParBBpos(          const char *fname  );
    void ReadParDesatBB(        const char *fname  );
    void ReadParBBpol4(          const char *fname  );


//    void Process( PamLevel2 *l2p, Int_t itr=0 ); ///< Process data for track number itr
    void Process( PamLevel2 *l2p, const char* alg,  const char  *tri_or_bi ); ///< Process data 10th red 
    void Print(Option_t *option="");
    void PrintTD();

// track dependent results

    Float_t GetdEdx_pmt(Int_t ipmt) { return eDEDXpmt[ipmt]; }  // 0-47 dEdx for each PMT for tracked events
    Float_t GetCharge_pmt(Int_t ipmt) {return eZpmt[ipmt];}  // 0-47 Z for each PMT for tracked events
    Float_t GetdEdx_pad(Int_t ipad) {return eDEDXpad[ipad];}  // 0-23 dEdx for each paddle for tracked events (no request of consistency between PMT's response when both on!)
    Float_t GetCharge_pad(Int_t ipad) {return  eZpad[ipad];}  // 0-23 Z for each paddle for tracked events (no request of consistency)
    Float_t GetdEdx_layer(Int_t ilay) {return eDEDXlayer[ilay];}  // 0-5 dEdx for each layer for tracked events
    Float_t GetCharge_layer(Int_t ilay) {return eZlayer[ilay];}  // 0-5 Z for each layer for tracked events
 

// ToF standalone results
    Float_t GetdEdx_pmtstd(Int_t ipmt) { return eDEDXpmtstd[ipmt]; }  // 0-47 dEdx for each PMT for tracked events
    Float_t GetCharge_pmtstd(Int_t ipmt) {return eZpmtstd[ipmt];}  // 0-47 Z for each PMT for tracked events
    Float_t GetdEdx_padstd(Int_t ipad) {return eDEDXpadstd[ipad];}  // 0-23 dEdx for each paddle for tracked events (no request of consistency between PMT's response when both on!)
    Float_t GetCharge_padstd(Int_t ipad) {return  eZpadstd[ipad];}  // 0-23 Z for each paddle for tracked events (no request of consistency)
    Float_t GetdEdx_layerstd(Int_t ilay) {return eDEDXlayerstd[ilay];}  // 0-5 dEdx for each layer for tracked events
    Float_t GetCharge_layerstd(Int_t ilay) {return eZlayerstd[ilay];}  // 0-5 Z for each layer for tracked events
 

    Float_t GetInfo_pmt(Int_t ipmt) {return INFOpmt[ipmt];} // 0-47 pmt status  

    /* INFOpmt table:
       
       INFOpmt[ii]=0  --->  everithing is ok!
       INFOpmt[ii]=1  --->  beta not good (<0.05 || >2)
       INFOpmt[ii]=2  --->  PMT OFF
       INFOpmt[ii]=3  --->  PMT saturated
       INFOpmt[ii]=4  --->  error during the correction for the incidence angle
       INFOpmt[ii]=5  --->  error during the correction for the dependence on the position
       INFOpmt[ii]=6  --->  error in dEdx reconstruction
       INFOpmt[ii]=7  --->  error in Z reconstruction 
    */

    Float_t GetInfo_layer(Int_t ilay) {return INFOlayer[ilay];}  // 0-5 layer status

    /* INFOlayer table:
       
       INFOlayer[ii]=0  --->  everithing is ok!
       INFOlayer[ii]=1  --->  beta not good (<0.05 || >2)
       INFOlayer[ii]=2  --->  only one PMT is OFF (but you get the other one to have the measurement)
       INFOlayer[ii]=3  --->  only one PMT is saturated (but you get the other one to have the measurement)
       INFOlayer[ii]=4  --->  only one PMT with a wrong reconstruction  (but you get the other one to have the measurement)
       INFOlayer[ii]=5  --->  the 2 PMTs involved give different measurement (actually they differ for more then 1.5, to be tuned...)
       INFOlayer[ii]=6  --->  saturated layer (both PMTs)
       INFOlayer[ii]=7  --->  all PMTs show some error during reconstruction
       INFOlayer[ii]=8  --->  1 PMT is OFF and 1 is saturated (it happens quiet only on S115...)
       INFOlayer[ii]=9  --->  OFF layer
    */

 private:
    double f_adcPC( float x );
 
   double f_BB( TArrayF &p, float x );
   double f_BBpol4( TArrayF &p, float x );

   double f_BB5B( float x );
   double f_BB5Bpol4( float x );


//    double f_att( TArrayF &p, float x ) ;
    double f_att(float C0, float C1, float C2, float C3, float C4, float C5, float x ) ;
    double f_att5B( float x );
    double f_desatBB( TArrayF &p, float x );  
    double f_desatBB5B( float x );
    double f_pos( TArrayF &p, float x );
    double f_pos5B( float x );
 //   float Get_adc_he( int id, float pl_x[6], float pl_y[6]);
    float Get_adc_he( int id, float x);
   
    
    ClassDef(ToFdEdx_patch,1);
};

#endif

1	mayorov	1.1
2
3			/**
4			* \file ToFdEdx_patch.h
5			* \authors Rita Carbone & Lucia Consiglio & Wolfgang Menn
6			*/
7			#ifndef tofdEdx_patch_h
8			#define tofdEdx_patch_h
9
10			#include <PamLevel2.h>
11
12			#include <TTree.h>
13			#include <TFriendElement.h>
14			#include <TChain.h>
15			#include <TFile.h>
16			#include <TList.h>
17			#include <TF1.h>
18			#include <TKey.h>
19			#include <TSystemFile.h>
20			#include <TSystemDirectory.h>
21			#include <TSQLServer.h>
22
23			#include <iostream>
24
25			using namespace std;
26
27
28			class ToF_geometry : public TObject {
29
30			private:
31			TArrayI ePlane, eXY;
32
33			public:
34			ToF_geometry() {
35			int plane[24] = {
36			0, 0, 0, 0, 0, 0, 0, 0,
37			1, 1, 1, 1, 1, 1,
38			2, 2,
39			3, 3,
40			4, 4, 4,
41			5, 5, 5
42			};
43			int plXY[6]= { 2, 1, 1, 2, 2, 1 }; // X==1, Y==2 */
44			ePlane.Set(24,plane);
45			eXY.Set(6,plXY);
46			}
47
48			int GetPad( int idpmt) { return (int)((idpmt+0.5)/2.); }
49			int GetPlane( int idpmt) { return ePlane[ GetPad(idpmt) ]; }
50			int GetXY( int idpmt) { return eXY[ GetPlane(idpmt) ]; }
51
52			ClassDef(ToF_geometry,1);
53
54			};
55
56			/**
57			*
58			* Class to store and calculate variables useful for nuclei analysis
59			*/
60			class ToFdEdx_patch : public TObject { //class definition
61
62			private:
63			//
64			PamLevel2 *L2;
65			Int_t eNtr; // number of tracker tracks
66			const char* trkAlg;
67
68			ToF_geometry eGeom; // ToF geometry
69			//
70
71			UInt_t OBT;
72			UInt_t PKT;
73			UInt_t atime;
74			Int_t tr;
75
76			Float_t adc_he;
77
78			// ToF track dependent
79			TArrayF eDEDXpmt; // 0-47 pmt dEdx
80			TArrayF eZpmt; // 0-47 pmt charge
81			TArrayF eDEDXpad; // 0-23 paddle dEdx
82			TArrayF eZpad; // 0-23 paddle charge
83			TArrayF eDEDXlayer; // 0-5 layer dEdx
84			TArrayF eZlayer; // 0-5 layer charge
85			TArrayF eDEDXplane; // 0-2 plane dEdx
86			TArrayF eZplane; // 0-2 plane charge
87
88			TArrayF INFOpmt; // 0-47 pmt status
89			TArrayF INFOlayer; //0-5 layer status
90
91
92
93			// ToF standalone
94			TArrayF eDEDXpmtstd; // 0-47 pmt dEdx
95			TArrayF eZpmtstd; // 0-47 pmt charge
96			TArrayF eDEDXpadstd; // 0-23 paddle dEdx
97			TArrayF eZpadstd; // 0-23 paddle charge
98			TArrayF eDEDXlayerstd; // 0-5 layer dEdx
99			TArrayF eZlayerstd; // 0-5 layer charge
100			TArrayF INFOpmtstd; // 0-47 pmt status
101			TArrayF INFOlayerstd; //0-5 layer status
102
103			// parameters:
104			TArrayF PMTsat; // 0-47 saturation parameters
105
106
107			TArrayF A0_array[100]; // 48 x 100 define an array of 48 elements per each time interval
108			TArrayF A1_array[100];
109			TArrayF A2_array[100];
110			TArrayF A3_array[100];
111			TArrayF A4_array[100];
112			TArrayF A5_array[100];
113
114			Float_t A0[48];
115			Float_t A1[48];
116			Float_t A2[48];
117			Float_t A3[48];
118			Float_t A4[48];
119			Float_t A5[48];
120
121			UInt_t T_int_min[100];
122			UInt_t T_int_max[100];
123			UInt_t tmin_atten,tmax_atten;
124			Int_t ical_atten;
125
126			TArrayF dedx_corr_mp[3500]; // 48 x 3500 define an array of 48 elements per each time interval
127			TArrayF dedx_corr_mhe[3500]; // 48 x 3500 define an array of 48 elements per each time interval
128			TArrayF dedx_corr_mc[3500]; // 48 x 3500 define an array of 48 elements per each time interval
129
130			UInt_t mtime[3500];
131			Int_t ical_2nd;
132			UInt_t tmin_2nd,tmax_2nd;
133
134
135			// TArrayF TDx[48]; // 200 x 48 define an array of 200 elements per each pmt
136			// TArrayF TDy[48];
137			// TArrayF parAtt[48]; // 48 x 6
138
139			TArrayF parPos[48]; // 48 x 4
140			TArrayF parDesatBB[48]; // 48 x 3
141			TArrayF parBBneg[48]; // 48 x 3
142			TArrayF parBBpos; // 48 x 1
143			TArrayF parBBpol4[48]; // 48 x 5 for pol4 parameters
144
145
146			public:
147			ToFdEdx_patch() {Clear();} // class constructor
148			~ToFdEdx_patch(){ Delete(); }; // class distructor
149			//
150			void Clear(Option_t *option="");
151			void Delete(Option_t *option="") { Clear(); }
152
153			// void InitPar(const char *pardir); // init parameters
154			void InitPar(const char pardir, const char param); // init parameters
155
156			void Define_PMTsat();
157			// void ReadParTD( Int_t ipmt, const char *fname );
158
159			void ReadParAtt(const char pardir, const char param);
160			// void ReadParAtt( const char fname, const char param );
161			void ReadParPos( const char *fname );
162			void ReadParBBneg( const char *fname );
163			void ReadParBBpos( const char *fname );
164			void ReadParDesatBB( const char *fname );
165			void ReadParBBpol4( const char *fname );
166
167
168
169			// void Process( PamLevel2 *l2p, Int_t itr=0 ); ///< Process data for track number itr
170			void Process( PamLevel2 l2p, const char alg, const char *tri_or_bi ); ///< Process data 10th red
171			void Print(Option_t *option="");
172			void PrintTD();
173
174			// track dependent results
175
176			Float_t GetdEdx_pmt(Int_t ipmt) { return eDEDXpmt[ipmt]; } // 0-47 dEdx for each PMT for tracked events
177			Float_t GetCharge_pmt(Int_t ipmt) {return eZpmt[ipmt];} // 0-47 Z for each PMT for tracked events
178			Float_t GetdEdx_pad(Int_t ipad) {return eDEDXpad[ipad];} // 0-23 dEdx for each paddle for tracked events (no request of consistency between PMT's response when both on!)
179			Float_t GetCharge_pad(Int_t ipad) {return eZpad[ipad];} // 0-23 Z for each paddle for tracked events (no request of consistency)
180			Float_t GetdEdx_layer(Int_t ilay) {return eDEDXlayer[ilay];} // 0-5 dEdx for each layer for tracked events
181			Float_t GetCharge_layer(Int_t ilay) {return eZlayer[ilay];} // 0-5 Z for each layer for tracked events
182
183
184
185			// ToF standalone results
186			Float_t GetdEdx_pmtstd(Int_t ipmt) { return eDEDXpmtstd[ipmt]; } // 0-47 dEdx for each PMT for tracked events
187			Float_t GetCharge_pmtstd(Int_t ipmt) {return eZpmtstd[ipmt];} // 0-47 Z for each PMT for tracked events
188			Float_t GetdEdx_padstd(Int_t ipad) {return eDEDXpadstd[ipad];} // 0-23 dEdx for each paddle for tracked events (no request of consistency between PMT's response when both on!)
189			Float_t GetCharge_padstd(Int_t ipad) {return eZpadstd[ipad];} // 0-23 Z for each paddle for tracked events (no request of consistency)
190			Float_t GetdEdx_layerstd(Int_t ilay) {return eDEDXlayerstd[ilay];} // 0-5 dEdx for each layer for tracked events
191			Float_t GetCharge_layerstd(Int_t ilay) {return eZlayerstd[ilay];} // 0-5 Z for each layer for tracked events
192
193
194
195			Float_t GetInfo_pmt(Int_t ipmt) {return INFOpmt[ipmt];} // 0-47 pmt status
196
197			/* INFOpmt table:
198
199			INFOpmt[ii]=0 ---> everithing is ok!
200			INFOpmt[ii]=1 ---> beta not good (<0.05 \|\| >2)
201			INFOpmt[ii]=2 ---> PMT OFF
202			INFOpmt[ii]=3 ---> PMT saturated
203			INFOpmt[ii]=4 ---> error during the correction for the incidence angle
204			INFOpmt[ii]=5 ---> error during the correction for the dependence on the position
205			INFOpmt[ii]=6 ---> error in dEdx reconstruction
206			INFOpmt[ii]=7 ---> error in Z reconstruction
207			*/
208
209			Float_t GetInfo_layer(Int_t ilay) {return INFOlayer[ilay];} // 0-5 layer status
210
211			/* INFOlayer table:
212
213			INFOlayer[ii]=0 ---> everithing is ok!
214			INFOlayer[ii]=1 ---> beta not good (<0.05 \|\| >2)
215			INFOlayer[ii]=2 ---> only one PMT is OFF (but you get the other one to have the measurement)
216			INFOlayer[ii]=3 ---> only one PMT is saturated (but you get the other one to have the measurement)
217			INFOlayer[ii]=4 ---> only one PMT with a wrong reconstruction (but you get the other one to have the measurement)
218			INFOlayer[ii]=5 ---> the 2 PMTs involved give different measurement (actually they differ for more then 1.5, to be tuned...)
219			INFOlayer[ii]=6 ---> saturated layer (both PMTs)
220			INFOlayer[ii]=7 ---> all PMTs show some error during reconstruction
221			INFOlayer[ii]=8 ---> 1 PMT is OFF and 1 is saturated (it happens quiet only on S115...)
222			INFOlayer[ii]=9 ---> OFF layer
223			*/
224
225			private:
226			double f_adcPC( float x );
227
228			double f_BB( TArrayF &p, float x );
229			double f_BBpol4( TArrayF &p, float x );
230
231			double f_BB5B( float x );
232			double f_BB5Bpol4( float x );
233
234
235			// double f_att( TArrayF &p, float x ) ;
236			double f_att(float C0, float C1, float C2, float C3, float C4, float C5, float x ) ;
237			double f_att5B( float x );
238			double f_desatBB( TArrayF &p, float x );
239			double f_desatBB5B( float x );
240			double f_pos( TArrayF &p, float x );
241			double f_pos5B( float x );
242			// float Get_adc_he( int id, float pl_x[6], float pl_y[6]);
243			float Get_adc_he( int id, float x);
244
245
246
247
248			ClassDef(ToFdEdx_patch,1);
249			};
250
251			#endif
252