Processing SPD Mean Vertex only in PHYSICS runs.
[u/mrichter/AliRoot.git] / STEER / AliQADataMakerRec.cxx
index e2a1198..f400185 100644 (file)
@@ -7,7 +7,7 @@
  * Permission to use, copy, modify and distribute this software and its   *
  * documentation strictly for non-commercial purposes is hereby granted   *
  * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
+ * copies and that both the copyright notice and this permission notifce   *
  * appear in the supporting documentation. The authors make no claims     *
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
 
 /* $Id$ */
 
-/*
-  Base Class
-  Produces the data needed to calculate the quality assurance for Reconstruction
-  All data must be mergeable objects.
-  Y. Schutz CERN July 2007
-*/
+//
+//  Base Class
+//  Produces the data needed to calculate the quality assurance for Reconstruction
+//  All data must be mergeable objects.
+//  Y. Schutz CERN July 2007
+//
 
 // --- ROOT system ---
-#include <TSystem.h> 
 #include <TFile.h>
-#include <TList.h> 
 #include <TTree.h>
-#include <TClonesArray.h>
+#include <TNtupleD.h>
+#include <TObjArray.h>
 
 // --- Standard library ---
 
 // --- AliRoot header files ---
+#include "AliCDBPath.h"
+#include "AliCDBEntry.h"
+#include "AliDetectorRecoParam.h"
+#include "AliCDBManager.h"
+
 #include "AliLog.h"
 #include "AliQADataMakerRec.h"
-#include "AliQAChecker.h"
+#include "AliQAManager.h"
 #include "AliESDEvent.h"
 #include "AliRawReader.h"
 
@@ -44,9 +48,13 @@ ClassImp(AliQADataMakerRec)
 //____________________________________________________________________________ 
 AliQADataMakerRec::AliQADataMakerRec(const char * name, const char * title) : 
   AliQADataMaker(name, title), 
-  fESDsQAList(0x0), 
-  fRawsQAList(0x0), 
-  fRecPointsQAList(0x0)
+  fDigitsQAList(NULL),
+  fESDsQAList(NULL), 
+  fRawsQAList(NULL), 
+  fRecPointsQAList(NULL),
+  fCorrNt(NULL), 
+  fRecoParam(NULL),
+  fRecPointsArray(NULL)
 {
   // ctor
        fDetectorDirName = GetName() ; 
@@ -54,11 +62,14 @@ AliQADataMakerRec::AliQADataMakerRec(const char * name, const char * title) :
 
 //____________________________________________________________________________ 
 AliQADataMakerRec::AliQADataMakerRec(const AliQADataMakerRec& qadm) :
-    AliQADataMaker(qadm.GetName(), qadm.GetTitle()), 
-    fESDsQAList(qadm.fESDsQAList),
-       fRawsQAList(qadm.fRawsQAList),
-       fRecPointsQAList(qadm.fRecPointsQAList)
-  
+  AliQADataMaker(qadm.GetName(), qadm.GetTitle()), 
+  fDigitsQAList(qadm.fDigitsQAList),
+  fESDsQAList(qadm.fESDsQAList),
+  fRawsQAList(qadm.fRawsQAList),
+  fRecPointsQAList(qadm.fRecPointsQAList),
+  fCorrNt(qadm.fCorrNt),  
+  fRecoParam(qadm.fRecoParam),
+  fRecPointsArray(NULL)
 {
   //copy ctor
        SetName(qadm.GetName()) ; 
@@ -66,6 +77,52 @@ AliQADataMakerRec::AliQADataMakerRec(const AliQADataMakerRec& qadm) :
        fDetectorDirName = GetName() ; 
 }
 
+//____________________________________________________________________________ 
+AliQADataMakerRec::~AliQADataMakerRec()
+{
+       //dtor: delete the TObjArray and thei content
+       if ( fESDsQAList ) {
+    for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+      if ( fESDsQAList[specie] ) {
+        if ( fESDsQAList[specie]->IsOwner() ) 
+          fESDsQAList[specie]->Delete() ;     
+      }
+    }
+    delete[] fESDsQAList ;
+       }
+       if ( fRawsQAList ) {
+    for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+      if ( fRawsQAList[specie] ) {
+        if ( fRawsQAList[specie]->IsOwner() ) 
+          fRawsQAList[specie]->Delete() ;
+      }
+    }
+    delete[] fRawsQAList ;
+  }
+       if ( fDigitsQAList ) {
+    for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+      if ( fDigitsQAList[specie] ) {
+        if ( fDigitsQAList[specie]->IsOwner() ) 
+          fDigitsQAList[specie]->Delete() ;
+      }
+    }
+               delete[] fDigitsQAList ; 
+  }
+       if ( fRecPointsQAList ) {
+    for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+      if ( fRecPointsQAList[specie] ) {
+        if ( fRecPointsQAList[specie]->IsOwner() ) 
+          fRecPointsQAList[specie]->Delete() ;
+      }
+    }
+               delete[] fRecPointsQAList ; 
+  }
+  if (fRecPointsArray) {
+    fRecPointsArray->Clear() ; 
+    delete fRecPointsArray ; 
+  }
+}
+
 //__________________________________________________________________
 AliQADataMakerRec& AliQADataMakerRec::operator = (const AliQADataMakerRec& qadm )
 {
@@ -76,51 +133,120 @@ AliQADataMakerRec& AliQADataMakerRec::operator = (const AliQADataMakerRec& qadm
 }
 
 //____________________________________________________________________________
-void AliQADataMakerRec::EndOfCycle(AliQA::TASKINDEX task) 
+void AliQADataMakerRec::EndOfCycle() 
 {
-       // Finishes a cycle of QA data acquistion
+  // Finishes a cycle of QA for all the tasks
+  EndOfCycle(AliQAv1::kRAWS) ; 
+  EndOfCycle(AliQAv1::kDIGITSR) ; 
+  EndOfCycle(AliQAv1::kRECPOINTS) ; 
+  EndOfCycle(AliQAv1::kESDS) ; 
+  ResetCycle() ; 
+}
+
+//____________________________________________________________________________
+void AliQADataMakerRec::EndOfCycle(AliQAv1::TASKINDEX_t task) 
+{
+       // Finishes a cycle of QA 
        
-       TObjArray * list = 0x0 ; 
+    
+  TObjArray ** list = NULL ; 
        
-       if ( task == AliQA::kRAWS )     
+       if ( task == AliQAv1::kRAWS )     
                list = fRawsQAList ; 
-       else if ( task == AliQA::kRECPOINTS ) 
+       else if ( task == AliQAv1::kDIGITSR ) 
+               list = fDigitsQAList ; 
+       else if ( task == AliQAv1::kRECPOINTS ) 
                list = fRecPointsQAList ; 
-       else if ( task == AliQA::kESDS )
+       else if ( task == AliQAv1::kESDS )
                list = fESDsQAList ; 
-       
-       EndOfDetectorCycle(task, list) ; 
-       TDirectory * subDir = fDetectorDir->GetDirectory(AliQA::GetTaskName(task)) ; 
-       if ( subdir ) {
-               subDir->cd() ; 
-               list->Write() ;
-       }
-}
+
  
+       if ( ! list && ! fCorrNt ) 
+    return ; 
+  //DefaultEndOfDetectorCycle(task) ;
+       EndOfDetectorCycle(task, list) ;
+  
+  if (! AliQAManager::QAManager(AliQAv1::kRECMODE)->IsSaveData())
+    return ; 
+
+  fDetectorDir = fOutput->GetDirectory(GetDetectorDirName()) ; 
+  if (!fDetectorDir)
+    fDetectorDir = fOutput->mkdir(GetDetectorDirName()) ; 
+  TDirectory * subDir = fDetectorDir->GetDirectory(AliQAv1::GetTaskName(task)) ; 
+  if (!subDir)
+    subDir = fDetectorDir->mkdir(AliQAv1::GetTaskName(task)) ;  
+  subDir->cd() ; 
+  for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) { // skip Default
+    if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(specie)) || AliRecoParam::ConvertIndex(specie) == AliRecoParam::kDefault) 
+      continue ; 
+    TDirectory * eventSpecieDir = subDir->GetDirectory(AliRecoParam::GetEventSpecieName(specie)) ;
+    if (!eventSpecieDir) 
+      eventSpecieDir = subDir->mkdir(AliRecoParam::GetEventSpecieName(specie)) ; 
+    eventSpecieDir->cd() ;    
+    if (list) {
+      if (list[specie]) {
+        TIter next(list[specie]) ; 
+        TObject * obj ; 
+        while( (obj = next()) ) {
+          if (!obj->TestBit(AliQAv1::GetExpertBit()))
+            obj->Write() ;
+        }
+        if (WriteExpert()) {
+          TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQAv1::GetExpert()) ; 
+          if (!expertDir)
+            expertDir = eventSpecieDir->mkdir(AliQAv1::GetExpert()) ; 
+          expertDir->cd() ;
+          next.Reset() ; 
+          while( (obj = next()) ) {
+            if (!obj->TestBit(AliQAv1::GetExpertBit()))
+              continue ; 
+            obj->Write() ;
+          }      
+        }
+      }
+    } 
+    else if ( fCorrNt ) {
+      if (fCorrNt[specie] && AliQAv1::GetDetIndex(GetName()) == AliQAv1::kCORR) {
+        eventSpecieDir->cd() ; 
+        fCorrNt[specie]->Write() ; 
+      }
+      fOutput->Save() ; 
+    }
+  }
+}
+
 //____________________________________________________________________________
-void AliQADataMakerRec::Exec(AliQA::TASKINDEX task, TObject * data) 
+void AliQADataMakerRec::Exec(AliQAv1::TASKINDEX_t task, TObject * data) 
 { 
   // creates the quality assurance data for the various tasks (Hits, SDigits, Digits, ESDs)
        
-       if ( task == AliQA::kRAWS ) {
-               AliDebug(1, "Processing Raws QA") ; 
-               AliRawReader * rawReader = dynamic_cast<AliRawReader *>(data) ; 
+       if ( task == AliQAv1::kRAWS ) {
+               AliDebug(AliQAv1::GetQADebugLevel(), "Processing Raws QA") ; 
+               AliRawReader * rawReader = static_cast<AliRawReader *>(data) ; 
                if (rawReader) 
                        MakeRaws(rawReader) ;
                else
-               AliError("Wrong data type") ;     
-       } else if ( task == AliQA::kRECPOINTS ) {
-               AliDebug(1, "Processing RecPoints QA") ; 
-               TTree * tree = dynamic_cast<TTree *>(data) ; 
-               if (tree) {
+      AliDebug(AliQAv1::GetQADebugLevel(), "Raw data are not processed") ;     
+       } else if ( task == AliQAv1::kDIGITSR ) {
+               AliDebug(AliQAv1::GetQADebugLevel(), "Processing Digits QA") ; 
+               TTree * tree = static_cast<TTree *>(data) ; 
+               if (strcmp(tree->ClassName(), "TTree") == 0) {
+                       MakeDigits(tree) ; 
+               } else {
+                       AliWarning("data are not a TTree") ; 
+               }
+       } else if ( task == AliQAv1::kRECPOINTS ) {
+               AliDebug(AliQAv1::GetQADebugLevel(), "Processing RecPoints QA") ; 
+               TTree * tree = static_cast<TTree *>(data) ; 
+               if (strcmp(tree->ClassName(), "TTree") == 0) {
                        MakeRecPoints(tree) ; 
                } else {
                        AliWarning("data are not a TTree") ; 
                }
-       } else if ( task == AliQA::kESDS ) {
-               AliDebug(1, "Processing ESDs QA") ; 
-               AliESDEvent * esd = dynamic_cast<AliESDEvent *>(data) ; 
-               if (esd) 
+       } else if ( task == AliQAv1::kESDS ) {
+               AliDebug(AliQAv1::GetQADebugLevel(), "Processing ESDs QA") ; 
+               AliESDEvent * esd = static_cast<AliESDEvent *>(data) ; 
+               if (strcmp(esd->ClassName(), "AliESDEvent") == 0) 
                        MakeESDs(esd) ;
                else 
                        AliError("Wrong type of esd container") ; 
@@ -128,87 +254,188 @@ void AliQADataMakerRec::Exec(AliQA::TASKINDEX task, TObject * data)
 }
 
 //____________________________________________________________________________ 
-TObjArray *  AliQADataMakerRec::Init(AliQA::TASKINDEX task, Int_t run, Int_t cycles)
+TObjArray **  AliQADataMakerRec::Init(AliQAv1::TASKINDEX_t task, Int_t cycles)
 {
   // general intialisation
-       
-       TObjArray * rv = NULL ; 
+  InitRecoParams() ;
+       TObjArray ** rv = NULL ; 
   
-       fRun = run ;
        if (cycles > 0)
                SetCycle(cycles) ;  
        
-       if ( task == AliQA::kRAWS ) {
-               fRawsQAList = new TObjArray(100) ;       
-               InitRaws() ;
+       if ( task == AliQAv1::kRAWS ) {
+               if (! fRawsQAList ) { 
+      fRawsQAList = new TObjArray *[AliRecoParam::kNSpecies] ; 
+      for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+        fRawsQAList[specie] = new TObjArray(AliQAv1::GetMaxQAObj()) ;   
+        fRawsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
+      }
+               }
                rv = fRawsQAList ;
-       } else if ( task == AliQA::kRECPOINTS ) {
-               fRecPointsQAList = new TObjArray(100) ; 
-               InitRecPoints() ;
+       } else if ( task == AliQAv1::kDIGITSR ) {
+               if ( ! fDigitsQAList ) {
+      fDigitsQAList = new TObjArray *[AliRecoParam::kNSpecies] ; 
+      for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+        fDigitsQAList[specie] = new TObjArray(AliQAv1::GetMaxQAObj()) ; 
+        fDigitsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ; 
+      }
+               }
+               rv = fDigitsQAList ;
+       } else if ( task == AliQAv1::kRECPOINTS ) {
+               if ( ! fRecPointsQAList ) {
+      fRecPointsQAList = new TObjArray *[AliRecoParam::kNSpecies] ; 
+      for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+        fRecPointsQAList[specie] = new TObjArray(AliQAv1::GetMaxQAObj()) ; 
+        fRecPointsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ; 
+      }
+    }
                rv = fRecPointsQAList ;
-       } else if ( task == AliQA::kESDS ) {
-               fESDsQAList = new TObjArray(100) ; 
-               InitESDs() ;
+       } else if ( task == AliQAv1::kESDS ) {
+               if ( ! fESDsQAList ) {
+      fESDsQAList = new TObjArray *[AliRecoParam::kNSpecies] ; 
+      for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+        fESDsQAList[specie] = new TObjArray(AliQAv1::GetMaxQAObj()) ;
+        fESDsQAList[specie]->SetName(Form("%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ; 
+      }
+               }
                rv = fESDsQAList ;
        }
-       
        return rv ; 
 }
 
 //____________________________________________________________________________ 
-void AliQADataMakerRec::Init(AliQA::TASKINDEX task, TObjArray * list, Int_t run, Int_t cycles)
+void AliQADataMakerRec::Init(AliQAv1::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles)
 {
   // Intialisation by passing the list of QA data booked elsewhere
   
-       fRun = run ;
+  InitRecoParams() ;
+  fRun = run ;
        if (cycles > 0)
                SetCycle(cycles) ;  
        
-       if ( task == AliQA::kRAWS ) {
+       if ( task == AliQAv1::kRAWS ) {
                fRawsQAList = list ;     
-       } else if ( task == AliQA::kRECPOINTS ) {
+       } else if ( task == AliQAv1::kDIGITSR ) {
+               fDigitsQAList = list ; 
+       } else if ( task == AliQAv1::kRECPOINTS ) {
                fRecPointsQAList = list ; 
-       } else if ( task == AliQA::kESDS ) {
+       } else if ( task == AliQAv1::kESDS ) {
                fESDsQAList = list ; 
        }
 }
 
 //____________________________________________________________________________
-void AliQADataMakerRec::StartOfCycle(AliQA::TASKINDEX task, const Bool_t sameCycle) 
+void AliQADataMakerRec::InitRecoParams() 
+{
+  if (!fRecoParam) {
+    AliDebug(AliQAv1::GetQADebugLevel(), Form("Loading reconstruction parameter objects for detector %s", GetName()));
+    AliCDBPath path(GetName(),"Calib","RecoParam");
+    AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
+    if(!entry) {
+      fRecoParam = NULL ; 
+      AliDebug(AliQAv1::GetQADebugLevel(), Form("Couldn't find RecoParam entry in OCDB for detector %s",GetName()));
+    }
+    else {
+      TObject * recoParamObj = entry->GetObject() ; 
+      if ( strcmp(recoParamObj->ClassName(), "TObjArray") == 0 ) {
+        // The detector has only one set of reco parameters
+        AliDebug(AliQAv1::GetQADebugLevel(), Form("Array of reconstruction parameters found for detector %s",GetName()));
+        TObjArray *recoParamArray = static_cast<TObjArray*>(recoParamObj) ;
+        for (Int_t iRP=0; iRP<recoParamArray->GetEntriesFast(); iRP++) {
+          fRecoParam = static_cast<AliDetectorRecoParam*>(recoParamArray->At(iRP)) ;
+          if (!fRecoParam) 
+            break ; 
+          else if (fRecoParam->IsDefault()) 
+            break ; 
+        }
+      }
+      else if (recoParamObj->InheritsFrom("AliDetectorRecoParam")) {
+        // The detector has only one set of reco parameters
+        // Registering it in AliRecoParam
+        AliDebug(AliQAv1::GetQADebugLevel(), Form("Single set of reconstruction parameters found for detector %s",GetName()));
+        fRecoParam = static_cast<AliDetectorRecoParam*>(recoParamObj) ;
+        static_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
+      } else { 
+        AliError(Form("No valid RecoParam object found in the OCDB for detector %s",GetName()));
+      }
+    }
+  }
+}
+
+//____________________________________________________________________________ 
+void AliQADataMakerRec::ResetDetector(AliQAv1::TASKINDEX_t task)
+{
+    // default reset that resets all the QA objects.
+    // to be overloaded by detectors, if necessary
+
+  TObjArray ** list = NULL ; 
+  if ( task == AliQAv1::kRAWS ) {
+               list = fRawsQAList ;     
+       } else if ( task == AliQAv1::kDIGITSR ) {
+               list = fDigitsQAList ; 
+       } else if ( task == AliQAv1::kRECPOINTS ) {
+               list = fRecPointsQAList ; 
+       } else if ( task == AliQAv1::kESDS ) {
+               list = fESDsQAList ; 
+       }
+    //list was not initialized, skip
+  if (!list) 
+    return ; 
+  
+  for (int spec = 0; spec < AliRecoParam::kNSpecies; spec++) {
+    if (!AliQAv1::Instance()->IsEventSpecieSet(AliRecoParam::ConvertIndex(spec)))
+      continue;
+    TIter next(list[spec]) ; 
+    TH1 * histo = NULL ; 
+    while ( (histo = dynamic_cast<TH1*> (next())) ) {
+      histo->Reset() ;
+    }
+  }
+}
+
+//____________________________________________________________________________
+void AliQADataMakerRec::StartOfCycle(Int_t run) 
+{
+  // Finishes a cycle of QA for all the tasks
+  Bool_t samecycle = kFALSE ; 
+  StartOfCycle(AliQAv1::kRAWS,      run, samecycle) ;
+  samecycle = kTRUE ; 
+  StartOfCycle(AliQAv1::kDIGITSR,   run, samecycle) ; 
+  StartOfCycle(AliQAv1::kRECPOINTS, run, samecycle) ; 
+  StartOfCycle(AliQAv1::kESDS,      run, samecycle) ; 
+}
+
+//____________________________________________________________________________
+void AliQADataMakerRec::StartOfCycle(AliQAv1::TASKINDEX_t task, Int_t run, const Bool_t sameCycle) 
 { 
   // Finishes a cycle of QA data acquistion
+  if ( run > 0 ) 
+    fRun = run ; 
        if ( !sameCycle || fCurrentCycle == -1) {
                ResetCycle() ;
                if (fOutput) 
                        fOutput->Close() ; 
-               fOutput = AliQA::GetQADataFile(GetName(), fRun, fCurrentCycle) ;        
+               if (AliQAManager::QAManager(AliQAv1::kRECMODE)->IsSaveData())
+      fOutput = AliQAv1::GetQADataFile(GetName(), fRun) ;      
        }       
-       AliInfo(Form(" Run %d Cycle %d task %s file %s", 
-                                fRun, fCurrentCycle, AliQA::GetTaskName(task).Data(), fOutput->GetName() )) ;
-
-       fDetectorDir = fOutput->GetDirectory(GetDetectorDirName()) ; 
-       if (!fDetectorDir)
-               fDetectorDir = fOutput->mkdir(GetDetectorDirName()) ; 
-
-       TDirectory * subDir = fDetectorDir->GetDirectory(AliQA::GetTaskName(task)) ; 
-       if (!subDir)
-               subDir = fDetectorDir->mkdir(AliQA::GetTaskName(task)) ;  
-       subDir->cd() ; 
-
-       TObjArray * list = 0x0 ; 
-  
-  if ( task == AliQA::kRAWS ) 
-         list = fRawsQAList ; 
-  else if ( task == AliQA::kRECPOINTS)  
-         list = fRecPointsQAList ;
-  else if ( task == AliQA::kESDS )  
-         list = fESDsQAList ;
-
-       TIter next(list) ;
-       TH1 * h ; 
-       while ( (h = dynamic_cast<TH1 *>(next())) )
-               h->Reset() ;  
+       AliDebug(AliQAv1::GetQADebugLevel(), Form(" Run %d Cycle %d task %s file %s", 
+                                fRun, fCurrentCycle, AliQAv1::GetTaskName(task).Data(), fOutput->GetName() )) ;
 
+//     fDetectorDir = fOutput->GetDirectory(GetDetectorDirName()) ; 
+//     if (!fDetectorDir)
+//             fDetectorDir = fOutput->mkdir(GetDetectorDirName()) ; 
+//  
+//     TDirectory * subDir = fDetectorDir->GetDirectory(AliQAv1::GetTaskName(task)) ; 
+//     if (!subDir)
+//             subDir = fDetectorDir->mkdir(AliQAv1::GetTaskName(task)) ;  
+//  
+//  for ( Int_t specie = AliRecoParam::kDefault ; specie < AliRecoParam::kNSpecies ; specie++ ) {
+//    TDirectory * eventSpecieDir = subDir->GetDirectory(AliRecoParam::GetEventSpecieName(specie)) ; 
+//    if (!eventSpecieDir) 
+//      eventSpecieDir = subDir->mkdir(AliRecoParam::GetEventSpecieName(specie)) ; 
+//    TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQAv1::GetExpert()) ; 
+//    if (!expertDir)
+//      expertDir = eventSpecieDir->mkdir(AliQAv1::GetExpert()) ; 
+//  } 
        StartOfDetectorCycle() ; 
 }