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