TrackerLevel2/inc/ExtTrkingAlg.h

/**
 * \file ExtTrkingAlg.h
 * \author Elena Vannuccini
 */
#ifndef exttrkingalg_h
#define exttrkingalg_h

// PAMELA classes
#include <TrkLevel1.h>
#include <TrkLevel2.h>

#include <ToFLevel2.h>

#include <CaloLevel1.h>
#include <CaloLevel2.h>

#include <ExtTrack.h>

// ROOT classes
#include <TClonesArray.h>


#include <stdlib.h>
#include <map>
#include <iostream>
#include <iomanip>


#define nCP 22;
#define nCV 2;
#define nCS 9;

 //         relative to pamela reference system (convenzione emiliano):
 //
 //        y ^
 //          |
 //          | 6 7 8 sisensor
 //          | 3 4 5   
 //          | 0 1 2 
 //          ------------> x 
 //
 //        relative to silicon sensor           
 //
 //        S ^
 //          |   |
 //        2 |   |  <- strip direction
 // sensor 1 |   | 
 //        0 |...|...
 //          ------------> L
 //            0 1 2 
 //            ladder
 //
 //

int GetCaloSensor(int view, int sis){
    if(sis<0||sis>8)return -1;
    if(view<0||view>1)return -1;
    if(!view)return (int)(sis/3); 
    else return sis%3; 
};
int GetCaloLadder(int view, int sis){ 
    if(sis<0||sis>8)return -1;
    if(view<0||view>1)return -1;
    if(!view)return sis%3;  
    else return (int)(sis/3); 
};
int GetCaloLadder(int strip){ 
    return (int)(strip/32);
};
int GetCaloSiSensor(int view, int l, int s){
    if(view<0||view>1)return -1;
    if(s<0||s>2)return -1;
    if(!view) return 3*s+l;
    else      return 3*l+s;
};

/**
 *
 * Extended CaloStrip class, to account for rototraslation parameters
 *
 */
class CaloStripRoto  {

 private:

  float fPitch; // = 1.;
  float shift[3]; //= {0.,0.,0.};//(L,S,Z)
  float alpha;//  = 0.;

  int   siSensor; // 0-8
  int sView;//0-1
  int sPlane;//0-21
  CaloStrip st;
  
  void Set(int view, int plane, float strip, int sisensor); ///< Set strip giving view [0-1], plane [0-22] and number [0-95]
  void SetSiSensor( int si=-1  ){ siSensor = si;};
  void SetView(int view){sView = view;};
  void SetPlane(int plane){sPlane = plane;};

 public:

/*   CaloStrip st; */


  float fXA; //< X position in cm of the strip
  float fYA; //< Y position in cm of the strip
  float fZA; //< Z position in cm of the strip

  float fXB; //< X position in cm of the strip
  float fYB; //< Y position in cm of the strip
  float fZB; //< Z position in cm of the strip
  
  //
  CaloStripRoto(int view, int plane, int sisensor, bool usemechanicalalignement = true); ///< Default Constructor.


  void ResetAligParams();
  void SetAligParams__fPitch( float f ){ fPitch = f; };
  void SetAligParams__shift( float *s ){ for(int i=0; i<3; i++)shift[i]=s[i]; };
  void SetAligParams__alpha( float a ){ alpha = a; };

  void SetStrip(float strip){Set(GetView(),GetPlane(),strip,GetSiSensor());}; ///< Set strip giving view [0-1], plane [0-22] and number [0-95]


/*   int GetSensor(int view, int sisensor); */
/*   int GetLadder(int view, int sisensor); */
/*   int GetSiSensor(int view, int ladder, int sensor); */
  //  CaloStrip GetCaloStrip(){return st;};
  bool SensorContains(float x, float y);
  
  int GetView(){return sView;};
  int GetPlane(){return sPlane;};
  int GetStrip(){return st.GetStrip();};
  int GetSensor();
  int GetLadder();
  int GetSiSensor(){ return siSensor; };
  
  float GetSpatialResolution(float def, float degx=0., float degy=0.,  float beta=1.);

  float GetDistanceTo(float xP, float yP, float& xM, float &yM);
  float GetDistanceTo(float xP, float yP){ float xM,yM; return GetDistanceTo(xP,yP,xM,yM); };

};


/**
 *
 * Extended hit class
 *
 */


class ExtHit{

 private:


 public:

 
  Float_t coordCm; //centimeters
  Float_t coordPU; //pitch units
  Float_t resCm; 
  Float_t signal;
  Int_t start; 
  Int_t mult;
  Int_t view;

  
  void Reset(){    
    coordCm = 1000.;
    coordPU = 1000.;
    resCm   = 1000.;
    signal  = 0.;
    start   = -1; 
    mult    = 0;
    view    = -1;
  };
  void Set(int s, int v){start=s; view=v;}   
  /* void Set(int s, int v){coordPU=s; view=v;}   */

  ExtHit(){Reset();};
  ExtHit(int s, int v){Reset(); Set(s,v); };
  ~ExtHit(){Reset();};

  ExtHit( const ExtHit& h ){
    coordCm = h.coordCm;
    coordPU = h.coordPU;
    resCm   = h.resCm;
    signal  = h.signal;
     start   = h.start; 
    mult    = h.mult;
    view    = h.view;
  }

  void Add(float cc, float pp, float ss){
    if(ss<0)cout << "void ExtHit(cc="<<cc<<",ss="<<ss<<") -- not valid argument";
    if(ss<0)return;
    mult++;
    float sumcc =  coordCm * signal;
    float sumpp =  coordPU * signal;
    signal+=ss;
    sumcc += ss * cc;
    sumpp += ss * pp;
    coordCm = sumcc/signal;
    coordPU = sumpp/signal;
  };

  void Dump(){
    cout << " View  "<<view<<endl;
    cout << " Coordinate (cm)   "<<coordCm<<endl;
    cout << " Coordinate (p.u.) "<<coordPU<<endl;
    cout << " Resolution (cm) "<<resCm<<endl;
    cout << " Multiplicity  "<<mult<<endl;
    cout << " Signal (MIP)  "<<signal<<endl;    
  };

  //  ClassDef(ExtHit,1);

};

/**
 *
 * Algorythm class
 *
 */


class ExtTrkingAlg : public TObject {

private:

  Int_t  _whichAlg;         ///< algorythm id

  TClonesArray *_trkArray; ///< array of tracks
  
  TrkLevel1*  _trk_l1; 
  TrkLevel2*  _trk_l2;
  
  CaloLevel1* _cal_l1;
  CaloLevel2* _cal_l2;
  vector<ExtHit> _cal_cl;///< calorimeter hits

  ToFLevel2*  _tof_l2;
  vector<ExtHit> _trk_cl;///< tracker hits

  ExtTrack* _extTrack;
  float*    _zMech;

  Int_t _sel_nClstrMAX;  ///< selection parameter: maximum number of cluster
  Int_t _sel_nPlaneXMIN; ///< selection parameter: minimum number of hit x-views
  Int_t _sel_nPlaneYMIN; ///< selection parameter: minimum number of hit y-views

  Int_t _alg_nClFixX;     ///< algorythm parameter: n.hits required on X view
  Int_t _alg_nClFixY;     ///< algorythm parameter:n.hits required on Y view
  Int_t _alg_nTrackMAX;   ///< algorythm parameter: maximum num. of track candidates
  Int_t _alg_nViewCal;    ///< algorythm parameter: n. calorimeter planes included 

  Int_t NEXTVIEWS;
  Int_t NEXTPLANES;

  float _caloCoord[2][22][96];
  float _caloZ[44];
  Trajectory* _caloTj;
  Trajectory* _tgf;


  vector<CaloStripRoto> _caloStripRoto; // rotatore di calorimetri! sapevatelo!

  Bool_t _debug;

public:

  void Clear(Option_t* option = "");    ///< Clear the event
  void Delete();                        ///< Delete all (deallocate arrays)

  ExtTrkingAlg(Int_t id=0);
  //  ExtTrkingAlg(){ ExtTrkingAlg(0); };  
  ~ExtTrkingAlg(){ Delete(); };

  //  ExtTrkingAlg(Int_t id);

  void SetTrkLevel1( TrkLevel1* trkl1 = NULL )   { _trk_l1  = trkl1;};
  void SetTrkLevel2( TrkLevel2* trkl2 = NULL )   { _trk_l2  = trkl2; };
  void SetToFLevel2( ToFLevel2* tofl2 = NULL )   { _tof_l2  = tofl2; };
  void SetCaloLevel1( CaloLevel1* call1 = NULL ) { _cal_l1  = call1; };
  void SetCaloLevel2( CaloLevel2* call2 = NULL ) { _cal_l2  = call2; };

  
  void FillClusterMap(multimap<int,int> &map,TrkLevel1* l1,Int_t vOffset = 0);
  void FillClusterMap(multimap<int,int> &map,CaloLevel1* l1,Int_t vOffset = 12);

  Bool_t CheckEvent();                        ///< pre-selection
  void ProcessEvent0(Bool_t force = false);    ///< apply tracking algorythm 0
  void ProcessEvent1(Bool_t force = false);    ///< apply tracking algorythm 1
  void ProcessEvent2(Bool_t force = false);    ///< apply tracking algorythm 1
  void ProcessEvent(Bool_t force = false);
  bool EvaluateClusterPosition_Tracker( int, int, int, int, float*, float*, float*);  
  bool EvaluateClusterPosition_Calorimeter( int icl, int& sensor, float *xmABar, float *ymABar, float *zmAB, float def=0.);


  TClonesArray *GetTrackArray(Bool_t reset = false);

  void SetSelectionParams(double* par);
  void SetAlgorythmParams(double* par);


  void SetDebug(Bool_t dbg = false){ _debug = dbg; };

  void Dump();

  TClonesArray** GetPointerToTrackArray(){ return &_trkArray; };

  vector<ExtHit> GetCaloClusters(){ return _cal_cl; };
  vector<ExtHit> GetTrkClusters(){ return _trk_cl; };

  CaloStripRoto GetCaloStripRoto(int index){ return _caloStripRoto[index]; };


};


#endif
1	pam-fi	1.1	/**
2			* \file ExtTrkingAlg.h
3			* \author Elena Vannuccini
4			*/
5			#ifndef exttrkingalg_h
6			#define exttrkingalg_h
7
8			// PAMELA classes
9			#include <TrkLevel1.h>
10			#include <TrkLevel2.h>
11
12			#include <ToFLevel2.h>
13
14			#include <CaloLevel1.h>
15			#include <CaloLevel2.h>
16
17	pam-ts	1.2	#include <ExtTrack.h>
18	pam-fi	1.1
19			// ROOT classes
20			#include <TClonesArray.h>
21
22
23
24			#include <stdlib.h>
25			#include <map>
26			#include <iostream>
27			#include <iomanip>
28
29	pam-ts	1.2
30			#define nCP 22;
31			#define nCV 2;
32			#define nCS 9;
33
34			// relative to pamela reference system (convenzione emiliano):
35			//
36			// y ^
37			// \|
38			// \| 6 7 8 sisensor
39			// \| 3 4 5
40			// \| 0 1 2
41			// ------------> x
42			//
43			// relative to silicon sensor
44			//
45			// S ^
46			// \| \|
47			// 2 \| \| <- strip direction
48			// sensor 1 \| \|
49			// 0 \|...\|...
50			// ------------> L
51			// 0 1 2
52			// ladder
53			//
54			//
55
56			int GetCaloSensor(int view, int sis){
57			if(sis<0\|\|sis>8)return -1;
58			if(view<0\|\|view>1)return -1;
59			if(!view)return (int)(sis/3);
60			else return sis%3;
61			};
62			int GetCaloLadder(int view, int sis){
63			if(sis<0\|\|sis>8)return -1;
64			if(view<0\|\|view>1)return -1;
65			if(!view)return sis%3;
66			else return (int)(sis/3);
67			};
68			int GetCaloLadder(int strip){
69			return (int)(strip/32);
70			};
71			int GetCaloSiSensor(int view, int l, int s){
72			if(view<0\|\|view>1)return -1;
73			if(s<0\|\|s>2)return -1;
74			if(!view) return 3*s+l;
75			else return 3*l+s;
76			};
77
78			/**
79			*
80			* Extended CaloStrip class, to account for rototraslation parameters
81			*
82			*/
83			class CaloStripRoto {
84
85			private:
86
87			float fPitch; // = 1.;
88			float shift[3]; //= {0.,0.,0.};//(L,S,Z)
89			float alpha;// = 0.;
90
91			int siSensor; // 0-8
92			int sView;//0-1
93			int sPlane;//0-21
94			CaloStrip st;
95
96			void Set(int view, int plane, float strip, int sisensor); ///< Set strip giving view [0-1], plane [0-22] and number [0-95]
97			void SetSiSensor( int si=-1 ){ siSensor = si;};
98			void SetView(int view){sView = view;};
99			void SetPlane(int plane){sPlane = plane;};
100
101			public:
102
103			/* CaloStrip st; */
104
105
106			float fXA; //< X position in cm of the strip
107			float fYA; //< Y position in cm of the strip
108			float fZA; //< Z position in cm of the strip
109
110			float fXB; //< X position in cm of the strip
111			float fYB; //< Y position in cm of the strip
112			float fZB; //< Z position in cm of the strip
113
114			//
115			CaloStripRoto(int view, int plane, int sisensor, bool usemechanicalalignement = true); ///< Default Constructor.
116
117
118
119			void ResetAligParams();
120			void SetAligParams__fPitch( float f ){ fPitch = f; };
121			void SetAligParams__shift( float *s ){ for(int i=0; i<3; i++)shift[i]=s[i]; };
122			void SetAligParams__alpha( float a ){ alpha = a; };
123
124			void SetStrip(float strip){Set(GetView(),GetPlane(),strip,GetSiSensor());}; ///< Set strip giving view [0-1], plane [0-22] and number [0-95]
125
126
127
128			/* int GetSensor(int view, int sisensor); */
129			/* int GetLadder(int view, int sisensor); */
130			/* int GetSiSensor(int view, int ladder, int sensor); */
131			// CaloStrip GetCaloStrip(){return st;};
132			bool SensorContains(float x, float y);
133
134			int GetView(){return sView;};
135			int GetPlane(){return sPlane;};
136			int GetStrip(){return st.GetStrip();};
137			int GetSensor();
138			int GetLadder();
139			int GetSiSensor(){ return siSensor; };
140
141			float GetSpatialResolution(float def, float degx=0., float degy=0., float beta=1.);
142
143			float GetDistanceTo(float xP, float yP, float& xM, float &yM);
144			float GetDistanceTo(float xP, float yP){ float xM,yM; return GetDistanceTo(xP,yP,xM,yM); };
145
146			};
147
148
149			/**
150			*
151			* Extended hit class
152			*
153			*/
154
155
156			class ExtHit{
157
158			private:
159
160
161			public:
162
163
164			Float_t coordCm; //centimeters
165			Float_t coordPU; //pitch units
166			Float_t resCm;
167			Float_t signal;
168			Int_t start;
169			Int_t mult;
170			Int_t view;
171
172
173			void Reset(){
174			coordCm = 1000.;
175			coordPU = 1000.;
176			resCm = 1000.;
177			signal = 0.;
178			start = -1;
179			mult = 0;
180			view = -1;
181			};
182			void Set(int s, int v){start=s; view=v;}
183			/* void Set(int s, int v){coordPU=s; view=v;} */
184
185			ExtHit(){Reset();};
186			ExtHit(int s, int v){Reset(); Set(s,v); };
187			~ExtHit(){Reset();};
188
189			ExtHit( const ExtHit& h ){
190			coordCm = h.coordCm;
191			coordPU = h.coordPU;
192			resCm = h.resCm;
193			signal = h.signal;
194			start = h.start;
195			mult = h.mult;
196			view = h.view;
197			}
198
199			void Add(float cc, float pp, float ss){
200			if(ss<0)cout << "void ExtHit(cc="<<cc<<",ss="<<ss<<") -- not valid argument";
201			if(ss<0)return;
202			mult++;
203			float sumcc = coordCm * signal;
204			float sumpp = coordPU * signal;
205			signal+=ss;
206			sumcc += ss * cc;
207			sumpp += ss * pp;
208			coordCm = sumcc/signal;
209			coordPU = sumpp/signal;
210			};
211
212			void Dump(){
213			cout << " View "<<view<<endl;
214			cout << " Coordinate (cm) "<<coordCm<<endl;
215			cout << " Coordinate (p.u.) "<<coordPU<<endl;
216			cout << " Resolution (cm) "<<resCm<<endl;
217			cout << " Multiplicity "<<mult<<endl;
218			cout << " Signal (MIP) "<<signal<<endl;
219			};
220
221			// ClassDef(ExtHit,1);
222
223			};
224
225			/**
226			*
227			* Algorythm class
228			*
229			*/
230
231
232
233	pam-fi	1.1	class ExtTrkingAlg : public TObject {
234
235			private:
236
237			Int_t _whichAlg; ///< algorythm id
238
239			TClonesArray *_trkArray; ///< array of tracks
240
241			TrkLevel1* _trk_l1;
242			TrkLevel2* _trk_l2;
243
244			CaloLevel1* _cal_l1;
245			CaloLevel2* _cal_l2;
246	pam-ts	1.2	vector<ExtHit> _cal_cl;///< calorimeter hits
247	pam-fi	1.1
248			ToFLevel2* _tof_l2;
249	pam-ts	1.2	vector<ExtHit> _trk_cl;///< tracker hits
250
251			ExtTrack* _extTrack;
252			float* _zMech;
253	pam-fi	1.1
254			Int_t _sel_nClstrMAX; ///< selection parameter: maximum number of cluster
255			Int_t _sel_nPlaneXMIN; ///< selection parameter: minimum number of hit x-views
256			Int_t _sel_nPlaneYMIN; ///< selection parameter: minimum number of hit y-views
257
258			Int_t _alg_nClFixX; ///< algorythm parameter: n.hits required on X view
259	pam-ts	1.2	Int_t _alg_nClFixY; ///< algorythm parameter:n.hits required on Y view
260	pam-ts	1.3	Int_t _alg_nTrackMAX; ///< algorythm parameter: maximum num. of track candidates
261			Int_t _alg_nViewCal; ///< algorythm parameter: n. calorimeter planes included
262	pam-ts	1.2
263			Int_t NEXTVIEWS;
264			Int_t NEXTPLANES;
265
266			float _caloCoord[2][22][96];
267			float _caloZ[44];
268			Trajectory* _caloTj;
269			Trajectory* _tgf;
270
271
272			vector<CaloStripRoto> _caloStripRoto; // rotatore di calorimetri! sapevatelo!
273	pam-fi	1.1
274			Bool_t _debug;
275
276			public:
277
278			void Clear(Option_t* option = ""); ///< Clear the event
279	pam-ts	1.2	void Delete(); ///< Delete all (deallocate arrays)
280	pam-fi	1.1
281			ExtTrkingAlg(Int_t id=0);
282			// ExtTrkingAlg(){ ExtTrkingAlg(0); };
283			~ExtTrkingAlg(){ Delete(); };
284
285			// ExtTrkingAlg(Int_t id);
286
287			void SetTrkLevel1( TrkLevel1* trkl1 = NULL ) { _trk_l1 = trkl1;};
288			void SetTrkLevel2( TrkLevel2* trkl2 = NULL ) { _trk_l2 = trkl2; };
289			void SetToFLevel2( ToFLevel2* tofl2 = NULL ) { _tof_l2 = tofl2; };
290			void SetCaloLevel1( CaloLevel1* call1 = NULL ) { _cal_l1 = call1; };
291			void SetCaloLevel2( CaloLevel2* call2 = NULL ) { _cal_l2 = call2; };
292
293	pam-ts	1.2
294			void FillClusterMap(multimap<int,int> &map,TrkLevel1* l1,Int_t vOffset = 0);
295			void FillClusterMap(multimap<int,int> &map,CaloLevel1* l1,Int_t vOffset = 12);
296
297	pam-fi	1.1	Bool_t CheckEvent(); ///< pre-selection
298	pam-ts	1.2	void ProcessEvent0(Bool_t force = false); ///< apply tracking algorythm 0
299			void ProcessEvent1(Bool_t force = false); ///< apply tracking algorythm 1
300			void ProcessEvent2(Bool_t force = false); ///< apply tracking algorythm 1
301			void ProcessEvent(Bool_t force = false);
302			bool EvaluateClusterPosition_Tracker( int, int, int, int, float, float, float*);
303			bool EvaluateClusterPosition_Calorimeter( int icl, int& sensor, float xmABar, float ymABar, float *zmAB, float def=0.);
304
305	pam-fi	1.1
306			TClonesArray *GetTrackArray(Bool_t reset = false);
307
308			void SetSelectionParams(double* par);
309			void SetAlgorythmParams(double* par);
310
311	pam-ts	1.2
312	pam-fi	1.1	void SetDebug(Bool_t dbg = false){ _debug = dbg; };
313
314			void Dump();
315
316			TClonesArray** GetPointerToTrackArray(){ return &_trkArray; };
317
318	pam-ts	1.2	vector<ExtHit> GetCaloClusters(){ return _cal_cl; };
319			vector<ExtHit> GetTrkClusters(){ return _trk_cl; };
320
321			CaloStripRoto GetCaloStripRoto(int index){ return _caloStripRoto[index]; };
322
323
324	pam-fi	1.1	};
325
326
327			#endif