added slewing correction by data
[u/mrichter/AliRoot.git] / TRD / AliTRDtrackletOflHelper.cxx
1 #include "TObjArray.h"
2 #include "TMath.h"
3
4 #include "AliLog.h"
5 #include "AliMathBase.h"
6
7 #include "AliTRDseedV1.h"
8 #include "AliTRDcluster.h"
9 #include "AliTRDpadPlane.h"
10 #include "AliTRDtrackletOflHelper.h"
11
12 ClassImp(AliTRDtrackletOflHelper)
13 //___________________________________________________________________
14 AliTRDtrackletOflHelper::AliTRDtrackletOflHelper() 
15   :TObject()
16   ,fRow(-1)
17   ,fClusters(NULL)
18   ,fPadPlane(NULL)
19 {
20 // Default constructor
21   fCol[0]=144; fCol[1]=0;
22   fTBrange[0]=1; fTBrange[1]=21;
23 }
24
25 //___________________________________________________________________
26 AliTRDtrackletOflHelper::AliTRDtrackletOflHelper(const AliTRDtrackletOflHelper &ref) 
27   :TObject(ref)
28   ,fRow(-1)
29   ,fClusters(NULL)
30   ,fPadPlane(ref.fPadPlane)
31 {
32 // Copy constructor
33   fRow = ref.fRow; fCol[0]=ref.fCol[0]; fCol[1]=ref.fCol[1];
34   fTBrange[0] = ref.fTBrange[0];fTBrange[1] = ref.fTBrange[1];
35   Int_t n(0);
36   if(ref.fClusters){
37     if((n = ref.fClusters->GetEntriesFast())) {
38       fClusters = new TObjArray(n);
39       for(Int_t ic(n); ic--;) fClusters->AddAt(ref.fClusters->At(ic), ic);
40     }
41   }
42 }
43
44 //___________________________________________________________________
45 AliTRDtrackletOflHelper& AliTRDtrackletOflHelper::operator=(const AliTRDtrackletOflHelper &rhs)
46 {
47   if(this != &rhs){
48     TObject::operator=(rhs);
49     fPadPlane  = rhs.fPadPlane;
50     fRow       = rhs.fRow;
51     fCol[0]    = rhs.fCol[0];
52     fCol[1]    = rhs.fCol[1];
53     fTBrange[0]= rhs.fTBrange[0];
54     fTBrange[1]= rhs.fTBrange[1];
55     if(rhs.fClusters){ 
56       Int_t n(rhs.fClusters->GetEntriesFast());
57       if(!fClusters) fClusters = new TObjArray(n);
58       if(fClusters->GetEntriesFast() != n){ 
59         fClusters->Clear();
60         fClusters->Expand(n);
61       }
62       for(Int_t ic(n); ic--;)  fClusters->AddAt(rhs.fClusters->At(ic), ic);
63     } else {
64       if(fClusters) delete fClusters;
65     }
66   }
67   return *this;
68 }
69
70 //___________________________________________________________________
71 AliTRDtrackletOflHelper::~AliTRDtrackletOflHelper()
72 {
73 // Clean helper  
74   if(fClusters) fClusters->Clear();
75   delete fClusters;
76 }
77
78 //___________________________________________________________________
79 Int_t AliTRDtrackletOflHelper::Expand(TObjArray *cls, Int_t *mark, Int_t groupId)
80 {
81 // Allocate new clusters for this helper.  If a subset of clusters is to be allocated 
82 // this can be specified via the identifier "groupId" which have to be compared 
83 // with individual elements in the array "mark".
84 // 
85 // Return total no. of clusters in helper
86
87   if(!fPadPlane || !fClusters ){
88     AliError("Helper not initialized."); 
89     return 0;
90   }
91   Int_t ncl(fClusters->GetEntriesFast());
92   Int_t mcl(cls->GetEntriesFast());
93   fClusters->Expand(mcl + ncl);
94   fCol[0]=144; fCol[1]=0;
95   AliTRDcluster *c(NULL);
96   for(Int_t icl(0), jcl(ncl); icl<mcl; icl++){
97     if(!(c=(AliTRDcluster*)cls->At(icl))) continue;
98     if(mark && mark[icl]!=groupId) continue;
99     fClusters->AddAt(c, jcl++);
100     Int_t col(c->GetPadCol());
101     Short_t *sig(c->GetSignals());
102     for(Int_t icol(0), jcol(col-3); icol<7; icol++, jcol++){
103       if(sig[icol]==0) continue;
104       if(jcol<fCol[0]) fCol[0]=jcol;
105       if(jcol>fCol[1]) fCol[1]=jcol;
106     }
107   }
108
109   AliDebug(1, Form("Segment[%d] Clusters[%2d] pad[%3d %3d].", groupId, fClusters->GetEntriesFast(), fCol[0], fCol[1]));
110   return fClusters->GetEntriesFast();
111 }
112
113
114 //___________________________________________________________________
115 Int_t AliTRDtrackletOflHelper::Init(AliTRDpadPlane *p, TObjArray *cls, Int_t *mark, Int_t groupId)
116 {
117 // Allocate clusters for this helper.  If a subset of clusters is to be allocated 
118 // this can be specified via the identifier "groupId" which have to be compared 
119 // with individual elements in the array "mark".
120 // 
121 // Return no. of clusters allocated
122
123   if(!p){
124     AliError("PadPlane not initialized."); return 0;
125   }
126   if(!cls){
127     AliError("Cluster array not initialized."); return 0;
128   }
129   Int_t ncl(cls->GetEntriesFast());
130   if(ncl<2){ 
131     AliDebug(1, Form("Segment[%d] failed n[%d].", groupId, ncl)); return 0;
132   }
133   Int_t mcl(ncl);
134   if(mark){
135     mcl = 0;
136     for(Int_t icl(ncl); icl--;) 
137       if(cls->At(icl) && mark[icl]==groupId) mcl++;
138   }  
139   if(mcl<2){ 
140     AliDebug(1, Form("Segment[%d] failed n[%d] in group.", groupId, mcl)); return 0;
141   }
142   if(!fClusters) fClusters = new TObjArray(mcl);
143   else{ 
144     fClusters->Clear();
145     fClusters->Expand(mcl);
146   }
147   fCol[0]=144; fCol[1]=0; fRow=-1;
148   AliTRDcluster *c(NULL);
149   for(Int_t icl(0), jcl(0); icl<ncl; icl++){
150     if(!(c=(AliTRDcluster*)cls->At(icl))) continue;
151     if(mark && mark[icl]!=groupId) continue;
152     fClusters->AddAt(c, jcl++);
153     if(fRow<0) fRow = c->GetPadRow();
154     Int_t col(c->GetPadCol());
155     Short_t *sig(c->GetSignals());
156     for(Int_t icol(0), jcol(col-3); icol<7; icol++, jcol++){
157       if(sig[icol]==0) continue;
158       if(jcol<fCol[0]) fCol[0]=jcol;
159       if(jcol>fCol[1]) fCol[1]=jcol;
160     }
161   }
162   fPadPlane = p;
163   
164   AliDebug(1, Form("Segment[%d] Clusters[%2d] pad[%3d %3d].", groupId, fClusters->GetEntriesFast(), fCol[0], fCol[1]));
165   return fClusters->GetEntriesFast();
166 }
167
168 //___________________________________________________________________
169 Int_t AliTRDtrackletOflHelper::ClassifyTopology()
170 {
171 // Classify topology and return classification code
172 // 0 - normal tracklet
173 // 1 - delta ray candidate
174 // 2 - secondary candidate
175 // 3 - "elephant" candidate
176 // 4 - unknown topology
177
178   if(!fClusters){ 
179     AliError("Helper not initialized. Missing clusters.");
180     return kUnknown;
181   }
182   Int_t ncl(fClusters->GetEntries());
183   if(!ncl){ 
184     AliError("Helper not initialized. No cluster allocated.");
185     return kUnknown;
186   }
187   const Int_t kRange(22); // DEFINE based on vd 
188   
189   // compute local occupancy
190   Int_t localOccupancy[AliTRDseedV1::kNtb]; memset(localOccupancy, 0, AliTRDseedV1::kNtb*sizeof(Int_t));
191   AliTRDcluster *c(NULL);
192   Double_t sy[kNcls]; Int_t mcl(0);
193   for(Int_t icl(ncl), time; icl--;){
194     c = (AliTRDcluster*)fClusters->At(icl);
195     time = c->GetPadTime();
196     if(time==0 || time>=kRange){
197       sy[icl] = -1; // mark clusters outsde drift volume
198       continue;
199     }
200     // protect against wrong error param.
201     if(c->GetSigmaY2() < 1.e-5) sy[icl] = 0.02;
202     else sy[icl] = TMath::Min(TMath::Sqrt(c->GetSigmaY2()), 0.04);
203     localOccupancy[time]++;
204     mcl++;
205   }
206   if(!mcl){
207     AliWarning("No clusters in the active area.");
208     return kUnknown;
209   } 
210   //compute number of 0 bins and high occupancy
211   Int_t goodOccupancy(0), highOccupancy(0), lowOccupancy(0);
212   for(Int_t itb(1); itb<kRange; itb++){
213     switch(localOccupancy[itb]){ 
214       case 0: lowOccupancy++; break;
215       case 1: goodOccupancy++; break;
216       default: highOccupancy++; break;
217     }
218   }
219   AliDebug(2, Form("H[%2d | %5.2f%%] L[%2d | %5.2f%%] N[%2d | %5.2f%% | %5.2f%%]",
220           highOccupancy, 100.*highOccupancy/kRange, 
221           lowOccupancy, 100.*lowOccupancy/kRange, 
222           goodOccupancy, 100.*goodOccupancy/kRange, 100.*goodOccupancy/mcl));
223   
224   // filter
225   Double_t dy[kNcls];
226   if(goodOccupancy==mcl) return kNormal;
227   else if(Double_t(goodOccupancy)/kRange > 0.9){
228     if(highOccupancy == 0 ) {
229       if(!FitPSR(dy)) return kUnknown;
230       Int_t nin(0);
231       for(Int_t idy(ncl); idy--;){
232         if(sy[idy]<0.) continue;
233         if(dy[idy] > 3*sy[idy]) continue;
234         nin ++;
235       }
236       if(Double_t(nin)/mcl > 0.8) return kNormal;
237       else return kUnknown;
238     } else return kDeltaRay;
239   } else return kUnknown;
240 }
241
242
243 //___________________________________________________________________
244 void AliTRDtrackletOflHelper::FindSolidCls(Bool_t *mark, Int_t *q)
245 {
246 //  Find clusters produced by large fluctuations of energy deposits
247 //  Largest charge and well separation from neighbors
248
249   Int_t ntb(AliTRDseedV1::kNtb);
250   Int_t idx[ntb+1];
251   TMath::Sort(ntb, q, idx, kTRUE);
252   Int_t qmax = Int_t(0.3*q[idx[0]]);
253   mark[0] = kFALSE;
254   for(Int_t icl(ntb-5); icl<ntb; icl++) mark[icl] = kFALSE;
255   for(Int_t icl(0); icl<ntb; icl++){
256     Int_t jcl(idx[icl]);
257     if(!mark[jcl]) continue;
258     if(q[jcl-1]>q[jcl] || q[jcl+1]>q[jcl]){
259       mark[jcl] = kFALSE;
260       continue;
261     }
262     if(q[jcl] < qmax){
263       mark[jcl] = kFALSE;
264       continue;
265     }
266     for(Int_t kcl=TMath::Max(0, jcl-2); kcl<jcl+3; kcl++){
267       if(kcl==jcl) continue;
268       mark[kcl] = kFALSE;
269     }
270   }
271 }
272
273 //___________________________________________________________________
274 Bool_t AliTRDtrackletOflHelper::FitPSR(Double_t dy[200], Bool_t useSolid)
275 {
276 // Fit tracklet in Pad System of Reference [PSR] to avoid uncertainty related to 
277 // Lorentz angle correction
278
279   Bool_t mark[200]; memset(mark, 0, 200*sizeof(Bool_t));
280   Int_t q[200]; memset(q, 0, 200*sizeof(Int_t));
281   Int_t ncl(fClusters->GetEntries());
282   AliTRDcluster *c(NULL);
283   for(Int_t icl(ncl); icl--;){
284     c = (AliTRDcluster*)fClusters->At(icl);
285     if(c->GetPadRow() != fRow) continue;
286     Int_t time(c->GetPadTime());
287     mark[time] = kTRUE; q[time] = Int_t(c->GetQ());
288   }
289   if(useSolid) FindSolidCls(mark, q);
290   
291   Double_t 
292     x[AliTRDseedV1::kNtb], y[AliTRDseedV1::kNtb], sy[AliTRDseedV1::kNtb], 
293     xf[AliTRDseedV1::kNtb], yf[AliTRDseedV1::kNtb], syf[AliTRDseedV1::kNtb], 
294     par[3];
295   Int_t jcl(0), kcl(0);
296   for(Int_t icl(0); icl<ncl; icl++){
297     c = (AliTRDcluster*)fClusters->At(icl);
298     if(c->GetPadRow() != fRow) continue;
299     Int_t col(c->GetPadCol());
300     Int_t time(c->GetPadTime());
301     Double_t center(c->GetCenter());
302     Double_t cw(fPadPlane->GetColSize(col));
303     //Double_t corr = AliTRDcluster::GetYcorr(AliTRDgeometry::GetLayer(det), center);
304     y[jcl] = fPadPlane->GetColPos(col) + (.5 + center)*cw /*+ corr*/;
305     x[jcl] = c->GetX();
306     sy[jcl]= TMath::Sqrt(c->GetSigmaY2());
307     if(mark[time]){
308       yf[kcl] = y[jcl];
309       xf[kcl] = x[jcl];
310       syf[kcl]= useSolid ? 0.5/time:sy[jcl];
311       kcl++;
312     } 
313     jcl++;
314   }
315   Fit(kcl, xf, yf, syf, par);
316
317   for(Int_t icl(0); icl<jcl; icl++){
318     Double_t dx(x[icl] - par[2]);
319     dy[icl] = y[icl] - (par[0] + par[1]*dx);
320   }
321   return kTRUE;
322 }
323
324 //___________________________________________________________________
325 Bool_t AliTRDtrackletOflHelper::Fit(Int_t n, Double_t *x, Double_t *y, Double_t *sy, Double_t *par, Double_t sCut,  Double_t *cov)
326 {
327 // Iterative robust tracklet fit 
328   if(n<3) return kFALSE;
329   //select reference radial position
330   if(par[2]<0.){ //compute reference radial position as <x>
331     par[2] = 0.; for(Int_t ic(n); ic--;) par[2] += x[ic]; par[2] /= n;
332   }
333   AliTRDtrackerV1::AliTRDLeastSquare &f=Fitter();
334   for(Int_t iter(0); iter<3; iter++){
335     f.Reset();
336     Int_t jp(0);
337     for(Int_t ip(0); ip<n; ip++){
338       Double_t dx(x[ip]-par[2]);
339       Double_t dy(y[ip] - (par[0] + par[1]*dx));
340       if(iter && TMath::Abs(dy)>sCut*sy[ip]) continue;
341       f.AddPoint(&dx, y[ip], sy[ip]);
342       jp++;
343     }
344     if(jp<3) continue;
345     if(!f.Eval()) continue;
346     par[0]=f.GetFunctionParameter(0);
347     par[1]=f.GetFunctionParameter(1);
348     if(cov) f.GetCovarianceMatrix(cov);
349     AliDebugGeneral("AliTRDtrackletOflHelper::Fit()", 2, Form("Iter[%d] Ncl[%2d/%2d] par[%f %f %f]", iter, jp, n, par[0], par[1], par[2]));
350   }
351   return kTRUE;
352 }
353
354 //___________________________________________________________________
355 Bool_t AliTRDtrackletOflHelper::Fit(Double_t *par, Double_t sCut) const
356 {
357 // Wrapper for clusters attach to this for static Fit function  
358 //
359   Int_t n(fClusters->GetEntriesFast()), jc(0), dr(0);
360   Double_t corr = TMath::Tan(TMath::DegToRad()*fPadPlane->GetTiltingAngle())*
361                   fPadPlane->GetLengthIPad();
362   Double_t x[kNcls], y[kNcls], sy[kNcls];
363   AliTRDcluster *c(NULL);
364   for(Int_t ic(0); ic<n; ic++){
365     c = (AliTRDcluster*)fClusters->At(ic);
366     if(!c->IsInChamber()) continue;
367     dr = c->GetPadRow() - fRow;
368     x[jc] = c->GetX();
369     y[jc] = c->GetY()+corr*dr;
370     sy[jc]= c->GetSigmaY2()>0?(TMath::Min(TMath::Sqrt(c->GetSigmaY2()), 0.08)):0.08;
371     jc++;
372   }
373   return Fit(jc, x, y, sy, par, sCut);
374 }
375
376 //___________________________________________________________________
377 void AliTRDtrackletOflHelper::GetColSignals(Int_t col, Int_t adc[32], Bool_t mainRow) const
378 {
379   memset(adc, 0, 32*sizeof(Int_t));
380   if(col<fCol[0] || col>fCol[1]) return;
381   
382   AliTRDcluster *cc(NULL);
383   for(Int_t ic(fClusters->GetEntriesFast()); ic--;){
384     cc = (AliTRDcluster*)fClusters->At(ic);
385     if((mainRow && cc->GetPadRow()!=fRow) ||
386        (!mainRow && cc->GetPadRow()==fRow)) continue;
387     Short_t *sig = cc->GetSignals();
388     Int_t padcol(cc->GetPadCol());
389     Int_t time(cc->GetPadTime());
390     for(Int_t icol(0), jcol(padcol-3); icol<7; icol++, jcol++){
391       if(jcol!=col) continue;
392       adc[time]+=sig[icol];
393     }
394   }
395 }
396
397 //___________________________________________________________________
398 Int_t AliTRDtrackletOflHelper::GetRMS(Double_t &r, Double_t &m, Double_t &s, Double_t xm) const
399 {
400 // Calculate Rotation[r], Mean y[m] (at radial position [xm]) and Sigma[s] (of a gaussian distribution in the tracklet [SR])
401 // for clusters attach to this helper. The Rotation and Mean are calculated without tilt correction option.
402 // It returns the number of clusters in 1 sigma cut.
403   
404   Int_t n(fClusters->GetEntriesFast());
405   if(n<=2) return n;
406   Double_t par[3] = {0., 0., -1.};
407   if(xm>0.) par[2] = xm; // select reference radial position from outside 
408   Fit(par);
409   m = par[0];
410   r = par[1];
411   xm= par[2];
412
413   Double_t corr = TMath::Tan(TMath::DegToRad()*fPadPlane->GetTiltingAngle())*
414                   fPadPlane->GetLengthIPad();
415   Double_t y[kNcls];
416   AliTRDcluster *c(NULL);
417   for(Int_t ic(n); ic--;){
418     c = (AliTRDcluster*)fClusters->At(ic);
419     Double_t x(c->GetX() - xm);
420     Int_t dr(c->GetPadRow() - fRow);
421     y[ic] = c->GetY()+corr*dr - (par[0] + par[1]*x);
422   }
423   Double_t m1(0.);
424   AliMathBase::EvaluateUni(n, y, m1, s, 0);
425   Int_t n0(0);
426   for(Int_t ic(n); ic--;){
427     c = (AliTRDcluster*)fClusters->At(ic);
428     Double_t sy = c->GetSigmaY2()>0?(TMath::Min(TMath::Sqrt(c->GetSigmaY2()), 0.08)):0.08;
429     if(TMath::Abs(y[ic]-m1) <= sy) n0++;
430   }
431   return n0;
432 }
433
434 //___________________________________________________________________
435 Double_t AliTRDtrackletOflHelper::GetQ() const
436 {
437 // Calculate total charge NOT normalized to inclination
438
439   Double_t q(0.);
440   Int_t n(fClusters->GetEntriesFast());
441   AliTRDcluster *c(NULL);
442   for(Int_t ic(n); ic--;){
443     c = (AliTRDcluster*)fClusters->At(ic);
444     q += TMath::Abs(c->GetQ());
445   }
446   return q;
447 }
448
449 //___________________________________________________________________
450 Double_t AliTRDtrackletOflHelper::GetSyMean() const
451 {
452 // Calculate mean uncertainty of clusters
453
454   Double_t sym(0.);
455   Int_t n(fClusters->GetEntriesFast());
456   AliTRDcluster *c(NULL);
457   for(Int_t ic(n); ic--;){
458     c = (AliTRDcluster*)fClusters->At(ic);
459     sym += c->GetSigmaY2()>0?(TMath::Min(TMath::Sqrt(c->GetSigmaY2()), 0.08)):0.08;
460   }
461   return sym/=n;
462 }
463
464 //___________________________________________________________________
465 Int_t AliTRDtrackletOflHelper::Segmentation(Int_t n, Double_t *x, Double_t *y, Int_t *Index)
466 {
467 // Segmentation of clusters in the tracklet roads
468 //
469 // The user supply the coordinates of the clusters (x,y) and their number "n". Also
470 // The array "Index" has to be allocated by the user with a size equal or larger than "n".
471 // On return the function returns the number of segments found and the array "Index" i-th element 
472 // is filled with the index of the tracklet segment to which the i-th cluster was assigned too.
473 // 
474 // Observation
475 // The parameter which controls the segmentation is set inside the function "kGapSize" and it is used 
476 // for both "x" and "y" segmentations. An improvement can be a parametrization as function of angle of 
477 // incidence.
478 //
479 // author:
480 // Alex Bercuci <a.bercuci@gsi.de>
481
482   if(!n || !x || !y || !Index){
483     AliErrorGeneral("AliTRDtrackletOflHelper::Segmentation()", "One of the input arrays non initialized.");
484     return 0;
485   }
486   const Int_t kBuffer = 200;
487   if(n>kBuffer){
488     AliWarningGeneral("AliTRDtrackletOflHelper::Segmentation()", Form("Input array size %d exceed buffer %d. Truncate.", n, kBuffer));
489     n = kBuffer;
490   }
491   const Double_t kGapSize(0.2); // cm
492   Int_t ng(0),
493         nc(0);
494   Double_t xx[kBuffer], dy;
495   Int_t idx[kBuffer+1], jdx[kBuffer], kdx[kBuffer];
496   TMath::Sort(n, y, idx);
497   for(Int_t iy(0); iy<n; iy++){
498     dy = iy>0?(TMath::Abs(y[idx[iy-1]]-y[idx[iy]])):0.;
499     if(dy>kGapSize){
500       TMath::Sort(nc, xx, jdx);
501       for(Int_t ic(0), jc0, jc1; ic<nc; ic++){
502         jc0 = ic>0?kdx[jdx[ic-1]]:0;
503         jc1 = kdx[jdx[ic]];
504         dy = TMath::Abs(y[jc0] - y[jc1]);
505         if(ic && dy>kGapSize) ng++;
506         Index[jc1] = ng;
507         AliDebugGeneral("AliTRDtrackletOflHelper::Segmentation()", 4, Form("  y[%2d]=%+f x[%+f] %2d -> %2d -> %2d ng[%2d]", jc1, y[jc1], x[jc1], ic, jdx[ic], jc1, ng));
508       }
509       ng++;
510       nc=0;
511     }
512     xx[nc] = x[idx[iy]];
513     kdx[nc]= idx[iy];
514     AliDebugGeneral("AliTRDtrackletOflHelper::Segmentation()", 4, Form("y[%2d]=%+f -> %2d", idx[iy], y[idx[iy]], nc));
515     nc++;
516   }
517   if(nc){
518     TMath::Sort(nc, xx, jdx);
519     for(Int_t ic(0), jc0, jc1; ic<nc; ic++){
520       jc0 = ic>0?kdx[jdx[ic-1]]:0;
521       jc1 = kdx[jdx[ic]];
522       dy = TMath::Abs(y[jc0] - y[jc1]);
523       if(ic && dy>kGapSize) ng++;
524       Index[jc1] = ng;
525       AliDebugGeneral("AliTRDtrackletOflHelper::Segmentation()", 4, Form("  y[%2d]=%+f x[%+f|%+f] %2d -> %2d -> %2d ng[%2d]\n", jc1, y[jc1], xx[jdx[ic]], x[jc1], ic, jdx[ic], jc1, ng));
526     }
527     ng++;
528   }
529   return ng;
530 }
531
532 //___________________________________________________________________
533 void AliTRDtrackletOflHelper::SetTbRange(Float_t t0, Float_t vd)
534 {
535 // Set first time bin and total number of time bins corresponding to clusters 
536 // in chamber based on the calibrated info "t0" and drift velocity "vd"
537
538   // TO CHECK
539   fTBrange[0] = Int_t(t0*0.1);
540   fTBrange[1] = Int_t(vd*0.1);
541 }
542
543 #include "TH2.h"
544 #include "TGraph.h"
545 #include "TGraphErrors.h"
546 #include "TCanvas.h"
547 #include "TLegend.h"
548 #include "TGaxis.h"
549 //___________________________________________________________________
550 void AliTRDtrackletOflHelper::View(TVirtualPad *vpad)
551 {
552 // Visualization support. Draw this tracklet segment  
553
554
555   Int_t row(-1), det(-1);
556   Int_t n(fClusters->GetEntriesFast());
557   AliInfo(Form("Processing Clusters[%2d] Class[%d].", n ,ClassifyTopology()));
558   
559   // prepare drawing objects
560   Int_t ncols(fPadPlane->GetNcols());
561   Double_t cw(fPadPlane->GetColSize(1));
562   TH2 *h2 = new TH2I("h2pm", ";y_{Local} [cm]; pad time;Charge", ncols, fPadPlane->GetColPos(1)-cw, fPadPlane->GetColPos(ncols-1)+cw, 31, -30.5, 0.5);
563   h2->SetMarkerColor(kWhite);h2->SetMarkerSize(2.);
564   h2->SetFillColor(9);
565   
566   TGraph *gcls = new TGraph(n);
567   gcls->SetMarkerColor(kBlack);gcls->SetMarkerStyle(20);
568   TGraph *gclsLC = new TGraph(n);
569   gclsLC->SetMarkerColor(kBlack);gclsLC->SetMarkerStyle(28);
570   TGraph *gclsSC = new TGraph(n);
571   gclsSC->SetMarkerColor(kBlack);gclsSC->SetMarkerStyle(4);gclsSC->SetMarkerSize(1.5);
572   TGraph *gFP = new TGraph(n);
573   gFP->SetMarkerColor(kBlack);gFP->SetLineWidth(2);
574   
575   // fill signal data
576   Bool_t map[200]; memset(map, 0, 200*sizeof(Bool_t));
577   Int_t qa[200]; memset(qa, 0, 200*sizeof(Int_t));
578   AliTRDcluster *cc(NULL); Int_t tm = 30; Double_t ym=0.;
579   for(Int_t ic(n); ic--;){
580     cc = (AliTRDcluster*)fClusters->At(ic);
581     if(cc->GetPadRow() != fRow) continue; //TODO extend for 2 pad rows
582     Short_t *sig = cc->GetSignals();
583     Int_t col(cc->GetPadCol());
584     det = cc->GetDetector();
585     row = cc->GetPadRow();
586     Int_t time(cc->GetPadTime());
587     map[time] = kTRUE; qa[time] = (Int_t)cc->GetQ();
588     for(Int_t ipad(0), jpad(col-2); ipad<7; ipad++, jpad++){
589       Int_t q = (Int_t)h2->GetBinContent(jpad, 31-time);
590       h2->SetBinContent(jpad, 31-time, q+sig[ipad]);
591     }
592     Double_t y0 = fPadPlane->GetColPos(col) + (.5 + cc->GetCenter())*cw;
593     //h2->GetXaxis()->GetBinCenter(pad)+cc->GetCenter();
594     gcls->SetPoint(ic, y0, -time);
595     if(time <= tm) {ym = cc->GetY() - y0; tm = time;}
596   }
597
598   // draw special clusters (solid and Lorentz corrected and fit) 
599   FindSolidCls(map, qa);
600   Double_t ddy[200]; FitPSR(ddy, kTRUE);
601   Double_t dt, dy;
602   for(Int_t ic(0), jc(0); ic<n; ic++){
603     cc = (AliTRDcluster*)fClusters->At(ic);
604     if(cc->GetPadRow() != fRow) continue; //TODO extend for 2 pad rows
605     gcls->GetPoint(ic, dy, dt);
606     gclsLC->SetPoint(ic, cc->GetY()-ym, dt);
607     gFP->SetPoint(ic, dy-ddy[ic], dt);
608     if(map[cc->GetPadTime()]) gclsSC->SetPoint(jc++, dy, dt);
609   }
610   
611   
612   // prepare frame histo
613   h2->SetName(Form("h2s%03d%02d", det, row));
614   Int_t binSrt(fCol[0]+1), binSop(fCol[1]+1);
615   TH1 *h1(NULL);
616   
617   // show everything
618   if(!vpad){ 
619     vpad = new TCanvas(Form("c%03d%02d", det, row), Form("D %03d [%02d_%d_%d] R[%02d]", det, AliTRDgeometry::GetSector(det), AliTRDgeometry::GetStack(det), AliTRDgeometry::GetLayer(det), row), 700, 500);
620   }
621   TVirtualPad *pp(NULL);
622   vpad->Divide(2,1,2.e-5,2.e-5);
623   pp = vpad->cd(1); pp->SetRightMargin(0.0001);pp->SetTopMargin(0.1);pp->SetBorderMode(0); pp->SetFillColor(kWhite);
624   h1 = h2->ProjectionY(); h1->GetYaxis()->SetTitle("Total Charge");
625   h1->SetTitle(Form("D%03d[%02d_%d_%d] R[%02d]", 
626     det,AliTRDgeometry::GetSector(det), AliTRDgeometry::GetStack(det), AliTRDgeometry::GetLayer(det), row));
627   TAxis *ax(h1->GetXaxis()); for(Int_t ib(0), jb(1); ib<ax->GetNbins(); ib++, jb++) ax->SetBinLabel(jb, Form("%d", -Int_t(ax->GetBinCenter(jb))));
628   h1->Draw("hbar3");
629
630   pp = vpad->cd(2);
631   pp->SetRightMargin(0.15);pp->SetLeftMargin(0.0001);pp->SetTopMargin(0.1);
632   pp->SetBorderMode(0); pp->SetFillColor(kWhite);
633   ax=h2->GetXaxis();
634   ax->SetRange(TMath::Max(1, binSrt-1), TMath::Min(ncols, binSop+1));
635   h2->Draw("coltextz");
636   gPad->Update();
637   TGaxis *axis = new TGaxis(gPad->GetUxmin(),
638                     gPad->GetUymax(),
639                     gPad->GetUxmax(),
640                     gPad->GetUymax(),
641                     TMath::Max(0, binSrt-2)-0.5, TMath::Min(ncols-1, binSop)+0.5, 510,"-L");
642
643   axis->SetNdivisions(103+binSop-binSrt);
644   axis->SetTitle("pad col");
645   axis->Draw();
646
647   TLegend *leg = new TLegend(0.01, 0.1, 0.84, 0.21);
648   leg->SetBorderSize(1); leg->SetFillColor(kYellow-9);leg->SetTextSize(0.04);
649   gcls->Draw("p");  leg->AddEntry(gcls, "Cls. in Pad [SR]", "p");
650   gclsLC->Draw("p"); leg->AddEntry(gclsLC, "Lorentz Corr. Cls.", "p");
651   gclsSC->Draw("p"); leg->AddEntry(gclsSC, "Solid Cls.", "p");
652   gFP->Draw("l"); leg->AddEntry(gFP, "Fit in Pad [SR]", "l");
653   leg->Draw();
654 }
655
656 //___________________________________________________________________
657 AliTRDtrackerV1::AliTRDLeastSquare& AliTRDtrackletOflHelper::Fitter()
658 {
659   static AliTRDtrackerV1::AliTRDLeastSquare f;
660   return f;
661 }