Transfer of the initialisation of the QA Data objects in the framework; clean the...
[u/mrichter/AliRoot.git] / STEER / AliQADataMakerRec.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, 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 notifce   *
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 //  Base Class
21 //  Produces the data needed to calculate the quality assurance for Reconstruction
22 //  All data must be mergeable objects.
23 //  Y. Schutz CERN July 2007
24 //
25
26 // --- ROOT system ---
27 #include <TCanvas.h>
28 #include <TFile.h>
29 #include <TTree.h>
30 #include <TNtupleD.h>
31 #include <TObjArray.h>
32
33 // --- Standard library ---
34
35 // --- AliRoot header files ---
36 #include "AliCDBPath.h"
37 #include "AliCDBEntry.h"
38 #include "AliDetectorRecoParam.h"
39 #include "AliCDBManager.h"
40
41 #include "AliLog.h"
42 #include "AliQADataMakerRec.h"
43 #include "AliESDEvent.h"
44 #include "AliRawReader.h"
45
46 ClassImp(AliQADataMakerRec)
47              
48 //____________________________________________________________________________ 
49 AliQADataMakerRec::AliQADataMakerRec(const char * name, const char * title) : 
50   AliQADataMaker(name, title), 
51   fDigitsQAList(NULL),
52   fESDsQAList(NULL), 
53   fRawsQAList(NULL), 
54   fRecPointsQAList(NULL),
55   fCorrNt(NULL), 
56   fRecoParam(NULL),
57   fRecPointsArray(NULL)
58 {
59   // ctor
60         fDetectorDirName = GetName() ; 
61 }
62
63 //____________________________________________________________________________ 
64 AliQADataMakerRec::AliQADataMakerRec(const AliQADataMakerRec& qadm) :
65   AliQADataMaker(qadm.GetName(), qadm.GetTitle()), 
66   fDigitsQAList(qadm.fDigitsQAList),
67   fESDsQAList(qadm.fESDsQAList),
68   fRawsQAList(qadm.fRawsQAList),
69   fRecPointsQAList(qadm.fRecPointsQAList),
70   fCorrNt(qadm.fCorrNt),  
71   fRecoParam(qadm.fRecoParam),
72   fRecPointsArray(NULL)
73 {
74   //copy ctor
75         SetName(qadm.GetName()) ; 
76         SetTitle(qadm.GetTitle()) ; 
77         fDetectorDirName = GetName() ; 
78 }
79
80 //____________________________________________________________________________ 
81 AliQADataMakerRec::~AliQADataMakerRec()
82 {
83         //dtor: delete the TObjArray and thei content
84         if ( fESDsQAList ) {
85     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
86       if ( fESDsQAList[specie] ) {
87         if ( fESDsQAList[specie]->IsOwner() ) 
88           fESDsQAList[specie]->Delete() ;     
89       }
90     }
91     delete[] fESDsQAList ;
92         }
93         if ( fRawsQAList ) {
94     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
95       if ( fRawsQAList[specie] ) {
96         if ( fRawsQAList[specie]->IsOwner() ) 
97           fRawsQAList[specie]->Delete() ;
98       }
99     }
100     delete[] fRawsQAList ;
101   }
102         if ( fDigitsQAList ) {
103     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
104       if ( fDigitsQAList[specie] ) {
105         if ( fDigitsQAList[specie]->IsOwner() ) 
106           fDigitsQAList[specie]->Delete() ;
107       }
108     }
109                 delete[] fDigitsQAList ; 
110   }
111         if ( fRecPointsQAList ) {
112     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
113       if ( fRecPointsQAList[specie] ) {
114         if ( fRecPointsQAList[specie]->IsOwner() ) 
115           fRecPointsQAList[specie]->Delete() ;
116       }
117     }
118                 delete[] fRecPointsQAList ; 
119   }
120   if (fRecPointsArray) {
121     fRecPointsArray->Clear() ; 
122     delete fRecPointsArray ; 
123   }
124 }
125
126 //__________________________________________________________________
127 AliQADataMakerRec& AliQADataMakerRec::operator = (const AliQADataMakerRec& qadm )
128 {
129   // Assignment operator.
130   this->~AliQADataMakerRec();
131   new(this) AliQADataMakerRec(qadm);
132   return *this;
133 }
134
135 //____________________________________________________________________________
136 void AliQADataMakerRec::EndOfCycle() 
137 {
138   // Finishes a cycle of QA for all the tasks
139   EndOfCycle(AliQAv1::kRAWS) ; 
140   EndOfCycle(AliQAv1::kDIGITSR) ; 
141   EndOfCycle(AliQAv1::kRECPOINTS) ; 
142   EndOfCycle(AliQAv1::kESDS) ; 
143   ResetCycle() ; 
144 }
145
146 //____________________________________________________________________________
147 void AliQADataMakerRec::EndOfCycle(AliQAv1::TASKINDEX_t task) 
148 {
149         // Finishes a cycle of QA 
150         
151         TObjArray ** list = NULL ; 
152         
153         if ( task == AliQAv1::kRAWS )     
154                 list = fRawsQAList ; 
155         else if ( task == AliQAv1::kDIGITSR ) 
156                 list = fDigitsQAList ; 
157         else if ( task == AliQAv1::kRECPOINTS ) 
158                 list = fRecPointsQAList ; 
159         else if ( task == AliQAv1::kESDS )
160                 list = fESDsQAList ; 
161
162  
163         if ( ! list && ! fCorrNt ) 
164     return ; 
165   //DefaultEndOfDetectorCycle(task) ;
166         EndOfDetectorCycle(task, list) ;
167   fDetectorDir = fOutput->GetDirectory(GetDetectorDirName()) ; 
168   if (!fDetectorDir)
169     fDetectorDir = fOutput->mkdir(GetDetectorDirName()) ; 
170   TDirectory * subDir = fDetectorDir->GetDirectory(AliQAv1::GetTaskName(task)) ; 
171   if (!subDir)
172     subDir = fDetectorDir->mkdir(AliQAv1::GetTaskName(task)) ;  
173   subDir->cd() ; 
174   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) { // skip Default
175     if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(specie)) || AliRecoParam::ConvertIndex(specie) == AliRecoParam::kDefault) 
176       continue ; 
177     TDirectory * eventSpecieDir = subDir->GetDirectory(AliRecoParam::GetEventSpecieName(specie)) ;
178     if (!eventSpecieDir) 
179       eventSpecieDir = subDir->mkdir(AliRecoParam::GetEventSpecieName(specie)) ; 
180     eventSpecieDir->cd() ;    
181     if (list[specie]) {
182       TIter next(list[specie]) ; 
183       TObject * obj ; 
184       while( (obj = next()) ) {
185         if (!obj->TestBit(AliQAv1::GetExpertBit()))
186           obj->Write() ;
187       }
188       if (WriteExpert()) {
189         TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQAv1::GetExpert()) ; 
190         if (!expertDir)
191           expertDir = eventSpecieDir->mkdir(AliQAv1::GetExpert()) ; 
192         expertDir->cd() ;
193         next.Reset() ; 
194         while( (obj = next()) ) {
195           if (!obj->TestBit(AliQAv1::GetExpertBit()))
196             continue ; 
197           obj->Write() ;
198         }      
199       }
200     }
201     if ( !fCorrNt )
202       continue ; 
203     if (fCorrNt[specie] && AliQAv1::GetDetIndex(GetName()) == AliQAv1::kCORR) {
204       eventSpecieDir->cd() ; 
205       fCorrNt[specie]->Write() ; 
206     }
207     fOutput->Save() ; 
208   }
209   MakeImage(task) ; 
210 }
211
212 //____________________________________________________________________________ 
213 void AliQADataMakerRec::MakeImage(AliQAv1::TASKINDEX_t task)
214 {
215   // create a drawing of detetor defined histograms
216   TObjArray ** list = NULL ;  
217   switch (task) {
218     case AliQAv1::kRAWS:
219       list = fRawsQAList ; 
220       break;
221     case AliQAv1::kHITS:
222       break;
223     case AliQAv1::kSDIGITS:
224       break;  
225     case AliQAv1::kDIGITS:
226       break;  
227     case AliQAv1::kDIGITSR:
228       list = fDigitsQAList ; 
229       break;  
230     case AliQAv1::kRECPOINTS:
231       list = fRecPointsQAList ; 
232       break;
233     case AliQAv1::kTRACKSEGMENTS:
234       break;
235     case AliQAv1::kRECPARTICLES:
236       break;
237     case AliQAv1::kESDS:
238       list = fESDsQAList ; 
239       break;
240     case AliQAv1::kNTASKINDEX:
241       break;
242     default:
243       break;
244   }
245   if ( !list) {
246     AliError("data not initialized, call AliQADataMaker::Init"); 
247     return ; 
248   }
249   MakeTheImage(list, task, "Rec") ; 
250 }
251
252 //____________________________________________________________________________
253 void AliQADataMakerRec::Exec(AliQAv1::TASKINDEX_t task, TObject * data) 
254
255   // creates the quality assurance data for the various tasks (Hits, SDigits, Digits, ESDs)
256         
257         if ( task == AliQAv1::kRAWS ) {
258                 AliDebug(AliQAv1::GetQADebugLevel(), "Processing Raws QA") ; 
259                 AliRawReader * rawReader = static_cast<AliRawReader *>(data) ; 
260                 if (rawReader) 
261                         MakeRaws(rawReader) ;
262                 else
263       AliDebug(AliQAv1::GetQADebugLevel(), "Raw data are not processed") ;     
264         } else if ( task == AliQAv1::kDIGITSR ) {
265                 AliDebug(AliQAv1::GetQADebugLevel(), "Processing Digits QA") ; 
266                 TTree * tree = static_cast<TTree *>(data) ; 
267                 if (strcmp(tree->ClassName(), "TTree") == 0) {
268                         MakeDigits(tree) ; 
269                 } else {
270                         AliWarning("data are not a TTree") ; 
271                 }
272         } else if ( task == AliQAv1::kRECPOINTS ) {
273                 AliDebug(AliQAv1::GetQADebugLevel(), "Processing RecPoints QA") ; 
274                 TTree * tree = static_cast<TTree *>(data) ; 
275                 if (strcmp(tree->ClassName(), "TTree") == 0) {
276                         MakeRecPoints(tree) ; 
277                 } else {
278                         AliWarning("data are not a TTree") ; 
279                 }
280         } else if ( task == AliQAv1::kESDS ) {
281                 AliDebug(AliQAv1::GetQADebugLevel(), "Processing ESDs QA") ; 
282                 AliESDEvent * esd = static_cast<AliESDEvent *>(data) ; 
283                 if (strcmp(esd->ClassName(), "AliESDEvent") == 0) 
284                         MakeESDs(esd) ;
285                 else 
286                         AliError("Wrong type of esd container") ; 
287         }  
288 }
289
290 //____________________________________________________________________________ 
291 TObjArray **  AliQADataMakerRec::Init(AliQAv1::TASKINDEX_t task, Int_t cycles)
292 {
293   // general intialisation
294   InitRecoParams() ;
295         TObjArray ** rv = NULL ; 
296   
297         if (cycles > 0)
298                 SetCycle(cycles) ;  
299         
300         if ( task == AliQAv1::kRAWS ) {
301                 if (! fRawsQAList ) { 
302       fRawsQAList = new TObjArray *[AliRecoParam::kNSpecies] ; 
303       for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
304         fRawsQAList[specie] = new TObjArray(AliQAv1::GetMaxQAObj()) ;    
305         fRawsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
306       }
307                 }
308                 rv = fRawsQAList ;
309         } else if ( task == AliQAv1::kDIGITSR ) {
310                 if ( ! fDigitsQAList ) {
311       fDigitsQAList = new TObjArray *[AliRecoParam::kNSpecies] ; 
312       for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
313         fDigitsQAList[specie] = new TObjArray(AliQAv1::GetMaxQAObj()) ; 
314         fDigitsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ; 
315       }
316                 }
317                 rv = fDigitsQAList ;
318         } else if ( task == AliQAv1::kRECPOINTS ) {
319                 if ( ! fRecPointsQAList ) {
320       fRecPointsQAList = new TObjArray *[AliRecoParam::kNSpecies] ; 
321       for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
322         fRecPointsQAList[specie] = new TObjArray(AliQAv1::GetMaxQAObj()) ; 
323         fRecPointsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ; 
324       }
325     }
326                 rv = fRecPointsQAList ;
327         } else if ( task == AliQAv1::kESDS ) {
328                 if ( ! fESDsQAList ) {
329       fESDsQAList = new TObjArray *[AliRecoParam::kNSpecies] ; 
330       for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
331         fESDsQAList[specie] = new TObjArray(AliQAv1::GetMaxQAObj()) ;
332         fESDsQAList[specie]->SetName(Form("%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ; 
333       }
334                 }
335                 rv = fESDsQAList ;
336         }
337         return rv ; 
338 }
339
340 //____________________________________________________________________________ 
341 void AliQADataMakerRec::Init(AliQAv1::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles)
342 {
343   // Intialisation by passing the list of QA data booked elsewhere
344   
345   InitRecoParams() ;
346   fRun = run ;
347         if (cycles > 0)
348                 SetCycle(cycles) ;  
349         
350         if ( task == AliQAv1::kRAWS ) {
351                 fRawsQAList = list ;     
352         } else if ( task == AliQAv1::kDIGITSR ) {
353                 fDigitsQAList = list ; 
354         } else if ( task == AliQAv1::kRECPOINTS ) {
355                 fRecPointsQAList = list ; 
356         } else if ( task == AliQAv1::kESDS ) {
357                 fESDsQAList = list ; 
358         }
359 }
360
361 //____________________________________________________________________________
362 void AliQADataMakerRec::InitRecoParams() 
363 {
364   if (!fRecoParam) {
365     AliDebug(AliQAv1::GetQADebugLevel(), Form("Loading reconstruction parameter objects for detector %s", GetName()));
366     AliCDBPath path(GetName(),"Calib","RecoParam");
367     AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
368     if(!entry) {
369       fRecoParam = NULL ; 
370       AliWarning(Form("Couldn't find RecoParam entry in OCDB for detector %s",GetName()));
371     }
372     else {
373       TObject * recoParamObj = entry->GetObject() ; 
374       if ( strcmp(recoParamObj->ClassName(), "TObjArray") == 0 ) {
375         // The detector has only one set of reco parameters
376         AliDebug(AliQAv1::GetQADebugLevel(), Form("Array of reconstruction parameters found for detector %s",GetName()));
377         TObjArray *recoParamArray = static_cast<TObjArray*>(recoParamObj) ;
378         for (Int_t iRP=0; iRP<recoParamArray->GetEntriesFast(); iRP++) {
379           fRecoParam = static_cast<AliDetectorRecoParam*>(recoParamArray->At(iRP)) ;
380           if (!fRecoParam) 
381             break ; 
382           else if (fRecoParam->IsDefault()) 
383             break ; 
384         }
385       }
386       else if (recoParamObj->InheritsFrom("AliDetectorRecoParam")) {
387         // The detector has only one set of reco parameters
388         // Registering it in AliRecoParam
389         AliDebug(AliQAv1::GetQADebugLevel(), Form("Single set of reconstruction parameters found for detector %s",GetName()));
390         fRecoParam = static_cast<AliDetectorRecoParam*>(recoParamObj) ;
391         static_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
392       } else { 
393         AliError(Form("No valid RecoParam object found in the OCDB for detector %s",GetName()));
394       }
395     }
396     AliCDBManager::Instance()->UnloadFromCache(path.GetPath());
397   }
398 }
399
400 //____________________________________________________________________________
401 void AliQADataMakerRec::StartOfCycle(Int_t run) 
402 {
403   // Finishes a cycle of QA for all the tasks
404   Bool_t samecycle = kFALSE ; 
405   StartOfCycle(AliQAv1::kRAWS,      run, samecycle) ;
406   samecycle = kTRUE ; 
407   StartOfCycle(AliQAv1::kDIGITSR,   run, samecycle) ; 
408   StartOfCycle(AliQAv1::kRECPOINTS, run, samecycle) ; 
409   StartOfCycle(AliQAv1::kESDS,      run, samecycle) ; 
410 }
411
412 //____________________________________________________________________________
413 void AliQADataMakerRec::StartOfCycle(AliQAv1::TASKINDEX_t task, Int_t run, const Bool_t sameCycle) 
414
415   // Finishes a cycle of QA data acquistion
416   if ( run > 0 ) 
417     fRun = run ; 
418         if ( !sameCycle || fCurrentCycle == -1) {
419                 ResetCycle() ;
420                 if (fOutput) 
421                         fOutput->Close() ; 
422                 fOutput = AliQAv1::GetQADataFile(GetName(), fRun) ;     
423         }       
424         AliDebug(AliQAv1::GetQADebugLevel(), Form(" Run %d Cycle %d task %s file %s", 
425                                  fRun, fCurrentCycle, AliQAv1::GetTaskName(task).Data(), fOutput->GetName() )) ;
426
427 //      fDetectorDir = fOutput->GetDirectory(GetDetectorDirName()) ; 
428 //      if (!fDetectorDir)
429 //              fDetectorDir = fOutput->mkdir(GetDetectorDirName()) ; 
430 //  
431 //      TDirectory * subDir = fDetectorDir->GetDirectory(AliQAv1::GetTaskName(task)) ; 
432 //      if (!subDir)
433 //              subDir = fDetectorDir->mkdir(AliQAv1::GetTaskName(task)) ;  
434 //  
435 //  for ( Int_t specie = AliRecoParam::kDefault ; specie < AliRecoParam::kNSpecies ; specie++ ) {
436 //    TDirectory * eventSpecieDir = subDir->GetDirectory(AliRecoParam::GetEventSpecieName(specie)) ; 
437 //    if (!eventSpecieDir) 
438 //      eventSpecieDir = subDir->mkdir(AliRecoParam::GetEventSpecieName(specie)) ; 
439 //    TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQAv1::GetExpert()) ; 
440 //    if (!expertDir)
441 //      expertDir = eventSpecieDir->mkdir(AliQAv1::GetExpert()) ; 
442 //  } 
443         StartOfDetectorCycle() ; 
444 }