Compilation with Root6: TH1::GetXaxis returns now const TAxis*
[u/mrichter/AliRoot.git] / PWGPP / TRD / AliTRDcalibration.cxx
1
2 /**************************************************************************
3 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 *                                                                        *
5 * Author: The ALICE Off-line Project.                                    *
6 * Contributors are mentioned in the code where appropriate.              *
7 *                                                                        *
8 * Permission to use, copy, modify and distribute this software and its   *
9 * documentation strictly for non-commercial purposes is hereby granted   *
10 * without fee, provided that the above copyright notice appears in all   *
11 * copies and that both the copyright notice and this permission notice   *
12 * appear in the supporting documentation. The authors make no claims     *
13 * about the suitability of this software for any purpose. It is          *
14 * provided "as is" without express or implied warranty.                  *
15 **************************************************************************/
16
17 /////////////////////////////////////////////////////////////////////////////////
18 //                                                                             
19 // AliTRDcalibration                                                            
20 //                                                                             
21 // Task to run the calibration offline.
22 // Author:
23 //   R. Bailhache (rbailhache@ikf.uni-frankfurt.de, R.Bailhache@gsi.de)
24 //           
25 //////////////////////////////////////////////////////////////////////////////////
26
27
28 #include "Riostream.h"
29 #include "TChain.h"
30 #include "TTree.h"
31 #include "TProfile2D.h"
32 #include "TH2I.h"
33 #include "TH1F.h"
34 #include "TList.h"
35 #include "TMath.h"
36 #include "TCanvas.h"
37 #include "TObject.h"
38 #include "TFile.h"
39 #include "TObjArray.h"
40 #include "TGraph.h"
41 #include "TStyle.h"
42 #include "TLegend.h"
43 #include "TGraphErrors.h"
44
45 #include "AliTRDrecoTask.h"
46 #include "AliAnalysisManager.h"
47
48 #include "AliESDInputHandler.h"
49 #include "AliTRDtrackV1.h"
50 #include "AliTRDseedV1.h"
51 #include "AliTRDcluster.h"
52 #include "info/AliTRDtrackInfo.h"
53 #include "AliTRDcalibDB.h"
54
55 #include "AliTRDCalibraFillHisto.h"
56 #include "AliTRDCalibraFit.h"
57 #include "AliTRDCalibraVdriftLinearFit.h"
58 #include "AliTRDCalibraMode.h"
59 #include "AliTRDCalibraVector.h"
60 #include "./Cal/AliTRDCalPad.h"
61 #include "./Cal/AliTRDCalDet.h"
62
63 #include "AliLog.h"
64
65 #include "AliTRDcalibration.h"
66
67
68 ClassImp(AliTRDcalibration)
69
70 //________________________________________________________________________
71 AliTRDcalibration::AliTRDcalibration() 
72   :AliTRDrecoTask()
73   ,fTrackInfo(0)
74   ,ftrdTrack(0)
75   ,fcl(0)
76   ,fTRDCalibraFillHisto(0)
77   ,fNbTRDTrack(0)
78   ,fNbTRDTrackOffline(0)
79   ,fNbTRDTrackStandalone(0)
80   ,fNbTRDTracklet(0)
81   ,fNbTRDTrackletOffline(0)
82   ,fNbTRDTrackletStandalone(0)
83   ,fNbTimeBin(0x0)
84   ,fNbTimeBinOffline(0x0)
85   ,fNbTimeBinStandalone(0x0)
86   ,fNbClusters(0)
87   ,fNbClustersOffline(0)
88   ,fNbClustersStandalone(0)
89   ,fPHSM(0)
90   ,fCHSM(0)
91   ,fPHSum(0)
92   ,fCHSum(0)
93   ,fDetSum(0)
94   ,fDetSumVector(0)
95   ,fHisto2d(kTRUE)
96   ,fVector2d(kFALSE)
97   ,fVdriftLinear(kTRUE)
98   ,flow(0)
99   ,fhigh(30)
100   ,fNbTimeBins(0)
101   ,ffillZero(kFALSE)
102   ,fnormalizeNbOfCluster(kFALSE)
103   ,fmaxCluster(0)
104   ,fOfflineTracks(kFALSE)
105   ,fStandaloneTracks(kFALSE)
106   ,fCompressPerDetector(kFALSE)
107   ,fGraph(0x0)
108   ,fArrayCalib(0x0)
109   ,fPostProcess(kFALSE)
110 {
111   // Constructor
112   
113   fNRefFigures = 17;
114
115   for(Int_t k = 0; k < 3; k++)
116     {
117       fNz[k]=0;
118       fNrphi[k]=0;
119     }
120
121 }  
122
123 AliTRDcalibration::AliTRDcalibration(char* name) 
124   :AliTRDrecoTask(name, "Calibration on tracks")
125   ,fTrackInfo(0)
126   ,ftrdTrack(0)
127   ,fcl(0)
128   ,fTRDCalibraFillHisto(0)
129   ,fNbTRDTrack(0)
130   ,fNbTRDTrackOffline(0)
131   ,fNbTRDTrackStandalone(0)
132   ,fNbTRDTracklet(0)
133   ,fNbTRDTrackletOffline(0)
134   ,fNbTRDTrackletStandalone(0)
135   ,fNbTimeBin(0x0)
136   ,fNbTimeBinOffline(0x0)
137   ,fNbTimeBinStandalone(0x0)
138   ,fNbClusters(0)
139   ,fNbClustersOffline(0)
140   ,fNbClustersStandalone(0)
141   ,fPHSM(0)
142   ,fCHSM(0)
143   ,fPHSum(0)
144   ,fCHSum(0)
145   ,fDetSum(0)
146   ,fDetSumVector(0)
147   ,fHisto2d(kTRUE)
148   ,fVector2d(kFALSE)
149   ,fVdriftLinear(kTRUE)
150   ,flow(0)
151   ,fhigh(30)
152   ,fNbTimeBins(0)
153   ,ffillZero(kFALSE)
154   ,fnormalizeNbOfCluster(kFALSE)
155   ,fmaxCluster(0)
156   ,fOfflineTracks(kFALSE)
157   ,fStandaloneTracks(kFALSE)
158   ,fCompressPerDetector(kFALSE)
159   ,fGraph(0x0)
160   ,fArrayCalib(0x0)
161   ,fPostProcess(kFALSE)
162 {
163   // Constructor
164   
165   fNRefFigures = 17;
166
167   for(Int_t k = 0; k < 3; k++)
168     {
169       fNz[k]=0;
170       fNrphi[k]=0;
171     }
172
173 }  
174
175 //________________________________________________________________________
176 AliTRDcalibration::~AliTRDcalibration() 
177 {
178   // Default destructor
179   if (AliAnalysisManager::GetAnalysisManager()->IsProofMode()) return;
180   //
181   if(fNbTRDTrack) delete fNbTRDTrack;
182   if(fNbTRDTrackOffline) delete fNbTRDTrackOffline;
183   if(fNbTRDTrackStandalone) delete fNbTRDTrackStandalone;
184   if(fNbTRDTracklet) delete fNbTRDTracklet;
185   if(fNbTRDTrackletOffline) delete fNbTRDTrackletOffline;
186   if(fNbTRDTrackletStandalone) delete fNbTRDTrackletStandalone;
187   if(fNbTimeBin) delete fNbTimeBin;
188   if(fNbTimeBinOffline) delete fNbTimeBinOffline;
189   if(fNbTimeBinStandalone) delete fNbTimeBinStandalone;
190   if(fNbClusters) delete fNbClusters;
191   if(fNbClustersOffline) delete fNbClustersOffline;
192   if(fNbClustersStandalone) delete fNbClustersStandalone;
193   if(fPHSM) delete fPHSM;
194   if(fCHSM) delete fCHSM;
195   if(fPHSum) delete fPHSum;
196   if(fCHSum) delete fCHSum;
197   if(fDetSum) delete fDetSum;
198   if(fDetSumVector) delete fDetSumVector;
199   if(fGraph){fGraph->Delete(); delete fGraph;}
200   if(fArrayCalib){fArrayCalib->Delete(); delete fArrayCalib;}
201    
202 }
203 //________________________________________________________________________
204 void AliTRDcalibration::UserCreateOutputObjects() 
205 {
206   // Create output objects
207
208   // Number of time bins
209   if(fNbTimeBins==0) {
210     AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
211     fNbTimeBins = cal->GetNumberOfTimeBinsDCS();
212     if(fNbTimeBins <= 0){ 
213       AliWarning(Form("No of TimeBins from DB [%d] use default [30]", fNbTimeBins));
214       fNbTimeBins = 30;
215     }
216   }
217   
218   // instance calibration: what to calibrate
219   fTRDCalibraFillHisto = AliTRDCalibraFillHisto::Instance();
220   fTRDCalibraFillHisto->SetHisto2d(fHisto2d); // choose to use histograms
221   fTRDCalibraFillHisto->SetVector2d(fVector2d); // choose to use vectors
222   fTRDCalibraFillHisto->SetCH2dOn();  // choose to calibrate the gain
223   fTRDCalibraFillHisto->SetPH2dOn();  // choose to calibrate the drift velocity
224   fTRDCalibraFillHisto->SetPRF2dOn(); // choose to look at the PRF
225   fTRDCalibraFillHisto->SetLinearFitterOn(fVdriftLinear); // Other possibility vdrift VDRIFT
226   fTRDCalibraFillHisto->SetLinearFitterDebugOn(fVdriftLinear); // Other possibility vdrift
227
228   // segmentation (should be per default the max and add at the end)
229   for(Int_t k = 0; k < 3; k++){
230     if(((fNz[k] != 10) && (fNrphi[k] != 10)) && ((fNz[k] != 100) && (fNrphi[k] != 100))) {
231       fTRDCalibraFillHisto->SetNz(k,fNz[k]);                                    // Mode calibration
232       fTRDCalibraFillHisto->SetNrphi(k,fNrphi[k]);                             // Mode calibration
233     }
234     else {
235       if((fNz[k] == 100) && (fNrphi[k] == 100))  {
236         if(fVector2d) AliInfo("The mode all together is not supported by the vector method");
237         fTRDCalibraFillHisto->SetAllTogether(k);
238       }
239       if((fNz[k] == 10) && (fNrphi[k] == 10))  {
240         if(fVector2d) AliInfo("The mode per supermodule is not supported by the vector method");
241         fTRDCalibraFillHisto->SetPerSuperModule(k);
242       }
243     }
244   }
245
246   // Debug level
247   fTRDCalibraFillHisto->SetDebugLevel(DebugLevel()); //debug stuff
248
249   // Init the stuff
250   fTRDCalibraFillHisto->Init2Dhistos(fNbTimeBins); // initialise the histos
251
252   // cuts
253   fTRDCalibraFillHisto->SetNumberClusters(flow); // At least flow clusters
254   fTRDCalibraFillHisto->SetNumberClustersf(fhigh); // The more fhigh clusters
255   fTRDCalibraFillHisto->SetFillWithZero(ffillZero); // Fill zeros
256   fTRDCalibraFillHisto->SetNormalizeNbOfCluster(fnormalizeNbOfCluster); // For iterations
257
258   // Add them to the container
259   fContainer = new TObjArray();
260   if(fHisto2d) {
261     fContainer->Add(fTRDCalibraFillHisto->GetCH2d()); //TH2I
262     fContainer->Add(fTRDCalibraFillHisto->GetPH2d()); //TProfile2D
263     fContainer->Add(fTRDCalibraFillHisto->GetPRF2d()); //TProfile2D
264   }
265   if(fVdriftLinear) fContainer->Add(fTRDCalibraFillHisto->GetVdriftLinearFit()); // Other drift velocity 
266   if(fVector2d) fContainer->Add(fTRDCalibraFillHisto->GetCalibraVector()); //calibra vector
267       
268   if(DebugLevel()) {
269     
270     // Init the debug histos
271     fNbTRDTrack = new TH1F("TRDTrack","TRDTrack",500,0,500);
272     fNbTRDTrack->Sumw2();
273     fNbTRDTrackOffline = new TH1F("TRDTrackOffline","TRDTrackOffline",500,0,500);
274     fNbTRDTrackOffline->Sumw2();
275     fNbTRDTrackStandalone = new TH1F("TRDTrackStandalone","TRDTrackStandalone",500,0,500);
276     fNbTRDTrackStandalone->Sumw2();
277     //
278     fNbTRDTracklet = new TH1F("TRDTracklet","TRDTracklet",540,0.,540.);
279     fNbTRDTracklet->Sumw2();
280     fNbTRDTrackletOffline = new TH1F("TRDTrackletOffline","TRDTrackletOffline",540,0.,540.);
281     fNbTRDTrackletOffline->Sumw2();
282     fNbTRDTrackletStandalone = new TH1F("TRDTrackletStandalone","TRDTrackletStandalone",540,0.,540.);
283     fNbTRDTrackletStandalone->Sumw2();
284     //
285     fNbTimeBin = new TH1F("TimeBin","TimeBin",35,0,35);
286     fNbTimeBin->Sumw2();
287     fNbTimeBinOffline = new TH1F("TimeBinOffline","TimeBinOffline",35,0,35);
288     fNbTimeBinOffline->Sumw2();
289     fNbTimeBinStandalone = new TH1F("TimeBinStandalone","TimeBinStandalone",35,0,35);
290     fNbTimeBinStandalone->Sumw2();
291     //
292     fNbClusters = new TH1F("NbClusters","",35,0,35);
293     fNbClusters->Sumw2();
294     fNbClustersOffline = new TH1F("NbClustersOffline","",35,0,35);
295     fNbClustersOffline->Sumw2();
296     fNbClustersStandalone = new TH1F("NbClustersStandalone","",35,0,35);
297     fNbClustersStandalone->Sumw2();
298     //
299     fPHSM = new TProfile2D("PH2dSM","Nz10Nrphi10"
300                             ,fNbTimeBins,-0.05,(Double_t)((fNbTimeBins-0.5)/10.0)
301                             ,18,0,18);
302     fPHSM->SetYTitle("Det/pad groups");
303     fPHSM->SetXTitle("time [#mus]");
304     fPHSM->SetZTitle("<PH> [a.u.]");
305     fPHSM->SetStats(0);
306     //
307     fCHSM = new TH2I("CH2dSM","Nz10Nrphi10",50,0,300,18,0,18);
308     fCHSM->SetYTitle("Det/pad groups");
309     fCHSM->SetXTitle("charge deposit [a.u]");
310     fCHSM->SetZTitle("counts");
311     fCHSM->SetStats(0);
312     fCHSM->Sumw2();
313     //
314     fPHSum = new TProfile2D("PH2dSum","Nz100Nrphi100"
315                             ,fNbTimeBins,-0.05,(Double_t)((fNbTimeBins-0.5)/10.0)
316                             ,1,0,1);
317     fPHSum->SetYTitle("Det/pad groups");
318     fPHSum->SetXTitle("time [#mus]");
319     fPHSum->SetZTitle("<PH> [a.u.]");
320     fPHSum->SetStats(0);
321     //
322     fCHSum = new TH2I("CH2dSum","Nz100Nrphi100",50,0,300,1,0,1);
323     fCHSum->SetYTitle("Det/pad groups");
324     fCHSum->SetXTitle("charge deposit [a.u]");
325     fCHSum->SetZTitle("counts");
326     fCHSum->SetStats(0);
327     fCHSum->Sumw2();
328     
329     // Add them
330     fContainer->Add(fNbTRDTrack);
331     fContainer->Add(fNbTRDTrackOffline);
332     fContainer->Add(fNbTRDTrackStandalone);
333     fContainer->Add(fNbTRDTracklet);
334     fContainer->Add(fNbTRDTrackletOffline);
335     fContainer->Add(fNbTRDTrackletStandalone);
336     fContainer->Add(fNbTimeBin);
337     fContainer->Add(fNbTimeBinOffline);
338     fContainer->Add(fNbTimeBinStandalone);
339     fContainer->Add(fNbClusters);
340     fContainer->Add(fNbClustersOffline);
341     fContainer->Add(fNbClustersStandalone);
342     fContainer->Add(fPHSM);
343     fContainer->Add(fCHSM);
344     fContainer->Add(fPHSum);
345     fContainer->Add(fCHSum);
346
347   }
348   // Post output data
349   PostData(1, fContainer);
350 }
351
352 //________________________________________________________________________
353 void AliTRDcalibration::UserExec(Option_t *) 
354 {
355   //
356   // Execute function where the reference data are filled
357   //
358
359   if(!fTracks) return;
360   
361   // In total
362   Int_t nbTrdTracks = 0;
363   // standalone
364   Int_t nbTrdTracksStandalone = 0;
365   // offline
366   Int_t nbTrdTracksOffline = 0;
367   
368
369   //
370   // Loop on track in the event
371   //
372   //printf("Total of %d\n",fTracks->GetEntriesFast());
373   for(Int_t itrk=0; itrk < fTracks->GetEntriesFast(); itrk++){
374     
375     //printf("itrk %d\n",itrk);
376
377     fTrackInfo = (AliTRDtrackInfo*)fTracks->UncheckedAt(itrk);
378     ftrdTrack = fTrackInfo->GetTrack();
379     if(!ftrdTrack) continue;
380
381     nbTrdTracks++;
382   
383     fTRDCalibraFillHisto->UpdateHistogramsV1(ftrdTrack);
384
385     if(DebugLevel()) {
386       
387       Bool_t standalonetracklet = kFALSE;  
388       const AliTRDseedV1 *tracklet = 0x0;
389       //
390       // Loop on tracklet in the event
391       //
392       for(Int_t itr = 0; itr < 6; itr++){
393         //printf("itr %d\n",itr);
394         if(!(tracklet = ftrdTrack->GetTracklet(itr))) continue;
395         if(!tracklet->IsOK()) continue;
396         // standalone
397         if(tracklet->IsStandAlone()) standalonetracklet = kTRUE;
398         Int_t nbclusters = 0;
399         // For PH
400         Double_t phtb[AliTRDseedV1::kNtb];
401         memset(phtb, 0, AliTRDseedV1::kNtb*sizeof(Double_t));
402         // For CH
403         Double_t sum = 0.0;
404         // normalisation
405         Float_t normalisation = 6.67;
406         Int_t detector = 0;
407         Int_t sector = 0;
408   /*Int_t crossrow = 0;
409   // Check no shared clusters
410   for(int icc=AliTRDseedV1::kNtb; icc<AliTRDseedV1::kNclusters; icc++){
411     if((fcl = tracklet->GetClusters(icc)))  crossrow = 1;
412   }*/
413         // Loop on clusters
414         for(int ic=0; ic<AliTRDseedV1::kNtb; ic++){
415           if(!(fcl = tracklet->GetClusters(ic))) continue;
416           nbclusters++;
417           Int_t time = fcl->GetPadTime();
418           Float_t ch =  tracklet->GetdQdl(ic);
419           Float_t qcl = TMath::Abs(fcl->GetQ());
420           detector = fcl->GetDetector();          
421           if((time>-1) && (time<fNbTimeBins)) phtb[time]=qcl;
422           sum += ch/normalisation;
423           fNbTimeBin->Fill(time);
424           if(tracklet->IsStandAlone()) fNbTimeBinStandalone->Fill(time);
425           else fNbTimeBinOffline->Fill(time);
426         }
427         sector = AliTRDgeometry::GetSector(detector);
428
429         fNbTRDTracklet->Fill(detector);
430         if(tracklet->IsStandAlone()) fNbTRDTrackletStandalone->Fill(detector);
431         else fNbTRDTrackletOffline->Fill(detector);
432         
433         fNbClusters->Fill(nbclusters);
434         if(tracklet->IsStandAlone())  fNbClustersStandalone->Fill(nbclusters);
435         else  fNbClustersOffline->Fill(nbclusters);
436         
437         if((nbclusters > flow) && (nbclusters < fhigh)){
438           fCHSM->Fill(sum/20.0,sector+0.5);
439           fCHSum->Fill(sum/20.0,0.5);
440           for(int ic=0; ic<fNbTimeBins; ic++){
441             if(ffillZero) {
442               fPHSum->Fill((Double_t)(ic/10.0),0.5,(Double_t)phtb[ic]);
443               fPHSM->Fill((Double_t)(ic/10.0),sector+0.5,(Double_t)phtb[ic]);
444             }
445             else {
446               if(phtb[ic] > 0.0) {
447                 fPHSum->Fill((Double_t)(ic/10.0),0.0,(Double_t)phtb[ic]);
448                 fPHSM->Fill((Double_t)(ic/10.0),sector+0.5,(Double_t)phtb[ic]);
449               }
450             }
451           }
452         }
453       }
454     
455     if(standalonetracklet) nbTrdTracksStandalone++;
456     else nbTrdTracksOffline++;
457     
458     }
459     
460   }
461   
462   if(DebugLevel()) {
463     
464     //Fill Histos
465     fNbTRDTrack->Fill(nbTrdTracks);
466     fNbTRDTrackStandalone->Fill(nbTrdTracksStandalone);
467     fNbTRDTrackOffline->Fill(nbTrdTracksOffline);
468     
469   }
470 }  
471     
472 //________________________________________________________________________
473 void AliTRDcalibration::Terminate(Option_t *) 
474 {
475   // Draw result to the screen
476   // Called once at the end of the query
477
478   //printf("terminate\n");
479
480   if(fTRDCalibraFillHisto) fTRDCalibraFillHisto->DestroyDebugStreamer();
481  
482 }
483 //________________________________________________________
484 Bool_t AliTRDcalibration::GetRefFigure(Int_t ifig)
485 {
486   //
487   // Draw filled histos
488   //
489   
490   gStyle->SetPalette(1);
491   gStyle->SetOptStat(1111);
492   gStyle->SetPadBorderMode(0);
493   gStyle->SetCanvasColor(10);
494   gStyle->SetPadLeftMargin(0.13);
495   gStyle->SetPadRightMargin(0.13);
496
497   if(!fContainer) return kFALSE;
498   
499   switch(ifig){
500   case kNbTrack:{
501     TCanvas *c0 = new TCanvas("c0","c0",10,10,510,510);
502     TLegend *legNbTrack = new TLegend(.7, .7, .98, .98);
503     legNbTrack->SetBorderSize(1);
504     TH1F *h  = 0x0;
505     TH1F *ho = 0x0;
506     TH1F *hs = 0x0;
507     if(!(h = (TH1F *)fContainer->FindObject("TRDTrack"))) break;
508     if(!(ho = (TH1F *)fContainer->FindObject("TRDTrackOffline"))) break;
509     if(!(hs = (TH1F *)fContainer->FindObject("TRDTrackStandalone"))) break;
510     c0->cd();
511     //gPad->SetLogy();
512     gPad->SetGridy();
513     gPad->SetGridx();
514     h->Draw();
515     ho->Draw("same");
516     hs->Draw("same");
517     legNbTrack->AddEntry(h, "all", "p");
518     legNbTrack->AddEntry(ho, "offline", "p");
519     legNbTrack->AddEntry(hs, "standalone", "p");
520     legNbTrack->Draw("same");
521     return kTRUE;
522   }
523   case kNbTracklet:{
524     TLegend *legNbTracklet = new TLegend(.7, .7, .98, .98);
525     legNbTracklet->SetBorderSize(1);
526     TH1F *h = 0x0;
527     TH1F *ho = 0x0;
528     TH1F *hs = 0x0;
529     if(!(h = (TH1F *)fContainer->FindObject("TRDTracklet"))) break;
530     if(!(ho = (TH1F *)fContainer->FindObject("TRDTrackletOffline"))) break;
531     if(!(hs = (TH1F *)fContainer->FindObject("TRDTrackletStandalone"))) break;
532     h->Draw();
533     ho->Draw("same");
534     hs->Draw("same");
535     legNbTracklet->AddEntry(h, "all", "p");
536     legNbTracklet->AddEntry(ho, "offline", "p");
537     legNbTracklet->AddEntry(hs, "standalone", "p");
538     legNbTracklet->Draw("same");
539     gPad->SetLogy();
540     gPad->SetGridy();
541     gPad->SetGridx();
542     return kTRUE;
543   }
544   case kNbTimeBin:{
545     TLegend *legNbTimeBin = new TLegend(.7, .7, .98, .98);
546     legNbTimeBin->SetBorderSize(1);
547     TH1F *h = 0x0;
548     TH1F *ho = 0x0;
549     TH1F *hs = 0x0;
550     if(!(h = (TH1F *)fContainer->FindObject("TimeBin"))) break;
551     if(!(ho = (TH1F *)fContainer->FindObject("TimeBinOffline"))) break;
552     if(!(hs = (TH1F *)fContainer->FindObject("TimeBinStandalone"))) break;
553     h->Draw();
554     ho->Draw("same");
555     hs->Draw("same");
556     legNbTimeBin->AddEntry(h, "all", "p");
557     legNbTimeBin->AddEntry(ho, "offline", "p");
558     legNbTimeBin->AddEntry(hs, "standalone", "p");
559     legNbTimeBin->Draw("same");
560     //gPad->SetLogy();
561     gPad->SetGridy();
562     gPad->SetGridx();
563     return kTRUE;
564   }
565   case kNbClusters:{
566     TLegend *legNbClusters = new TLegend(.7, .7, .98, .98);
567     legNbClusters->SetBorderSize(1);
568     TH1F *h = 0x0;
569     TH1F *ho = 0x0;
570     TH1F *hs = 0x0;
571     if(!(h = (TH1F *)fContainer->FindObject("NbClusters"))) break;
572     if(!(ho = (TH1F *)fContainer->FindObject("NbClustersOffline"))) break;
573     if(!(hs = (TH1F *)fContainer->FindObject("NbClustersStandalone"))) break;
574     h->Draw();
575     ho->Draw("same");
576     hs->Draw("same");
577     legNbClusters->AddEntry(h, "all", "p");
578     legNbClusters->AddEntry(ho, "offline", "p");
579     legNbClusters->AddEntry(hs, "standalone", "p");
580     legNbClusters->Draw("same");
581     gPad->SetLogy();
582     gPad->SetGridy();
583     gPad->SetGridx();
584     return kTRUE;
585   }
586   case kPHSum:{
587     TProfile2D *h = 0x0;
588     if(!(h = (TProfile2D *)fContainer->FindObject("PH2dSum"))) break;
589     TH1D *projh = h->ProjectionX("projh",1,1,"e");
590     projh->Draw();
591     gPad->SetGridy();
592     gPad->SetGridx();
593     return kTRUE;
594   }
595   case kCHSum:{
596     TH2I *h = 0x0;
597     if(!(h = (TH2I *)fContainer->FindObject("CH2dSum"))) break;
598     TH1D *projh = h->ProjectionX("projhh",1,1,"e");
599     projh->Draw();
600     gPad->SetGridy();
601     gPad->SetGridx();
602     return kTRUE;
603   }
604   case kPH2D:{
605     if(!fHisto2d) {
606       AliInfo("Histo was not filled!");
607       break;
608     }
609     TProfile2D *h = 0x0;
610     if(!(h = (TProfile2D *)fContainer->FindObject("PH2d"))) break;
611     h->Draw("lego");
612     return kTRUE;
613   }
614   case kCH2D:{
615     if(!fHisto2d) {
616       AliInfo("Histo was not filled!");
617       break;
618     }
619     TH2I *h = 0x0;
620     if(!(h = (TH2I *)fContainer->FindObject("CH2d"))) break;
621     h->Draw("lego");
622     return kTRUE;
623   }
624   case kPRF2D:{
625     if(!fHisto2d) {
626       AliInfo("Histo was not filled!");
627       break;
628     }
629     TProfile2D *h = 0x0;
630     if(!(h = (TProfile2D *)fContainer->FindObject("PRF2d"))) break;
631     h->Draw("lego");
632     return kTRUE;
633   }
634   case kPH2DVector:{
635     if(!fVector2d) {
636       AliInfo("vector was not filled!");
637       break;
638     }
639     AliTRDCalibraVector *v = 0x0;
640     TGraphErrors *vdet = 0x0; 
641     if(!(v = (AliTRDCalibraVector *)fContainer->FindObject("AliTRDCalibraVector"))) break;
642     Int_t detectormax = -1;
643     Int_t groupmax    = -1;
644     if(!v->FindTheMaxEntries(1,detectormax,groupmax)) break;
645     if(!(vdet = v->ConvertVectorPHTGraphErrors((Int_t)detectormax,groupmax,"plotPH2dVector"))) break;
646     Int_t nbeentries = 0;
647     TH1F *ko = v->CorrectTheError(vdet,nbeentries);
648     ko->Draw();
649     AliInfo(Form("There are %d entries in the detector %d and group %d",nbeentries,detectormax,groupmax));
650     return kTRUE;
651   }
652 case kCH2DVector:{
653     if(!fVector2d) {
654       AliInfo("vector was not filled!");
655       break;
656     }
657     AliTRDCalibraVector *v = 0x0;
658     TH1F *vdet = 0x0; 
659     if(!(v = (AliTRDCalibraVector *)fContainer->FindObject("AliTRDCalibraVector"))) break;
660     Int_t detectormax = -1;
661     Int_t groupmax    = -1;
662     if(!v->FindTheMaxEntries(0,detectormax,groupmax)) break;
663     if(!(vdet = v->ConvertVectorCHHisto((Int_t)detectormax,groupmax,"plotCH2dVector"))) break;
664     vdet->Draw();
665     AliInfo(Form("The detectormax and groupmax are %d and %d",detectormax,groupmax));
666     return kTRUE;
667   }
668   case kPRF2DVector:{
669     if(!fVector2d) {
670       AliInfo("vector was not filled!");
671       break;
672     }
673     AliTRDCalibraVector *v = 0x0;
674     TGraphErrors *vdet = 0x0; 
675     if(!(v = (AliTRDCalibraVector *)fContainer->FindObject("AliTRDCalibraVector"))) break;
676     Int_t detectormax  = -1;
677     Int_t groupmax     = -1;
678     Int_t nbeentries   = 0;
679     if(!v->FindTheMaxEntries(2,detectormax,groupmax)) break;
680     if(!(vdet = v->ConvertVectorPRFTGraphErrors((Int_t)detectormax,groupmax,"plotPRF2dVector"))) break;
681     TH1F *ko = v->CorrectTheError(vdet,nbeentries);
682     ko->Draw();
683     AliInfo(Form("The detectormax and groupmax are %d and %d",detectormax,groupmax));
684     return kTRUE;
685   }
686   case kLinearFitter:{
687     if(!fVdriftLinear) {
688       AliInfo("vdrift linear was not filled!");
689       break;
690     }
691     AliTRDCalibraVdriftLinearFit *h = 0x0;
692     TH2S *hdetector = 0x0; 
693     if(!(h = (AliTRDCalibraVdriftLinearFit *)fContainer->FindObject("AliTRDCalibraVdriftLinearFit"))) break;
694     Double_t entries[540];
695     for(Int_t k = 0; k < 540; k++){
696       entries[k] = 0.0;
697       hdetector = 0x0;
698       if(!(hdetector = (TH2S *)h->GetLinearFitterHisto(k,kFALSE))) continue;
699       entries[k] = hdetector->GetEntries();
700     }
701     Double_t max = -10.0;
702     Double_t detectormax = -1;
703     for(Int_t k = 0; k < 540; k++){
704       if(entries[k] > max) {
705         max = entries[k];
706         detectormax = k;
707       }
708     }
709     hdetector = 0x0;
710     if((TMath::Abs(max) <= 0.001) || (detectormax <0.0) || (detectormax >=540.0)) break;
711     if(!(hdetector = (TH2S *)h->GetLinearFitterHisto((Int_t)detectormax,kFALSE))) break;
712     AliInfo(Form("The detector with the maximum of entries is %f",detectormax));
713     hdetector->Draw();
714     return kTRUE;
715   }
716   case kGainFactor:{
717     if(!fPostProcess){
718       if(!PostProcess()) break;
719     }
720     TGraph *fgain = (TGraph *) fGraph->At(0);
721     if(!fgain) break;
722     fgain->Draw("ALP");
723     return kTRUE;
724   }
725   case kVdriftT0Factor:{
726     if(!fPostProcess){
727       if(!PostProcess()) break;
728     }
729     TCanvas *c = new TCanvas("c","c",10,10,510,510);
730     c->Divide(2,1);
731     TGraph *fvd = (TGraph *) fGraph->At(1);
732     if(fvd){
733       c->cd(1);
734       fvd->Draw("ALP");
735     } 
736     TGraph *ft0 = (TGraph *) fGraph->At(2);
737     if(ft0){
738       c->cd(2);
739       ft0->Draw("ALP");
740     } 
741     return kTRUE;
742   }
743   case kVdriftLorentzAngleFactor:{
744     if(!fVdriftLinear) {
745       AliInfo("vdrift linear was not filled!");
746       break;
747     }
748     if(!fPostProcess){
749       if(!PostProcess()) break;
750     }
751     TCanvas *c = new TCanvas("c","c",10,10,510,510);
752     c->Divide(2,1);
753     TGraph *fvdl = (TGraph *) fGraph->At(3);
754     if(fvdl){
755       c->cd(1);
756       fvdl->Draw("ALP");
757     } 
758     TGraph *flal = (TGraph *) fGraph->At(4);
759     if(flal){
760       c->cd(2);
761       flal->Draw("ALP");
762     } 
763     return kTRUE;
764   }
765   case kPRFFactor:{
766     if(!fPostProcess){
767       if(!PostProcess()) break;
768     }
769     TGraph *fprf = (TGraph *) fGraph->At(5);
770     if(!fprf) break;
771     fprf->Draw("ALP");
772     return kTRUE;
773   }
774   }
775   
776   return kFALSE;
777   
778 }
779 //________________________________________________________________________
780 Bool_t AliTRDcalibration::PostProcess()
781 {
782   // 
783   // Fit the filled histos
784   // Put the calibration object in fArrayCalib
785   // 0 and 1 AliTRDCalDet and AliTRDCalPad gain
786   // 2 and 3 AliTRDCalDet and AliTRDCalPad vdrift PH
787   // 4 and 5 AliTRDCalDet and AliTRDCalPad timeoffset PH
788   // 6 AliTRDCalPad PRF
789   // 7 and 8 AliTRDCalDet and AliTRDCalPad vdrift second
790   // 9 and 10 AliTRDCalDet and AliTRDCalPad lorentz angle second
791   //
792
793   if(!fArrayCalib){
794     fArrayCalib = new TObjArray(11);
795     fArrayCalib->SetOwner();
796   }
797   else {
798     delete fArrayCalib;
799     PostProcess();
800   }
801   
802   if(!fGraph){
803     fGraph = new TObjArray(6);
804     fGraph->SetOwner();
805   }
806   else {
807     delete fGraph;
808     PostProcess();
809   }
810
811 //  Bool_t storage[3] = {kFALSE,kFALSE,kFALSE};
812
813   // Objects for fitting
814   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
815   calibra->SetDebugLevel(2); // 0 rien, 1 fitvoir, 2 debug files, 3 one detector  
816   
817   // Take the stuff
818   if (!fContainer) {
819     Printf("ERROR: list not available");
820     return kFALSE;
821   }
822
823   if(fHisto2d && fVector2d) AliInfo("We will only look at histos. Set fHisto2d off if you don't want");
824   AliTRDCalibraVector *calibraVector = 0x0;
825   if(fVector2d) calibraVector = (AliTRDCalibraVector *) fContainer->FindObject("CalibraVector");
826   //
827   // GAIN TH2I
828   //
829   Bool_t pass = kFALSE; 
830   AliTRDCalibraVector *vvect = 0x0;
831   if(fHisto2d) {
832     TH2I *histogain = (TH2I *) fContainer->FindObject("CH2d");  
833     if(histogain) {
834       histogain->SetDirectory(0);
835       calibra->SetMinEntries(20); 
836       if(fCompressPerDetector){
837         if(AddStatsPerDetector(histogain)) pass = calibra->AnalyseCH(fCHSum);
838       }
839       else pass = calibra->AnalyseCH(histogain);
840     }
841   }
842   else {
843     if(fVector2d && calibraVector) {
844       calibra->SetMinEntries(20); 
845       if(fCompressPerDetector){
846         if(!(vvect = calibraVector->AddStatsPerDetectorCH())) return kFALSE;
847         pass = calibra->AnalyseCH(vvect);
848       }
849       else pass = calibra->AnalyseCH(calibraVector);
850     }
851   }
852   
853   if(pass)
854     {
855       Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
856         + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
857       Int_t nbfit = calibra->GetNumberFit();  //Number of fits
858       Int_t nbE   = calibra->GetNumberEnt();  //Number of detector mit entries
859       // enough statistics
860       if ((nbtg >                  0) && 
861           (nbfit        >= 0.001*nbE))
862         {
863           // create the cal objects
864           calibra->PutMeanValueOtherVectorFit(1,kTRUE); 
865           TObjArray object           = calibra->GetVectorFit();
866           AliTRDCalDet *objgaindet   = calibra->CreateDetObjectGain(&object);
867           TObject *objgainpad        = calibra->CreatePadObjectGain();
868           // store
869           fArrayCalib->AddAt(objgaindet,0);
870           fArrayCalib->AddAt(objgainpad,1);
871           //storage[0] = kTRUE;
872           // Make graph
873           TGraph *graph = 0x0;
874           if(FillGraphIndex(&object,graph)){ 
875             fGraph->AddAt(graph,0);
876           }
877         }//if(enough statistics?)
878       calibra->ResetVectorFit();
879     }
880   else return kFALSE;
881   
882   //
883   // VDRIFT average pulse height
884   //
885   pass = kFALSE; 
886   if(fHisto2d) {
887     TProfile2D *histodriftvelocity = (TProfile2D *) fContainer->FindObject("PH2d");  
888     if(histodriftvelocity) {
889       histodriftvelocity->SetDirectory(0);  
890       calibra->SetMinEntries(20*20);  
891       if(fCompressPerDetector){
892         if(AddStatsPerDetector(histodriftvelocity,1)) {
893           pass = calibra->AnalysePH(fDetSumVector);
894         }
895       }
896       else pass = calibra->AnalysePH(histodriftvelocity);
897     }
898   }
899   else {
900     if(fVector2d && calibraVector) {
901       calibra->SetMinEntries(20*20);  
902       if(fCompressPerDetector){
903         if(!(vvect = calibraVector->AddStatsPerDetectorPH())) return kFALSE;
904         pass = calibra->AnalysePH(vvect);
905       }
906       else pass = calibra->AnalysePH(calibraVector);  
907     }
908   }
909
910   if(pass) {
911     Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
912       + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
913     Int_t nbfit  = calibra->GetNumberFit();
914     Int_t nbE    = calibra->GetNumberEnt();
915     // enough statistics
916     if ((nbtg >                  0) && 
917         (nbfit        >= 0.001*nbE))
918       {
919         // create the cal objects
920         calibra->PutMeanValueOtherVectorFit(1,kTRUE);
921         calibra->PutMeanValueOtherVectorFit2(1,kTRUE); 
922         TObjArray object  = calibra->GetVectorFit();
923         AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
924         TObject *objdriftvelocitypad      = calibra->CreatePadObjectVdrift();
925         TObjArray objectt          = calibra->GetVectorFit2();
926         AliTRDCalDet *objtime0det  = calibra->CreateDetObjectT0(&object,kTRUE);
927         TObject *objtime0pad       = calibra->CreatePadObjectT0();
928         // store
929         fArrayCalib->AddAt(objdriftvelocitydet,2);
930         fArrayCalib->AddAt(objdriftvelocitypad,3);
931         //
932         fArrayCalib->AddAt(objtime0det,4);
933         fArrayCalib->AddAt(objtime0pad,5);
934         // Make graph
935         TGraph *graph = 0x0;
936         if(FillGraphIndex(&object,graph)){ 
937           fGraph->AddAt(graph,1);
938         }
939         TGraph *graphh = 0x0;
940         if(FillGraphIndex(&objectt,graphh)){ 
941           fGraph->AddAt(graphh,2);
942         }
943       }//if(enough statistics)
944     calibra->ResetVectorFit();
945   }
946   else return kFALSE;
947   
948   //
949   // PRF
950   //
951   pass = kFALSE; 
952   if(fHisto2d) {
953     TProfile2D *histoprf = (TProfile2D *) fContainer->FindObject("PRF2d");
954     if (histoprf) {
955       histoprf->SetDirectory(0);  
956       calibra->SetMinEntries(600); 
957       if(fCompressPerDetector){
958         if(AddStatsPerDetector(histoprf,2)) pass = calibra->AnalysePRFMarianFit(fDetSumVector);
959       }
960       else pass = calibra->AnalysePRFMarianFit(histoprf);
961     }
962   }
963   else {
964     if(fVector2d && calibraVector) {
965       calibra->SetMinEntries(600);  
966       if(fCompressPerDetector){
967         if(!(vvect =calibraVector->AddStatsPerDetectorPRF())) return kFALSE;
968         pass = calibra->AnalysePRFMarianFit(vvect);
969       }
970       else pass = calibra->AnalysePRFMarianFit(calibraVector);  
971     }
972   }
973   
974   if(pass){
975     Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
976       + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
977     Int_t nbfit        = calibra->GetNumberFit();
978     Int_t nbE          = calibra->GetNumberEnt();
979     // enough statistics
980     if ((nbtg >                  0) && 
981         (nbfit        >= 0.001*nbE)) {
982       TObjArray object            = calibra->GetVectorFit();
983       TObject *objPRFpad          = calibra->CreatePadObjectPRF(&object);
984       // store
985       fArrayCalib->AddAt(objPRFpad,6);
986       // Make graph
987       TGraph *graph = 0x0;
988       if(FillGraphIndex(&object,graph)){ 
989         fGraph->AddAt(graph,5);
990       }
991     }
992     calibra->ResetVectorFit();
993   }
994   else return kFALSE;
995   
996   //
997   // VDRIFT linear fit 
998   //
999   AliTRDCalibraVdriftLinearFit *vlinearfit = (AliTRDCalibraVdriftLinearFit *) fContainer->FindObject("LinearVdriftFit"); 
1000   if (vlinearfit) {
1001     calibra->SetMinEntries(20*20);     
1002     if(calibra->AnalyseLinearFitters(vlinearfit)) {
1003       
1004       Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
1005         + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
1006       Int_t nbfit  = calibra->GetNumberFit();
1007       Int_t nbE    = calibra->GetNumberEnt();
1008       // enough statistics
1009       if ((nbtg >                  0) && 
1010           (nbfit        >= 0.001*nbE))
1011         {
1012           // create the cal objects
1013           calibra->PutMeanValueOtherVectorFit(1,kTRUE);
1014           calibra->PutMeanValueOtherVectorFit2(1,kTRUE); 
1015           TObjArray object  = calibra->GetVectorFit();
1016           AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
1017           TObject *objdriftvelocitypad      = calibra->CreatePadObjectVdrift();
1018           TObjArray objectt          = calibra->GetVectorFit2();
1019           AliTRDCalDet *objtime0det  = calibra->CreateDetObjectT0(&object,kTRUE);
1020           TObject *objtime0pad       = calibra->CreatePadObjectT0();
1021           // store dummy
1022           fArrayCalib->AddAt(objdriftvelocitydet,7);
1023           fArrayCalib->AddAt(objdriftvelocitypad,8);
1024           //
1025           fArrayCalib->AddAt(objtime0det,9);
1026           fArrayCalib->AddAt(objtime0pad,10);
1027           // Make graph
1028           TGraph *graph = 0x0;
1029           if(FillGraphIndex(&object,graph)){ 
1030             fGraph->AddAt(graph,3);
1031           }
1032           TGraph *graphh = 0x0;
1033           if(FillGraphIndex(&objectt,graphh)){ 
1034             fGraph->AddAt(graphh,4);
1035           }
1036         }//if(enough statistics)
1037     }// if fit
1038     calibra->ResetVectorFit();
1039   }
1040   else return kFALSE;
1041   
1042   fPostProcess = kTRUE;
1043   
1044   return kTRUE;
1045   
1046 }
1047
1048 //________________________________________________________________________
1049 Bool_t AliTRDcalibration::FillGraphIndex(const TObjArray *vectora,TGraph *graph) const
1050 {
1051   //
1052   // Fill one value (the first one) per detector
1053   //
1054
1055   Int_t loop = (Int_t) vectora->GetEntriesFast();
1056   if(loop != 540) {
1057     AliInfo("The Vector Fit is not complete!");
1058     return kFALSE;
1059   }
1060   
1061   Double_t x[540];
1062   Double_t y[540];
1063   for (Int_t k = 0; k < loop; k++) {
1064     if(!vectora->At(k)){
1065       x[k] = -1.0;
1066       y[k] = -1.0;
1067       continue;
1068     }
1069     x[k]  = ((AliTRDCalibraFit::AliTRDFitInfo *) vectora->At(k))->GetDetector();
1070     y[k]  = ((Float_t *)((AliTRDCalibraFit::AliTRDFitInfo *) vectora->At(k))->GetCoef())[0];
1071   }
1072
1073   if(!graph){
1074     graph = new TGraph(540,&x[0],&y[0]);
1075     graph->SetMarkerStyle(20);
1076   } else{ 
1077     graph->~TGraph();
1078     new(graph) TGraph(540,&x[0],&y[0]);
1079   }
1080
1081   return kTRUE;
1082
1083 }
1084 //________________________________________________________________________
1085 Bool_t AliTRDcalibration::AddStatsPerDetector(const TH2I *ch) 
1086 {
1087   //
1088   // Add statistic per detector
1089   //
1090   
1091   AliTRDCalibraMode calibMode = AliTRDCalibraMode();
1092   const char *name = ch->GetTitle();
1093   if(!SetNzFromTObject(name,0,&calibMode)) return 0x0;
1094   if(!SetNrphiFromTObject(name,0,&calibMode)) return 0x0;
1095   if(((calibMode.GetNz(0) == 100) && (calibMode.GetNrphi(0) == 100)) || ((calibMode.GetNz(0) == 10) && (calibMode.GetNrphi(0) == 10))) return kFALSE;
1096
1097   Int_t    nybins  = ch->GetNbinsY();// groups number
1098   Int_t    nxbins  = ch->GetNbinsX();// number of bins X
1099   const TAxis   *xaxis   = ch->GetXaxis();
1100   Double_t lowedge  = xaxis->GetBinLowEdge(1);
1101   Double_t upedge   = xaxis->GetBinUpEdge(nxbins);
1102
1103   // number per chamber 2
1104   calibMode.ModePadCalibration(2,0);
1105   calibMode.ModePadFragmentation(0,2,0,0);
1106   calibMode.SetDetChamb2(0);
1107   Int_t perChamber2 = (Int_t) calibMode.GetDetChamb2(0);
1108
1109   // number per other chamber
1110   calibMode.ModePadCalibration(0,0);
1111   calibMode.ModePadFragmentation(0,0,0,0);
1112   calibMode.SetDetChamb0(0);
1113   Int_t perChamber0 = (Int_t) calibMode.GetDetChamb0(0);
1114
1115   if(nybins != (6*18*perChamber2+6*4*18*perChamber0)) return kFALSE;
1116
1117   // Create Histo
1118   TString nname((const char *)ch->GetName());
1119   nname  += "PerDetector";
1120   TString title("Nz");
1121   title += 0;
1122   title += "Nrphi";
1123   title += 0;
1124   if(!fCHSum) fCHSum = new TH2I((const char *)nname,(const char *)title
1125                                 ,nxbins,lowedge,upedge,540,0,540);
1126   else{ 
1127     fCHSum->~TH2I();
1128     new(fCHSum) TH2I((const Char_t *) nname,(const char *)title
1129                      ,nxbins,lowedge,upedge,540,0,540);
1130   }
1131   fCHSum->SetYTitle("Detector number");
1132   fCHSum->SetXTitle("charge deposit [a.u]");
1133   fCHSum->SetZTitle("counts");
1134   fCHSum->SetStats(0);
1135   fCHSum->Sumw2();
1136
1137   Int_t counter = 0;
1138   
1139   for(Int_t det = 0; det < 540; det++){
1140
1141     Int_t numberofgroup = 0;
1142     if(AliTRDgeometry::GetStack(det) == 2) numberofgroup = perChamber2;
1143     else numberofgroup = perChamber0;
1144     TH1I *projch = (TH1I *) ch->ProjectionX("projch",counter+1,counter+numberofgroup,(Option_t *)"e");
1145     projch->SetDirectory(0);
1146        
1147     for(Int_t nx = 0; nx <= nxbins; nx++) {
1148       fCHSum->SetBinContent(nx,det+1,projch->GetBinContent(nx));
1149       fCHSum->SetBinError(nx,det+1,projch->GetBinError(nx));
1150     }
1151
1152     counter += numberofgroup;
1153     
1154     delete projch;
1155
1156   }
1157
1158   return kTRUE;
1159
1160 }
1161 //_____________________________________________________________________________________________________________________
1162 Bool_t AliTRDcalibration::AddStatsPerDetector(const TProfile2D *ph,Int_t i)
1163 {
1164   //
1165   // Add statistic per detector
1166   //
1167
1168   AliTRDCalibraMode calibMode = AliTRDCalibraMode();
1169   const char *name = ph->GetTitle();
1170   //printf("name %s\n",name);
1171   if(!SetNzFromTObject(name,0,&calibMode)) return kFALSE;
1172   if(!SetNrphiFromTObject(name,0,&calibMode)) return kFALSE;
1173   if(((calibMode.GetNz(0) == 100) && (calibMode.GetNrphi(0) == 100)) || ((calibMode.GetNz(0) == 10) && (calibMode.GetNrphi(0) == 10))) return kFALSE;
1174   //printf("Found mode Mz %d, Nrphi %d\n",calibMode.GetNz(0),calibMode.GetNrphi(0));  
1175
1176
1177   Int_t    nybins  = ph->GetNbinsY();// groups number
1178   Int_t    nxbins  = ph->GetNbinsX();// number of bins X
1179   const TAxis   *xaxis = ph->GetXaxis();
1180   Double_t lowedge  = xaxis->GetBinLowEdge(1);
1181   Double_t upedge   = xaxis->GetBinUpEdge(nxbins);
1182
1183   // number per chamber 2
1184   calibMode.ModePadCalibration(2,0);
1185   calibMode.ModePadFragmentation(0,2,0,0);
1186   calibMode.SetDetChamb2(0);
1187   Int_t perChamber2 = (Int_t) calibMode.GetDetChamb2(0);
1188
1189   // number per other chamber
1190   calibMode.ModePadCalibration(0,0);
1191   calibMode.ModePadFragmentation(0,0,0,0);
1192   calibMode.SetDetChamb0(0);
1193   Int_t perChamber0 = (Int_t) calibMode.GetDetChamb0(0);
1194
1195   if(nybins != (6*18*perChamber2+6*4*18*perChamber0)) return kFALSE;
1196   
1197   // Create calvector 
1198   TString nbname((const char *)ph->GetName());
1199   nbname  += "PerDetectorVector";
1200   if(!fDetSumVector) fDetSumVector = new AliTRDCalibraVector();
1201   else{ 
1202     fDetSumVector->~AliTRDCalibraVector();
1203     new(fDetSumVector) AliTRDCalibraVector();
1204   }
1205   if(i==1){
1206     fDetSumVector->SetTimeMax(nxbins);
1207   }
1208   if(i==2){
1209     fDetSumVector->SetNumberBinPRF(nxbins);
1210     fDetSumVector->SetPRFRange(TMath::Abs(lowedge));
1211   }
1212   fDetSumVector->SetDetCha0(i,1);
1213   fDetSumVector->SetDetCha2(i,1);
1214   fDetSumVector->SetNzNrphi(i,0,0);
1215   if(i==2) {
1216     Int_t nbg = GetNumberOfGroupsPRF((const char *)name);
1217     fDetSumVector->SetNbGroupPRF(nbg);
1218   }
1219
1220   // Create Histo
1221   TString nname((const char *)ph->GetName());
1222   nname  += "PerDetector";
1223   TString title("Nz");
1224   title += 0;
1225   title += "Nrphi";
1226   title += 0;
1227   if(!fDetSum) fDetSum = new TH2D((const char *)nname,(const Char_t *) title
1228                                 ,nxbins,lowedge,upedge,540,0,540);
1229   else{ 
1230     fDetSum->~TH2D();
1231     new(fDetSum) TH2D((const Char_t *) nname,(const Char_t *) title
1232                      ,nxbins,lowedge,upedge,540,0,540);
1233   }
1234   fDetSum->SetYTitle("Detector number");
1235   fDetSum->SetXTitle(xaxis->GetTitle());
1236   fDetSum->SetStats(0);
1237   
1238   Int_t counter = 0;
1239
1240   for(Int_t det = 0; det < 540; det++){
1241
1242     Int_t numberofgroup = 0;
1243     if(AliTRDgeometry::GetStack(det) == 2) numberofgroup = perChamber2;
1244     else numberofgroup = perChamber0;
1245     
1246     for(Int_t nx = 1; nx <= nxbins; nx++) {
1247       
1248       Double_t entries = 0.0;
1249       Double_t sumw2 = 0.0;
1250       Double_t sumw = 0.0;
1251
1252       for(Int_t k = counter+1; k <= (counter+numberofgroup); k++){
1253         Int_t  binnumber = ph->GetBin(nx,k);
1254         entries += ph->GetBinEntries(binnumber);
1255         sumw2 += (ph->GetBinError(binnumber)*ph->GetBinError(binnumber)+ph->GetBinContent(binnumber)*ph->GetBinContent(binnumber))*ph->GetBinEntries(binnumber);
1256         sumw += ph->GetBinContent(binnumber)*ph->GetBinEntries(binnumber);
1257       }
1258
1259       Double_t mean = 0.0;
1260       if(entries > 0.0) mean = sumw/entries;
1261       Double_t squaremean = 0.0;
1262       if(entries > 0.0) squaremean = sumw2/entries;
1263       Double_t errorf = squaremean - mean*mean;
1264       Double_t error = 0.0;
1265       if(entries > 0.0) error = TMath::Sqrt(TMath::Abs(errorf)/entries);
1266       
1267       fDetSum->SetBinContent(nx,det+1,mean);
1268       fDetSum->SetBinError(nx,det+1,error);
1269
1270       if(i==1) fDetSumVector->FillVectorPH(det,0,nx-1,(Int_t)entries,(Float_t)mean,(Float_t)squaremean);
1271       if(i==2) fDetSumVector->FillVectorPRF(det,0,nx-1,(Int_t)entries,(Float_t)mean,(Float_t)squaremean);
1272       
1273     }
1274     
1275     counter += numberofgroup;
1276
1277   }
1278
1279   return kTRUE;
1280
1281   
1282 }
1283 //_____________________________________________________________________________
1284 Bool_t AliTRDcalibration::SetNrphiFromTObject(const char *name, Int_t i, AliTRDCalibraMode *calibMode) const
1285 {
1286   //
1287   // Set the granularity from object
1288   //  
1289   
1290   const Char_t *patternrphi0 = "Nrphi0";
1291   const Char_t *patternrphi1 = "Nrphi1";
1292   const Char_t *patternrphi2 = "Nrphi2";
1293   const Char_t *patternrphi3 = "Nrphi3";
1294   const Char_t *patternrphi4 = "Nrphi4";
1295   const Char_t *patternrphi5 = "Nrphi5";
1296   const Char_t *patternrphi6 = "Nrphi6";
1297
1298   
1299   const Char_t *patternrphi10 = "Nrphi10";
1300   const Char_t *patternrphi100 = "Nrphi100";
1301   const Char_t *patternz10 = "Nz10";
1302   const Char_t *patternz100 = "Nz100";
1303
1304   // Nrphi mode
1305   if ((strstr(name,patternrphi100)) && (strstr(name,patternz100))) {
1306     calibMode->SetAllTogether(i);
1307     return kTRUE;
1308   }
1309   if ((strstr(name,patternrphi10)) && (strstr(name,patternz10))) {
1310     calibMode->SetPerSuperModule(i);
1311     return kTRUE;
1312   }
1313   
1314   if (strstr(name,patternrphi0)) {
1315     calibMode->SetNrphi(i ,0);
1316     return kTRUE;
1317   }
1318   if (strstr(name,patternrphi1)) {
1319     calibMode->SetNrphi(i, 1);
1320     return kTRUE;
1321   }
1322   if (strstr(name,patternrphi2)) {
1323     calibMode->SetNrphi(i, 2);
1324     return kTRUE;
1325   }
1326   if (strstr(name,patternrphi3)) {
1327     calibMode->SetNrphi(i, 3);
1328     return kTRUE;
1329   }
1330   if (strstr(name,patternrphi4)) {
1331     calibMode->SetNrphi(i, 4);
1332     return kTRUE;
1333   }
1334   if (strstr(name,patternrphi5)) {
1335     calibMode->SetNrphi(i, 5);
1336     return kTRUE;
1337   }
1338   if (strstr(name,patternrphi6)) {
1339     calibMode->SetNrphi(i, 6);
1340     return kTRUE;
1341   }
1342   
1343   calibMode->SetNrphi(i ,0);
1344   return kFALSE;
1345   
1346 }
1347 //_____________________________________________________________________________
1348 Bool_t AliTRDcalibration::SetNzFromTObject(const char *name, Int_t i, AliTRDCalibraMode *calibMode) const
1349 {
1350   //
1351   // Set fNz[i] of the AliTRDCalibraFit::Instance()
1352   // corresponding to the given TObject
1353   //
1354
1355   // Some patterns
1356   const Char_t *patternz0    = "Nz0";
1357   const Char_t *patternz1    = "Nz1";
1358   const Char_t *patternz2    = "Nz2";
1359   const Char_t *patternz3    = "Nz3";
1360   const Char_t *patternz4    = "Nz4";
1361
1362   const Char_t *patternrphi10 = "Nrphi10";
1363   const Char_t *patternrphi100 = "Nrphi100";
1364   const Char_t *patternz10 = "Nz10";
1365   const Char_t *patternz100 = "Nz100";
1366
1367   if ((strstr(name,patternrphi100)) && (strstr(name,patternz100))) {
1368     calibMode->SetAllTogether(i);
1369     return kTRUE;
1370   }
1371   if ((strstr(name,patternrphi10)) && (strstr(name,patternz10))) {
1372     calibMode->SetPerSuperModule(i);
1373     return kTRUE;
1374   }
1375   if (strstr(name,patternz0)) {
1376     calibMode->SetNz(i, 0);
1377     return kTRUE;
1378   }
1379   if (strstr(name,patternz1)) {
1380     calibMode->SetNz(i ,1);
1381     return kTRUE;
1382   }
1383   if (strstr(name,patternz2)) {
1384     calibMode->SetNz(i ,2);
1385     return kTRUE;
1386   }
1387   if (strstr(name,patternz3)) {
1388     calibMode->SetNz(i ,3);
1389     return kTRUE;  
1390   }
1391   if (strstr(name,patternz4)) {
1392     calibMode->SetNz(i ,4);
1393     return kTRUE;
1394   }
1395  
1396   calibMode->SetNz(i ,0);
1397   return kFALSE;
1398 }
1399 //____________________________________________________________________________________________________
1400 Int_t AliTRDcalibration::GetNumberOfGroupsPRF(const char* nametitle) const
1401 {
1402   //
1403   // Get numberofgroupsprf
1404   //
1405   
1406   // Some patterns
1407   const Char_t *pattern0 = "Ngp0";
1408   const Char_t *pattern1 = "Ngp1";
1409   const Char_t *pattern2 = "Ngp2";
1410   const Char_t *pattern3 = "Ngp3";
1411   const Char_t *pattern4 = "Ngp4";
1412   const Char_t *pattern5 = "Ngp5";
1413   const Char_t *pattern6 = "Ngp6";
1414
1415   // Nrphi mode
1416   if (strstr(nametitle,pattern0)) {
1417     return 0;
1418   }
1419   if (strstr(nametitle,pattern1)) {
1420     return 1;
1421   }
1422   if (strstr(nametitle,pattern2)) {
1423     return 2;
1424   }
1425   if (strstr(nametitle,pattern3)) {
1426     return 3;
1427   }
1428   if (strstr(nametitle,pattern4)) {
1429     return 4;
1430   }
1431   if (strstr(nametitle,pattern5)) {
1432     return 5;
1433   }
1434   if (strstr(nametitle,pattern6)){
1435     return 6;
1436   }
1437   else return -1;
1438 }