Script supersceeded by AliForwarddNdetaTask.C and
[u/mrichter/AliRoot.git] / TPC / AliTPCQADataMakerRec.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16
17 /* $Id: $ */
18
19 /*
20   Based on AliPHOSQADataMaker
21   Produces the data needed to calculate the quality assurance. 
22   All data must be mergeable objects.
23   P. Christiansen, Lund, January 2008
24
25   Updated June 2010:
26   ==================
27
28   The "beautification" of the online DQM histograms have been moved to
29   an amore macro.  
30
31   The per event RAW histograms have been modified in AliTPCdataQA and
32   the copies have therefore also been modified here.
33
34   The AliTPCdataQA can now be configured a bit from here: time bin
35   range (extended default range to 1-1000, event range at start:
36   0-100000, 1000 events per bin). (At least the parameters are not
37   hardcoded:-)
38
39   Implementation:
40   ===============
41
42   For the QA of the RAW data we use the class, AliTPCdataQA, from the
43   existing TPC Calibration framework (which is more advanced than the
44   standard QA framework) and extract the histograms at the end. The
45   Analyse method of the AliTPCdataQA class is called in the method,
46   EndOfDetectorCycle, and there also: 1d histogram(s) are projected
47   and added to the QA list.
48 */
49
50 #include "AliTPCQADataMakerRec.h"
51
52 // --- ROOT system ---
53 #include <TClonesArray.h>
54 #include <TString.h>
55 #include <TSystem.h>
56 #include <TBox.h>
57 #include <TLine.h>
58 #include <TAxis.h>
59
60 // --- Standard library ---
61
62 // --- AliRoot header files ---
63 #include "AliQAChecker.h"
64 #include "AliESDEvent.h"
65 #include "AliESDtrack.h"
66 #include "AliLog.h"
67 #include "AliTPCCalPad.h"
68 #include "AliTPCCalROC.h"
69 #include "AliTPCClustersRow.h"
70 #include "AliTPCclusterMI.h"
71 #include "AliSimDigits.h"
72
73
74 ClassImp(AliTPCQADataMakerRec)
75
76 //____________________________________________________________________________ 
77 AliTPCQADataMakerRec::AliTPCQADataMakerRec() : 
78 AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kTPC), 
79                   "TPC Rec Quality Assurance Data Maker"),
80 fTPCdataQA(NULL),
81 fRawMaxEvents(100000),
82 fRawEventsPerBin(1000),
83 fRawFirstTimeBin(1),
84 fRawLastTimeBin(1000)
85 {
86   // ctor
87   fTPCdataQA = new AliTPCdataQA*[AliRecoParam::kNSpecies] ;
88   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
89     fTPCdataQA[specie] = NULL ; 
90   
91   for(Int_t i = 0; i < 6; i++)
92     fMapping[i] = 0;
93 }
94
95 //____________________________________________________________________________ 
96 AliTPCQADataMakerRec::AliTPCQADataMakerRec(const AliTPCQADataMakerRec& qadm) :
97   AliQADataMakerRec(),
98   fTPCdataQA(NULL),
99   fRawMaxEvents(qadm.GetRawMaxEvents()),
100   fRawEventsPerBin(qadm.GetRawEventsPerBin()),
101   fRawFirstTimeBin(qadm.GetRawFirstTimeBin()),
102   fRawLastTimeBin(qadm.GetRawLastTimeBin())
103 {
104   //copy ctor 
105   // Does not copy the calibration object, instead InitRaws have to be
106   // called again
107   SetName((const char*)qadm.GetName()) ; 
108   SetTitle((const char*)qadm.GetTitle()); 
109
110   fTPCdataQA = new AliTPCdataQA*[AliRecoParam::kNSpecies] ;
111   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
112     fTPCdataQA[specie] = NULL ; 
113   
114   for(Int_t i = 0; i < 6; i++)
115     fMapping[i] = 0;
116
117   //
118   // Associate class histogram objects to the copies in the list
119   // Could also be done with the indexes
120   //
121
122 }
123
124 //__________________________________________________________________
125 AliTPCQADataMakerRec& AliTPCQADataMakerRec::operator = (const AliTPCQADataMakerRec& qadm )
126 {
127   // Equal operator.
128   this->~AliTPCQADataMakerRec();
129   new(this) AliTPCQADataMakerRec(qadm);
130   return *this;
131 }
132
133 //__________________________________________________________________
134 AliTPCQADataMakerRec::~AliTPCQADataMakerRec()
135 {
136   // Destructor
137   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) 
138     if ( fTPCdataQA[specie] != NULL )
139       delete fTPCdataQA[specie] ; 
140   delete[] fTPCdataQA; 
141
142   for(Int_t i = 0; i < 6; i++) 
143     delete fMapping[i];
144 }
145  
146 //____________________________________________________________________________ 
147 void AliTPCQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
148 {
149   //Detector specific actions at end of cycle
150   
151   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
152     if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) ) 
153       continue ; 
154     if(fTPCdataQA[specie] != NULL) { // do the final step of the QA for Raw data
155
156       fTPCdataQA[specie]->Analyse(); // 31/1-08 Analyse is now protected against
157                            //         RAW data files with no TPC data
158
159       SetEventSpecie(AliRecoParam::ConvertIndex(specie)) ; 
160       TH1F * histRawsOccupancy                 = (TH1F*)GetRawsData(kRawsOccupancy) ;
161       TH1F * histRawsOccupancyVsSector         = (TH1F*)GetRawsData(kRawsOccupancyVsSector) ;
162       TH1F * histRawsNClustersPerEventVsSector = (TH1F*)GetRawsData(kRawsNClustersPerEventVsSector) ;
163       TH1F * histRawsQVsSector                 = (TH1F*)GetRawsData(kRawsQVsSector) ;
164       TH1F * histRawsQmaxVsSector              = (TH1F*)GetRawsData(kRawsQmaxVsSector) ;
165       TH1F * histRawsOccupancyVsEvent          = (TH1F*)GetRawsData(kRawsOccupancyVsEvent) ;
166       TH1F * histRawsNclustersVsEvent          = (TH1F*)GetRawsData(kRawsNclustersVsEvent) ;
167       if ( !histRawsOccupancy ||
168            !histRawsOccupancyVsSector ||
169            !histRawsNClustersPerEventVsSector ||
170            !histRawsQVsSector ||
171            !histRawsQmaxVsSector ||
172            !histRawsOccupancyVsEvent ||
173            !histRawsNclustersVsEvent ) {
174         AliError("Something very wrong here, corrupted memory ?????. Please check\n") ; 
175         continue ; 
176       }
177         
178       //Add2RawsList(fTPCdataQA, 0);
179       // get the histograms and add them to the output
180       // 31/8-08 Histogram is only added if the Calibration class 
181       //         receives TPC data 
182       const Int_t eventCounter = fTPCdataQA[specie]->GetEventCounter();
183       if(eventCounter>0) { // some TPC data has been processed
184
185         // Reset histograms and refill them 
186         histRawsOccupancy->Reset();
187         histRawsOccupancyVsSector->Reset();
188         histRawsNClustersPerEventVsSector->Reset();
189         histRawsQVsSector->Reset();
190         histRawsQmaxVsSector->Reset();
191       
192         TH1F* hNormOcc = new TH1F("hNormOcc", 0, 72, 0, 72);
193         hNormOcc->Sumw2();
194         TH1F* hNormNclusters = new TH1F("hNormNclusters", 0, 72, 0, 72);
195         hNormNclusters->Sumw2();
196
197         for (Int_t iSec = 0; iSec < 72; iSec++) {
198         
199           AliTPCCalROC* occupancyROC = 
200           fTPCdataQA[specie]->GetNoThreshold()->GetCalROC(iSec); 
201           AliTPCCalROC* nclusterROC = 
202           fTPCdataQA[specie]->GetNLocalMaxima()->GetCalROC(iSec); 
203           AliTPCCalROC* qROC = 
204           fTPCdataQA[specie]->GetMeanCharge()->GetCalROC(iSec); 
205           AliTPCCalROC* qmaxROC = 
206           fTPCdataQA[specie]->GetMaxCharge()->GetCalROC(iSec); 
207
208           const Int_t nRows = occupancyROC->GetNrows(); 
209           for (Int_t iRow = 0; iRow < nRows; iRow++) {
210
211             const Int_t nPads = occupancyROC->GetNPads(iRow); 
212             for (Int_t iPad = 0; iPad < nPads; iPad++) {
213               
214               histRawsOccupancy->Fill(occupancyROC->GetValue(iRow, iPad));
215               hNormOcc->Fill(iSec);
216               histRawsOccupancyVsSector
217                 ->Fill(iSec, occupancyROC->GetValue(iRow, iPad));
218               
219               const Int_t nClusters = TMath::Nint(nclusterROC->GetValue(iRow, iPad));
220               
221               if(nClusters>0) {
222                 
223                 hNormNclusters->Fill(iSec,nClusters);
224                 histRawsNClustersPerEventVsSector->Fill(iSec, nClusters);
225                 histRawsQVsSector->Fill(iSec, 
226                                         nClusters*qROC->GetValue(iRow, iPad));
227                 histRawsQmaxVsSector->Fill(iSec, 
228                                            nClusters*qmaxROC->GetValue(iRow, iPad));
229               }
230             }
231           }
232         } // end loop over sectors
233       
234         // update event histograms - copy info from TPDdataQA histos
235         const TH1F* hQAOccVsEvent = fTPCdataQA[specie]->GetHistOccupancyVsEvent();
236         const TH1F* hQANclVsEvent = fTPCdataQA[specie]->GetHistNclustersVsEvent();
237         
238         // In case the histogram limits have changed we have to update
239         // them here
240         if(histRawsOccupancy->GetXaxis()->GetXmax()!=
241            hQAOccVsEvent->GetXaxis()->GetXmax()) {
242           
243           histRawsOccupancyVsEvent->GetXaxis()->Set(histRawsOccupancyVsEvent->GetXaxis()->GetNbins(), hQAOccVsEvent->GetXaxis()->GetXmin(), hQAOccVsEvent->GetXaxis()->GetXmax()); 
244           
245           histRawsNclustersVsEvent->GetXaxis()->Set(histRawsOccupancyVsEvent->GetXaxis()->GetNbins(), hQANclVsEvent->GetXaxis()->GetXmin(), hQANclVsEvent->GetXaxis()->GetXmax()); 
246         }
247         
248         // reset the number of entries
249         histRawsOccupancyVsEvent->SetEntries(0);
250         histRawsNclustersVsEvent->SetEntries(0);
251
252         // the two event histograms should have the same number of bins
253         const Int_t nBins = hQAOccVsEvent->GetXaxis()->GetNbins();
254         for(Int_t bin = 1; bin <= nBins; bin++) {
255           
256           histRawsOccupancyVsEvent->SetBinContent(bin, hQAOccVsEvent->GetBinContent(bin));
257           histRawsNclustersVsEvent->SetBinContent(bin, hQANclVsEvent->GetBinContent(bin));
258         }
259         
260         // Normalize histograms
261         histRawsOccupancyVsSector->Divide(hNormOcc);
262         histRawsNClustersPerEventVsSector->Scale(1.0/Float_t(eventCounter));
263         histRawsQVsSector->Divide(hNormNclusters);
264         histRawsQmaxVsSector->Divide(hNormNclusters);
265         delete hNormOcc;
266         delete hNormNclusters;
267         
268       }
269     }
270   }
271   AliQAChecker::Instance()->Run(AliQAv1::kTPC, task, list) ;  
272 }
273
274
275 //____________________________________________________________________________ 
276 void AliTPCQADataMakerRec::InitESDs()
277 {
278   //create ESDs histograms in ESDs subdir  
279   const Bool_t expert   = kTRUE ; 
280   const Bool_t image    = kTRUE ; 
281   
282   TH1F * histESDclusters = 
283     new TH1F("hESDclusters", "N TPC clusters per track; N clusters; Counts",
284              160, 0, 160);
285   histESDclusters->Sumw2();
286   Add2ESDsList(histESDclusters, KClusters, !expert, image);
287
288   TH1F * histESDratio = 
289     new TH1F("hESDratio", "Ratio: TPC clusters / findable; Ratio: cluster/findable; Counts",
290              100, 0, 1);
291   histESDratio->Sumw2();
292   Add2ESDsList(histESDratio, kRatio, !expert, image);
293   
294   TH1F * histESDpt = 
295     new TH1F("hESDpt", "P_{T} distribution; p_{T} [GeV/c]; Counts",
296              50, 0, 5);
297   histESDpt->Sumw2();
298   Add2ESDsList(histESDpt, kPt, !expert, image);
299 }
300
301 //____________________________________________________________________________ 
302 void AliTPCQADataMakerRec::InitRaws()
303 {
304   //
305   // Adding the raw 
306   //  
307
308   // Modified: 7/7 - 2008
309   // Laurent Aphecetche pointed out that the mapping was read from file
310   // for each event, so now we read in the map here and set if for 
311   // the raw data qa
312   const Bool_t expert   = kTRUE ; 
313   const Bool_t saveCorr = kTRUE ; 
314   const Bool_t image    = kTRUE ; 
315   
316   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
317     
318     // It might happen that we will be in this method a few times because
319     // we create all dataQAs at the first call to this method
320     if(fTPCdataQA[specie]!=0) // data QA already created
321       continue;
322
323     fTPCdataQA[specie] = 
324       new AliTPCdataQA(AliRecoParam::ConvertIndex(specie));
325     LoadMaps(); // Load Altro maps
326     fTPCdataQA[specie]->SetAltroMapping(fMapping); // set Altro mapping
327     fTPCdataQA[specie]->SetRangeTime(fRawFirstTimeBin, fRawLastTimeBin); // set time bin interval 
328     fTPCdataQA[specie]->SetMaxEvents(fRawMaxEvents);
329     fTPCdataQA[specie]->SetEventsPerBin(fRawEventsPerBin);
330 //    Add2RawsList(fTPCdataQA, kTPCdataQ, !expert, image, !saveCorrA); // This is used by the AMORE monitoring <------- THIS WILL FAIL (YS)
331   }
332
333   TH1F * histRawsOccupancy = 
334     new TH1F("hRawsOccupancy", "Occupancy (all pads); Occupancy; Counts",
335              100, 0, 1);
336   histRawsOccupancy->Sumw2();
337   Add2RawsList(histRawsOccupancy, kRawsOccupancy, expert, !image, !saveCorr);
338   
339   TH1F * histRawsOccupancyVsSector = 
340     new TH1F("hRawsOccupancyVsSector", "Occupancy vs sector; Sector; Occupancy",
341              72, 0, 72);
342   histRawsOccupancyVsSector->Sumw2();
343   histRawsOccupancyVsSector->SetMarkerStyle(20);
344   histRawsOccupancyVsSector->SetOption("P");
345   histRawsOccupancyVsSector->SetStats(kFALSE);
346   Add2RawsList(histRawsOccupancyVsSector, kRawsOccupancyVsSector, !expert, image, !saveCorr);
347
348   TH1F * histRawsNClustersPerEventVsSector = 
349     new TH1F("hRawsNClustersPerEventVsSector", "Nclusters per event vs sector; Sector; Nclusters per event",
350              72, 0, 72);
351   histRawsNClustersPerEventVsSector->Sumw2();
352   Add2RawsList(histRawsNClustersPerEventVsSector, kRawsNClustersPerEventVsSector, expert, !image, !saveCorr);
353   
354   TH1F * histRawsQVsSector = 
355     new TH1F("hRawsQVsSector", "<Q> vs sector; Sector; <Q>",
356              72, 0, 72);
357   histRawsQVsSector->Sumw2();
358   Add2RawsList(histRawsQVsSector, kRawsQVsSector, expert, !image, !saveCorr);
359
360   TH1F * histRawsQmaxVsSector = 
361     new TH1F("hRawsQmaxVsSector", "<Qmax> vs sector; Sector; <Qmax>",
362              72, 0, 72);
363   histRawsQmaxVsSector->Sumw2();
364   histRawsQmaxVsSector->SetMarkerStyle(20);
365   histRawsQmaxVsSector->SetOption("P");
366   histRawsQmaxVsSector->SetStats(kFALSE);
367   Add2RawsList(histRawsQmaxVsSector, kRawsQmaxVsSector, !expert, image, !saveCorr);
368
369   // Get histogram information from data QA to build copy
370   const TH1F* hOccHelp = fTPCdataQA[0]->GetHistOccupancyVsEvent();
371   TH1F * histRawsOccupancyVsEvent = 
372     CreateEventsHistCopy(hOccHelp, "hRawsOccupancyVsEvent");
373   Add2RawsList(histRawsOccupancyVsEvent, kRawsOccupancyVsEvent, expert, !image, !saveCorr);
374   
375   // Get histogram information from data QA to build copy
376   const TH1F* hNclHelp = fTPCdataQA[0]->GetHistNclustersVsEvent();
377   TH1F * histRawsNclustersVsEvent = 
378     CreateEventsHistCopy(hNclHelp, "hRawsNclustersVsEvent");
379   Add2RawsList(histRawsNclustersVsEvent, kRawsNclustersVsEvent, expert, !image, !saveCorr);
380 }
381
382 //____________________________________________________________________________ 
383 void AliTPCQADataMakerRec::InitDigits()
384 {
385   const Bool_t expert   = kTRUE ; 
386   const Bool_t image    = kTRUE ; 
387   TH1F * histDigitsADC = 
388     new TH1F("hDigitsADC", "Digit ADC distribution; ADC; Counts",
389              1000, 0, 1000);
390   histDigitsADC->Sumw2();
391   Add2DigitsList(histDigitsADC, kDigitsADC, !expert, image);
392 }
393
394 //____________________________________________________________________________ 
395 void AliTPCQADataMakerRec::InitRecPoints()
396 {
397   const Bool_t expert   = kTRUE ; 
398   const Bool_t image    = kTRUE ; 
399   
400   TH1F * histRecPointsQmaxShort = 
401     new TH1F("hRecPointsQmaxShort", "Qmax distrbution (short pads); Qmax; Counts",
402              100, 0, 300);
403   histRecPointsQmaxShort->Sumw2();
404   Add2RecPointsList(histRecPointsQmaxShort, kQmaxShort, !expert, image);
405
406   TH1F * histRecPointsQmaxMedium = 
407     new TH1F("hRecPointsQmaxMedium", "Qmax distrbution (medium pads); Qmax; Counts",
408              100, 0, 300);
409   histRecPointsQmaxMedium->Sumw2();
410   Add2RecPointsList(histRecPointsQmaxMedium, kQmaxMedium, !expert, image);
411
412   TH1F * histRecPointsQmaxLong = 
413     new TH1F("hRecPointsQmaxLong", "Qmax distrbution (long pads); Qmax; Counts",
414              100, 0, 300);
415   histRecPointsQmaxLong->Sumw2();
416   Add2RecPointsList(histRecPointsQmaxLong, kQmaxLong, !expert, image);
417
418   TH1F * histRecPointsQShort = 
419     new TH1F("hRecPointsQShort", "Q distrbution (short pads); Q; Counts",
420              100, 0, 2000);
421   histRecPointsQShort->Sumw2();
422   Add2RecPointsList(histRecPointsQShort, kQShort, !expert, image);
423
424   TH1F * histRecPointsQMedium = 
425     new TH1F("hRecPointsQMedium", "Q distrbution (medium pads); Q; Counts",
426              100, 0, 2000);
427   histRecPointsQMedium->Sumw2();
428   Add2RecPointsList(histRecPointsQMedium, kQMedium, !expert, image);
429
430   TH1F * histRecPointsQLong = 
431     new TH1F("hRecPointsQLong", "Q distrbution (long pads); Q; Counts",
432              100, 0, 2000);
433   histRecPointsQLong->Sumw2();
434   Add2RecPointsList(histRecPointsQLong, kQLong, !expert, image);
435
436   TH1F * histRecPointsRow = 
437     new TH1F("hRecPointsRow", "Clusters per row; Row; Counts",
438              159, 0, 159);
439   histRecPointsRow->Sumw2();
440   Add2RecPointsList(histRecPointsRow, kRow, !expert, image);
441 }
442
443 //____________________________________________________________________________
444 void AliTPCQADataMakerRec::MakeESDs(AliESDEvent * esd)
445 {
446   // make QA data from ESDs
447  
448   const Int_t nESDTracks = esd->GetNumberOfTracks();
449   Int_t nTPCtracks = 0; 
450   for(Int_t i = 0; i < nESDTracks; i++) {
451     
452     AliESDtrack * track = esd->GetTrack(i);
453     
454     if ((track->GetStatus() & AliESDtrack::kTPCrefit)==0)
455       continue;
456     
457     nTPCtracks++;
458     
459     Int_t nTPCclusters         = track->GetTPCNcls();
460     Int_t nTPCclustersFindable = track->GetTPCNclsF();
461     if ( nTPCclustersFindable<=0) continue;
462     GetESDsData(KClusters)->Fill(nTPCclusters);
463     GetESDsData(kRatio)->Fill(Float_t(nTPCclusters)/Float_t(nTPCclustersFindable));
464     GetESDsData(kPt)->Fill(track->Pt()); 
465   }
466 }
467
468 //____________________________________________________________________________
469 void AliTPCQADataMakerRec::MakeRaws(AliRawReader* rawReader)
470 {
471   //
472   // To make QA for the RAW data we use the TPC Calibration framework 
473   // to handle the data and then in the end extract the data
474   //
475   
476   GetRawsData(0); // dummy call to init raw data
477   rawReader->Reset() ; 
478   if (! fTPCdataQA[AliRecoParam::AConvert(fEventSpecie)] ) {
479     AliError("Something unexpected here!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!") ; 
480   } else {  
481     fTPCdataQA[AliRecoParam::AConvert(fEventSpecie)]->ProcessEvent(rawReader);  
482   }
483 }
484
485 //____________________________________________________________________________
486 void AliTPCQADataMakerRec::MakeDigits(TTree* digitTree)
487 {
488  
489   TBranch* branch = digitTree->GetBranch("Segment");
490   AliSimDigits* digArray = 0;
491   branch->SetAddress(&digArray);
492   
493   Int_t nEntries = Int_t(digitTree->GetEntries());
494   
495   for (Int_t n = 0; n < nEntries; n++) {
496     
497     digitTree->GetEvent(n);
498     
499     if (digArray->First())
500       do {
501         Float_t dig = digArray->CurrentDigit();
502         
503         GetDigitsData(kDigitsADC)->Fill(dig);
504       } while (digArray->Next());    
505   }
506 }
507
508 //____________________________________________________________________________
509 void AliTPCQADataMakerRec::MakeRecPoints(TTree* recTree)
510 {
511   
512   AliTPCClustersRow* clrow = 0x0;
513   TBranch* branch = recTree->GetBranch("Segment");  
514   branch->SetAddress(&clrow);
515   TClonesArray * clarray = 0x0;
516
517   const Int_t nEntries = Int_t(recTree->GetEntries());
518   for (Int_t i = 0; i < nEntries; i++) {
519     
520     branch->GetEntry(i);
521
522     clarray = clrow->GetArray();
523
524     if (!clarray) continue;
525
526     const Int_t nClusters = clarray->GetEntriesFast();
527     for (Int_t icl=0; icl < nClusters; icl++){
528       
529       AliTPCclusterMI* cluster = 
530         (AliTPCclusterMI*)clarray->At(icl);
531       
532       Float_t Qmax = cluster->GetMax();
533       Float_t Q    = cluster->GetQ();
534       Int_t   row  = cluster->GetRow();
535
536       if(cluster->GetDetector()<36) { // IROC (short pads)
537
538         GetRecPointsData(kQmaxShort)->Fill(Qmax);
539         GetRecPointsData(kQShort)->Fill(Q);
540       } else { // OROC (medium and long pads)
541         row += 63;
542         if(cluster->GetRow()<64) { // medium pads
543
544           GetRecPointsData(kQmaxMedium)->Fill(Qmax);
545           GetRecPointsData(kQMedium)->Fill(Q);
546         } else { // long pads
547
548           GetRecPointsData(kQmaxLong)->Fill(Qmax);
549           GetRecPointsData(kQLong)->Fill(Q);
550         }
551       }
552       
553       GetRecPointsData(kRow)->Fill(row);
554     } // end loop over clusters
555   } // end loop over tree
556 }
557
558 //____________________________________________________________________________
559 void AliTPCQADataMakerRec::LoadMaps()
560 {
561   TString path = gSystem->Getenv("ALICE_ROOT");
562   path += "/TPC/mapping/Patch";
563
564   for(Int_t i = 0; i < 6; i++) {
565
566     if(fMapping[i]!=0) // mapping already loaded
567       continue;
568     TString path2 = path;
569     path2 += i;
570     path2 += ".data";
571     fMapping[i] = new AliTPCAltroMapping(path2.Data());
572   }
573 }
574
575 //____________________________________________________________________________
576 void AliTPCQADataMakerRec::ResetDetector(AliQAv1::TASKINDEX_t task)
577 {
578   // Overwrites general method for RAW data.
579   // The AliTPCdataQA elements that does the internal processing are
580   // in the case they have processed data deleted and new are created
581
582   if ( task != AliQAv1::kRAWS )
583     AliQADataMakerRec::ResetDetector(task);
584   
585   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
586     
587     if ( fTPCdataQA[specie] != NULL) { // exist
588       
589       if(fTPCdataQA[specie]->GetEventCounter()>0) { // has processed data
590         
591         // old configuration
592         Int_t  firstTime    = fTPCdataQA[specie]->GetFirstTimeBin();
593         Int_t  lastTime     = fTPCdataQA[specie]->GetLastTimeBin();
594         Int_t  minADC       = fTPCdataQA[specie]->GetAdcMin();
595         Int_t  maxADC       = fTPCdataQA[specie]->GetAdcMax();
596
597         //delete old
598         delete fTPCdataQA[specie]; 
599
600         // create new
601         fTPCdataQA[specie] = new AliTPCdataQA(AliRecoParam::ConvertIndex(specie));
602         // configure new
603         LoadMaps(); // Load Altro maps
604         fTPCdataQA[specie]->SetAltroMapping(fMapping);
605         fTPCdataQA[specie]->SetRangeTime(firstTime, lastTime);
606         fTPCdataQA[specie]->SetRangeAdc(minADC, maxADC);
607         // Here we want to restore the default configuration because
608         // the max events and events are adjusted for the last run
609         fTPCdataQA[specie]->SetMaxEvents(fRawMaxEvents);
610         fTPCdataQA[specie]->SetEventsPerBin(fRawEventsPerBin);
611       }
612     }
613   }
614 }
615
616 //____________________________________________________________________________
617 TH1F* AliTPCQADataMakerRec::CreateEventsHistCopy(const TH1F* hist, 
618                                                  const Char_t* copyName)
619 {
620   // This method is used to create a copy of the event histograms
621   
622   TH1F* histCopy = new TH1F(copyName, hist->GetTitle(),
623                             hist->GetXaxis()->GetNbins(),
624                             hist->GetXaxis()->GetXmin(), 
625                             hist->GetXaxis()->GetXmax());
626   histCopy->GetXaxis()->SetTitle(hist->GetXaxis()->GetTitle());
627   histCopy->GetYaxis()->SetTitle(hist->GetYaxis()->GetTitle());
628   histCopy->SetMarkerStyle(20);
629   histCopy->SetOption("P");
630   histCopy->SetStats(kFALSE);
631
632   return histCopy;
633 }