Make and print an image of QA user flagged histograms (Yves)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 8 May 2009 08:21:01 +0000 (08:21 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 8 May 2009 08:21:01 +0000 (08:21 +0000)
40 files changed:
ACORDE/AliACORDEQADataMakerRec.cxx
ACORDE/AliACORDEQADataMakerSim.cxx
EMCAL/AliEMCALQADataMakerRec.cxx
EMCAL/AliEMCALQADataMakerSim.cxx
FMD/AliFMDQADataMakerRec.cxx
FMD/AliFMDQADataMakerSim.cxx
HMPID/AliHMPIDQADataMakerRec.cxx
HMPID/AliHMPIDQADataMakerSim.cxx
ITS/AliITSQASDDDataMakerRec.cxx
ITS/AliITSQASDDDataMakerSim.cxx
ITS/AliITSQASPDDataMakerRec.cxx
ITS/AliITSQASPDDataMakerSim.cxx
ITS/AliITSQASSDDataMakerRec.cxx
ITS/AliITSQASSDDataMakerSim.cxx
MUON/AliMUONQADataMakerRec.cxx
MUON/AliMUONQADataMakerSim.cxx
PHOS/AliPHOSQADataMakerRec.cxx
PHOS/AliPHOSQADataMakerSim.cxx
PMD/AliPMDQADataMakerRec.cxx
PMD/AliPMDQADataMakerSim.cxx
STEER/AliQADataMaker.cxx
STEER/AliQADataMaker.h
STEER/AliQADataMakerRec.cxx
STEER/AliQADataMakerRec.h
STEER/AliQADataMakerSim.cxx
STEER/AliQADataMakerSim.h
STEER/AliQAv1.cxx
STEER/AliQAv1.h
T0/AliT0QADataMakerRec.cxx
T0/AliT0QADataMakerSim.cxx
TOF/AliTOFQADataMakerRec.cxx
TOF/AliTOFQADataMakerSim.cxx
TPC/AliTPCQADataMakerRec.cxx
TPC/AliTPCQADataMakerSim.cxx
TRD/AliTRDQADataMakerRec.cxx
TRD/AliTRDQADataMakerSim.cxx
VZERO/AliVZEROQADataMakerRec.cxx
VZERO/AliVZEROQADataMakerSim.cxx
ZDC/AliZDCQADataMakerRec.cxx
ZDC/AliZDCQADataMakerSim.cxx

index 3b785bf..9203890 100755 (executable)
@@ -85,15 +85,17 @@ void AliACORDEQADataMakerRec::InitRaws()
 {
   // create Raw histograms in Raw subdir
 
-TH1D *fhACORDEBitPattern[4];
-fhACORDEBitPattern[0] = new TH1D("ACORDERawDataSM","ACORDE-SingleMuon",60,1,60);//AcordeSingleMuon BitPattern
-fhACORDEBitPattern[1] = new TH1D("ACORDERawDataMM","ACORDE-MultiMuon",60,1,60);//AcordeMultiMuon BitPattern
-fhACORDEBitPattern[2] = new TH1D("ACORDERawDataSMM","ACORDE-SingleMuonMultiplicity",60,1,60);//AcordeSingleMuon Multiplicity
-fhACORDEBitPattern[3] = new TH1D("ACORDERawDataMMM","ACORDE-MultiMuonMultiplicity",60,1,60);//AcordeMultiMuon Multiplicity
-for(Int_t i=0;i<4;i++)
-{
-       Add2RawsList(fhACORDEBitPattern[i],i,kFALSE);
-}
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t saveCorr = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  TH1D *fhACORDEBitPattern[4];
+  fhACORDEBitPattern[0] = new TH1D("ACORDERawDataSM","ACORDE-SingleMuon",60,1,60);//AcordeSingleMuon BitPattern
+  fhACORDEBitPattern[1] = new TH1D("ACORDERawDataMM","ACORDE-MultiMuon",60,1,60);//AcordeMultiMuon BitPattern
+  fhACORDEBitPattern[2] = new TH1D("ACORDERawDataSMM","ACORDE-SingleMuonMultiplicity",60,1,60);//AcordeSingleMuon Multiplicity
+  fhACORDEBitPattern[3] = new TH1D("ACORDERawDataMMM","ACORDE-MultiMuonMultiplicity",60,1,60);//AcordeMultiMuon Multiplicity
+  for(Int_t i=0;i<4;i++) 
+    Add2RawsList(fhACORDEBitPattern[i],i,!expert, image, !saveCorr);
 }
 //____________________________________________________________________________ 
 
@@ -107,18 +109,21 @@ void AliACORDEQADataMakerRec::InitESDs()
 {
   //create ESDs histograms in ESDs subdir
 
-   TH1F *    fhESDsSingle;
-   TH1F *    fhESDsMulti;
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  TH1F *    fhESDsSingle;
+  TH1F *    fhESDsMulti;
 
    TString   name;
 
    name = "hESDsSingle";
    fhESDsSingle = new TH1F(name.Data(),"hESDsSingle",60,0,60);
-   Add2ESDsList(fhESDsSingle,0,kFALSE);
+   Add2ESDsList(fhESDsSingle,0,!expert,image);
 
    name = "hESDsMulti";
    fhESDsMulti = new TH1F(name.Data(),"hESDsMulti",60,0,60);
-   Add2ESDsList(fhESDsMulti,1,kFALSE);
+   Add2ESDsList(fhESDsMulti,1,!expert,image);
 }
 //____________________________________________________________________________
 void AliACORDEQADataMakerRec::MakeRaws(AliRawReader* rawReader)
index 6ebe597..887aaf0 100755 (executable)
@@ -87,20 +87,26 @@ void AliACORDEQADataMakerSim::InitHits()
 {
   // create Hits histograms in Hits subdir
        
-       TH1F *   fHitsACORDE;
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+       
+  TH1F *   fHitsACORDE;
        fHitsACORDE = new TH1F("hACORDEBitPattern","Distribution of fired modules",60,0,60);
-       Add2HitsList(fHitsACORDE,0,kFALSE);
+       Add2HitsList(fHitsACORDE,0,!expert,image);
 }
 //____________________________________________________________________________ 
 void AliACORDEQADataMakerSim::InitDigits()
 {
   // create Digits histograms in Digits subdir
 
-   TH1F *    fhDigitsModule;
-   TString   modulename;
-   modulename = "hDigitsModule";
-   fhDigitsModule = new TH1F(modulename.Data(),"hDigitsModuleSingle",60,0,60);
-   Add2DigitsList(fhDigitsModule,0,kFALSE);
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  TH1F *    fhDigitsModule;
+  TString   modulename;
+  modulename = "hDigitsModule";
+  fhDigitsModule = new TH1F(modulename.Data(),"hDigitsModuleSingle",60,0,60);
+  Add2DigitsList(fhDigitsModule,0,!expert,image);
 
 }
 //____________________________________________________________________________
index 03ecd6f..3e5822b 100644 (file)
@@ -81,21 +81,24 @@ void AliEMCALQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjA
 void AliEMCALQADataMakerRec::InitESDs()
 {
   //Create histograms to controll ESD
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TH1F * h1 = new TH1F("hESDCaloClusterE",  "ESDs CaloCluster energy in EMCAL",    200, 0., 20.) ; 
   h1->Sumw2() ;
-  Add2ESDsList(h1, kESDCaloClusE)  ;                                                     
+  Add2ESDsList(h1, kESDCaloClusE, !expert, image)  ;                                                     
 
   TH1I * h2 = new TH1I("hESDCaloClusterM", "ESDs CaloCluster multiplicity in EMCAL", 100, 0,  100) ; 
   h2->Sumw2() ;
-  Add2ESDsList(h2, kESDCaloClusM)  ;
+  Add2ESDsList(h2, kESDCaloClusM, !expert, image)  ;
 
   TH1F * h3 = new TH1F("hESDCaloCellA",  "ESDs CaloCell amplitude in EMCAL",    500, 0., 250.) ; 
   h3->Sumw2() ;
-  Add2ESDsList(h3, kESDCaloCellA)  ;  
+  Add2ESDsList(h3, kESDCaloCellA, !expert, image)  ;  
  
   TH1I * h4 = new TH1I("hESDCaloCellM", "ESDs CaloCell multiplicity in EMCAL", 200, 0,  1000) ; 
   h4->Sumw2() ;
-  Add2ESDsList(h4, kESDCaloCellM) ;
+  Add2ESDsList(h4, kESDCaloCellM, !expert, image) ;
        
 }
 
@@ -103,17 +106,20 @@ void AliEMCALQADataMakerRec::InitESDs()
 void AliEMCALQADataMakerRec::InitRecPoints()
 {
   // create Reconstructed Points histograms in RecPoints subdir
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TH1F* h0 = new TH1F("hEMCALRpE","EMCAL RecPoint energies",200, 0.,20.); //GeV
   h0->Sumw2();
-  Add2RecPointsList(h0,kRecPE);
+  Add2RecPointsList(h0,kRecPE, !expert, image);
 
   TH1I* h1 = new TH1I("hEMCALRpM","EMCAL RecPoint multiplicities",100,0,100);
   h1->Sumw2();
-  Add2RecPointsList(h1,kRecPM);
+  Add2RecPointsList(h1,kRecPM, !expert, image);
 
   TH1I* h2 = new TH1I("hEMCALRpDigM","EMCAL RecPoint Digit Multiplicities",20,0,20);
   h2->Sumw2();
-  Add2RecPointsList(h2,kRecPDigM);
+  Add2RecPointsList(h2,kRecPDigM, !expert, image);
 
 }
 
@@ -123,40 +129,44 @@ void AliEMCALQADataMakerRec::InitRaws()
   // create Raws histograms in Raws subdir
   //these need more thought
   /*
+   const Bool_t expert   = kTRUE ; 
+   const Bool_t saveCorr = kTRUE ; 
+   const Bool_t image    = kTRUE ; 
+  
   TH1I * h0 = new TH1I("hLowEmcalSupermodules",    "Low Gain digits in EMCAL supermodules",       12, 0, 12) ;
   h0->Sumw2() ;
-  Add2RawsList(h0, kNsmodLG) ;
+  Add2RawsList(h0, kNsmodLG, !expert, image, !saveCorr) ;
   TH1I * h1 = new TH1I("hHighEmcalSupermodules",   "High Gain Digits in EMCAL supermodules",       12, 0, 12) ;
   h1->Sumw2() ;
-  Add2RawsList(h1, kNsmodHG) ;
+  Add2RawsList(h1, kNsmodHG, !expert, image, !saveCorr) ;
 
   TH1F * h2 = new TH1F("hLowEmcalRawtime", "Low Gain Time of raw digits in EMCAL", 500, -50., 200.) ;
   h2->Sumw2() ;
-  Add2RawsList(h2, kLGtime) ;
+  Add2RawsList(h2, kLGtime, !expert, image, !saveCorr) ;
   TH1F * h3 = new TH1F("hHighEmcalRawtime", "High Gain Time of raw digits in EMCAL", 500, -50., 200.) ;
   h3->Sumw2() ;
-  Add2RawsList(h3, kHGtime) ;
+  Add2RawsList(h3, kHGtime, !expert, image, !saveCorr) ;
 
   TH1F * h4 = new TH1F("hLowEmcalRawEnergy", "Low Gain Energy of raw digits in EMCAL", 500, 0., 1000.) ;
   h4->Sumw2() ;
-  Add2RawsList(h4, kSpecLG) ;
+  Add2RawsList(h4, kSpecLG, !expert, image, !saveCorr) ;
   TH1F * h5 = new TH1F("hHighEmcalRawEnergy", "High Gain Energy of raw digits in EMCAL",500,0., 1000.) ;
   h5->Sumw2() ;
-  Add2RawsList(h5, kSpecHG) ;
+  Add2RawsList(h5, kSpecHG, !expert, image, !saveCorr) ;
 
   TH1I * h6 = new TH1I("hLowNtot", "Low Gain Total Number of raw digits in EMCAL", 500, 0, 10000) ;
   h6->Sumw2() ;
-  Add2RawsList(h6, kNtotLG) ;
+  Add2RawsList(h6, kNtotLG, !expert, image, !saveCorr) ;
   TH1I * h7 = new TH1I("hHighNtot", "High Gain Total Number of raw digits in EMCAL",500,0, 10000) ;
   h7->Sumw2() ;
-  Add2RawsList(h7, kNtotHG) ;
+  Add2RawsList(h7, kNtotHG, !expert, image, !saveCorr) ;
 
   TH1F * h8 = new TH1F("hLowEtot", "Low Gain Total Energy of raw digits in EMCAL", 500, 0., 5000.) ;
   h8->Sumw2() ;
-  Add2RawsList(h8, kEtotLG) ;
+  Add2RawsList(h8, kEtotLG, !expert, image, !saveCorr) ;
   TH1F * h9 = new TH1F("hHighEtot", "High Gain Total Energy of raw digits in EMCAL",500,0., 100000.) ;
   h9->Sumw2() ;
-  Add2RawsList(h9, kEtotHG) ;
+  Add2RawsList(h9, kEtotHG, !expert, image, !saveCorr) ;
   */
   
 }
index 30a2e3d..855d1a6 100644 (file)
@@ -79,36 +79,45 @@ void AliEMCALQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjA
 void AliEMCALQADataMakerSim::InitHits()
 {
   // create Hits histograms in Hits subdir
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TH1F * h0 = new TH1F("hEmcalHits",    "Hits energy distribution in EMCAL",       200, 0., 2.) ; //GeV
   h0->Sumw2() ;
-  Add2HitsList(h0, 0) ;
+  Add2HitsList(h0, 0, !expert, image) ;
   TH1I * h1  = new TH1I("hEmcalHitsMul", "Hits multiplicity distribution in EMCAL", 1000, 0, 10000) ; 
   h1->Sumw2() ;
-  Add2HitsList(h1, 1) ;
+  Add2HitsList(h1, 1, !expert, image) ;
 }
 
 //____________________________________________________________________________ 
 void AliEMCALQADataMakerSim::InitDigits()
 {
   // create Digits histograms in Digits subdir
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TH1I * h0 = new TH1I("hEmcalDigits",    "Digits amplitude distribution in EMCAL",    500, 0, 500) ; 
   h0->Sumw2() ;
-  Add2DigitsList(h0, 0) ;
+  Add2DigitsList(h0, 0, !expert, image) ;
   TH1I * h1 = new TH1I("hEmcalDigitsMul", "Digits multiplicity distribution in EMCAL", 200, 0, 2000) ; 
   h1->Sumw2() ;
-  Add2DigitsList(h1, 1) ;
+  Add2DigitsList(h1, 1, !expert, image) ;
 }
 
 //____________________________________________________________________________ 
 void AliEMCALQADataMakerSim::InitSDigits()
 {
   // create SDigits histograms in SDigits subdir
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TH1F * h0 = new TH1F("hEmcalSDigits",    "SDigits energy distribution in EMCAL",       200, 0., 20.) ; 
   h0->Sumw2() ;
-  Add2SDigitsList(h0, 0) ;
+  Add2SDigitsList(h0, 0, !expert, image) ;
   TH1I * h1 = new TH1I("hEmcalSDigitsMul", "SDigits multiplicity distribution in EMCAL", 500, 0,  5000) ; 
   h1->Sumw2() ;
-  Add2SDigitsList(h1, 1) ;
+  Add2SDigitsList(h1, 1, !expert, image) ;
 }
 
 //____________________________________________________________________________
index 7bab963..f95d040 100644 (file)
@@ -105,39 +105,38 @@ AliFMDQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task,
 void AliFMDQADataMakerRec::InitESDs()
 {
   // create Digits histograms in Digits subdir
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TH1F* hEnergyOfESD = new TH1F("hEnergyOfESD","Energy distribution",100,0,3);
   hEnergyOfESD->SetXTitle("Edep/Emip");
   hEnergyOfESD->SetYTitle("Counts");
-  Add2ESDsList(hEnergyOfESD, 0);
+  Add2ESDsList(hEnergyOfESD, 0, !expert, image);
     
 }
 
 //_____________________________________________________________________ 
-/*void AliFMDQADataMakerRec::InitDigits()
-{
-  // create Digits histograms in Digits subdir
-  TH1I* hADCCounts      = new TH1I("hADCCounts","Dist of ADC counts",
-                                  1024,0,1024);
-  hADCCounts->SetXTitle("ADC counts");
-  hADCCounts->SetYTitle("");
-  Add2DigitsList(hADCCounts, 0);
-  
-}
-*/
-//_____________________________________________________________________ 
 void AliFMDQADataMakerRec::InitRecPoints()
 {
+  // create Reconstructed Points histograms in RecPoints subdir
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+
   TH1F* hEnergyOfRecpoints = new TH1F("hEnergyOfRecpoints",
                                      "Energy Distribution",100,0,3);
   hEnergyOfRecpoints->SetXTitle("Edep/Emip");
   hEnergyOfRecpoints->SetYTitle("");
-  Add2RecPointsList(hEnergyOfRecpoints,0);
+  Add2RecPointsList(hEnergyOfRecpoints,0, !expert, image);
 }
 
 //_____________________________________________________________________ 
 void AliFMDQADataMakerRec::InitRaws()
 {
-  
+  // create Raws histograms in Raws subdir  
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t saveCorr = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+
   TH1I* hADCCounts;
   for(Int_t det = 1; det<=3; det++) {
     Int_t firstring = (det==1 ? 1 : 0);
@@ -148,7 +147,7 @@ void AliFMDQADataMakerRec::InitRaws()
                                 1024,0,1023);
       
       Int_t index1 = GetHalfringIndex(det, ring, 0,1);
-      Add2RawsList(hADCCounts, index1,kTRUE);
+      Add2RawsList(hADCCounts, index1, expert, !image, !saveCorr);
       
       for(Int_t b = 0; b<=1;b++) {
        
@@ -163,7 +162,7 @@ void AliFMDQADataMakerRec::InitRaws()
        hADCCounts->SetXTitle("ADC counts");
        hADCCounts->SetYTitle("");
        Int_t index2 = GetHalfringIndex(det, ring, board/16,0);
-       Add2RawsList(hADCCounts, index2);
+       Add2RawsList(hADCCounts, index2, !expert, image, !saveCorr);
 
       }
     }
index 39c7680..faf9809 100644 (file)
@@ -101,28 +101,37 @@ void AliFMDQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task,
 void AliFMDQADataMakerSim::InitSDigits()
 {
   // create SDigits histograms in SDigits subdir
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TH1I* hADCCounts = new TH1I("hADCCounts","Dist of ADC counts",1024,0,1024);
   hADCCounts->SetXTitle("ADC counts");
-  Add2SDigitsList(hADCCounts, 0);
+  Add2SDigitsList(hADCCounts, 0, !expert, image);
 }
 
 //____________________________________________________________________ 
 void AliFMDQADataMakerSim::InitHits()
 {
   // create Digits histograms in Digits subdir
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TH1F* hEnergyOfHits = new TH1F("hEnergyOfHits","Energy distribution",100,0,3);
   hEnergyOfHits->SetXTitle("Edep");
   hEnergyOfHits->SetYTitle("Counts");
-  Add2HitsList(hEnergyOfHits, 0);
+  Add2HitsList(hEnergyOfHits, 0, !expert, image);
 }
 
 //_____________________________________________________________________
 void AliFMDQADataMakerSim::InitDigits()
 {
   // create Digits histograms in Digits subdir
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TH1I* hADCCounts = new TH1I("hADCCounts","Dist of ADC counts",1024,0,1024);
   hADCCounts->SetXTitle("ADC counts");
-  Add2DigitsList(hADCCounts, 0);
+  Add2DigitsList(hADCCounts, 0, !expert, image);
 }
 
 //_____________________________________________________________________
index 4f1bb17..b085dbf 100644 (file)
@@ -76,33 +76,32 @@ AliHMPIDQADataMakerRec& AliHMPIDQADataMakerRec::operator = (const AliHMPIDQAData
 void AliHMPIDQADataMakerRec::InitRecPoints()
 {
   // create cluster histograms in RecPoint subdir
-
-  Bool_t expert = kTRUE;
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
  
   TProfile *hCluMult          = new TProfile("CluMult"   ,"Cluster multiplicity per chamber"    , 16, -1 , 7  , 0, 500);
-  Add2RecPointsList(hCluMult    , 0,expert);
+  Add2RecPointsList(hCluMult    , 0,expert, !image);
   
   TH2F *hCluFlg          = new TH2F("CluFlg"      ,"Cluster flag  "                              ,  56  ,-1.5, 12.5, 70, -0.5, 6.5);
-  Add2RecPointsList(hCluFlg    , 1,expert);
+  Add2RecPointsList(hCluFlg    , 1,expert, !image);
   
   TH1F *hCluSizeMip[7], *hCluSizePho[7];
   
   TH1F *hCluQSect[42], *hCluQSectZoom[42];
   
   for(Int_t iCh =0; iCh <7; iCh++){
-   hCluSizeMip[iCh] = new TH1F(Form("CluSizeMipCh%i",iCh),Form("Cluster size  MIP  (cluster Q > 100 ADC) in Chamber %i",iCh),  50  , 0  , 50  );
-  Add2RecPointsList(hCluSizeMip[iCh], iCh+2,expert);
-
-   hCluSizePho[iCh]  = new TH1F(Form("CluSizePho%i",iCh ),Form("Cluster size  Phots(cluster Q < 100 ADC) in Chamber %i",iCh),  50  , 0  , 50  );
-  Add2RecPointsList(hCluSizePho[iCh], iCh+7+2,expert);
+    hCluSizeMip[iCh] = new TH1F(Form("CluSizeMipCh%i",iCh),Form("Cluster size  MIP  (cluster Q > 100 ADC) in Chamber %i",iCh),  50  , 0  , 50  );
+    Add2RecPointsList(hCluSizeMip[iCh], iCh+2,expert,!image);
 
+    hCluSizePho[iCh]  = new TH1F(Form("CluSizePho%i",iCh ),Form("Cluster size  Phots(cluster Q < 100 ADC) in Chamber %i",iCh),  50  , 0  , 50  );
+    Add2RecPointsList(hCluSizePho[iCh], iCh+7+2,expert,!image);
+    
     for(Int_t iSect =0; iSect < 6; iSect++){
       hCluQSectZoom[iCh*6+iSect] = new TH1F(Form("QClusCh%iSect%iZoom",iCh,iSect) ,Form("Zoom on Cluster charge (ADC) in Chamber %i and sector %i",iCh,iSect),100,0,100);
-      Add2RecPointsList(hCluQSectZoom[iCh*6+iSect],2+14+iCh*6+iSect,expert);
-
+      Add2RecPointsList(hCluQSectZoom[iCh*6+iSect],2+14+iCh*6+iSect,expert,!image);
+      
       hCluQSect[iCh*6+iSect] = new TH1F(Form("QClusCh%iSect%i",iCh,iSect) ,Form("Cluster charge (ADC) in Chamber %i and sector %i",iCh,iSect),250,0,5000);
-      Add2RecPointsList(hCluQSect[iCh*6+iSect],2+14+42+iCh*6+iSect);
-
+      Add2RecPointsList(hCluQSect[iCh*6+iSect],2+14+42+iCh*6+iSect, !expert, image);
     }  
   }
 }
@@ -115,7 +114,10 @@ void AliHMPIDQADataMakerRec::InitRaws()
 // All histograms implemented in InitRaws are used in AMORE. Any change here should be propagated to the amoreHMP-QA as well!!! (clm)
 //  
   
-  Bool_t expert = kTRUE;
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t saveCorr = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   const Int_t kNerr = (Int_t)AliHMPIDRawStream::kSumErr+1;
   TH1F *hSumErr[14];
   TH2F *hDilo[14];
@@ -127,49 +129,50 @@ void AliHMPIDQADataMakerRec::InitRaws()
     for(Int_t ilabel=0; ilabel< kNerr; ilabel++) {
       hSumErr[iddl]->GetXaxis()->CenterLabels(kTRUE);
       hSumErr[iddl]->GetXaxis()->SetBinLabel((2*ilabel+1),Form("%i  %s",ilabel+1,AliHMPIDRawStream::GetErrName(ilabel)));
-      }
-      
-    Add2RawsList(hSumErr[iddl],iddl,expert);
+    }
+    
+    Add2RawsList(hSumErr[iddl],iddl,expert,!image, !saveCorr);
     
     hDilo[iddl] = new TH2F(Form("hDiloDDL%i",iddl),Form("Dilogic response at DDL;Row # ;Dilogic #",iddl),24,1,25,10,1,11);
-    Add2RawsList(hDilo[iddl],14+iddl,expert);
+    Add2RawsList(hDilo[iddl],14+iddl,expert,!image, !saveCorr);
   }//DDL loop
- for(Int_t iCh = AliHMPIDParam::kMinCh; iCh <=AliHMPIDParam::kMaxCh ;iCh++) {
-   for(Int_t iPc = AliHMPIDParam::kMinPc; iPc <= AliHMPIDParam::kMaxPc ;iPc++) {
+  for(Int_t iCh = AliHMPIDParam::kMinCh; iCh <=AliHMPIDParam::kMaxCh ;iCh++) {
+    for(Int_t iPc = AliHMPIDParam::kMinPc; iPc <= AliHMPIDParam::kMaxPc ;iPc++) {
       hPadMap[iPc+6*iCh] = new TH2I(Form("hPadMap_Ch_%i_Pc%i",iCh,iPc),Form("Pad Map of Ch: %i Pc: %i;Pad X;Pad Y;",iCh,iPc),80,0,80,48,0,48);
-      Add2RawsList(hPadMap[iPc+6*iCh],28+iPc+6*iCh,expert); 
+      Add2RawsList(hPadMap[iPc+6*iCh],28+iPc+6*iCh,expert,!image, !saveCorr); 
       hPadQ[iPc+6*iCh]   = new TH1I(Form("hPadQ_Ch_%i_Pc%i",iCh,iPc),Form("Pad Charge of Ch: %i Pc: %i;Pad Q;Entries;",iCh,iPc),4100,0,4100);
-      Add2RawsList(hPadQ[iPc+6*iCh],70+iPc+6*iCh,expert); 
+      Add2RawsList(hPadQ[iPc+6*iCh],70+iPc+6*iCh,expert,!image, !saveCorr); 
     }//PC loop
   }//Ch loop  
-
-    TH2I *hGeneralErrorSummary = new TH2I("GeneralErrorSummary"," DDL index vs Error type plot", 2*kNerr, 0, 2*kNerr, 2*AliHMPIDRawStream::kNDDL,0,2*AliHMPIDRawStream::kNDDL);
-  for(Int_t igenlabel =0 ; igenlabel< kNerr; igenlabel++) hGeneralErrorSummary->GetXaxis()->SetBinLabel((2*igenlabel+1),Form("%i  %s",igenlabel+1,AliHMPIDRawStream::GetErrName(igenlabel)));
-   Add2RawsList(hGeneralErrorSummary,14+14+42+42);
   
+  TH2I *hGeneralErrorSummary = new TH2I("GeneralErrorSummary"," DDL index vs Error type plot", 2*kNerr, 0, 2*kNerr, 2*AliHMPIDRawStream::kNDDL,0,2*AliHMPIDRawStream::kNDDL);
+  for(Int_t igenlabel =0 ; igenlabel< kNerr; igenlabel++) hGeneralErrorSummary->GetXaxis()->SetBinLabel((2*igenlabel+1),Form("%i  %s",igenlabel+1,AliHMPIDRawStream::GetErrName(igenlabel)));
+  Add2RawsList(hGeneralErrorSummary,14+14+42+42, !expert, image, !saveCorr);
 }
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 void AliHMPIDQADataMakerRec::InitESDs()
 {
   //
   //Booking ESDs histograms
-   TH2F*  hCkovP  = new TH2F("CkovP" , "#theta_{c}, [rad];P, [GeV]"   , 150,      0,  7  ,100, 0, 1)   ;
-   TH2F*  hSigP   = new TH2F("SigP"  ,"#sigma_{#theta_c} [mrad];[GeV]", 150,      0,  7  ,100, 0, 1)   ;
-   TH2F*  hDifXY  = new TH2F("DifXY" ,"diff"                          , 200,    -10, 10  ,200,-10,10)  ;
-   TH2F*  hMvsP = new TH2F("MvsP","Reconstructed Mass vs P",60,0,6,1000,0,1) ;
-   TH1F*  hPid[5];
-   hPid[0] = new TH1F("PidE" ,"electron response"              , 101, -0.005,1.005)             ;
-   hPid[1] = new TH1F("PidMu","#mu response"                   , 101, -0.005,1.005)             ;
-   hPid[2] = new TH1F("PidPi","#pi response"                   , 101, -0.005,1.005)             ;
-   hPid[3] = new TH1F("PidK" ,"K response"                     , 101, -0.005,1.005)             ;
-   hPid[4] = new TH1F("PidP" ,"p response"                     , 101, -0.005,1.005)             ;
-
-   Add2ESDsList(hCkovP,0);
-   Add2ESDsList(hSigP ,1,kTRUE);
-   Add2ESDsList(hDifXY,2);
-   Add2ESDsList(hMvsP,3,kTRUE);
-   for(Int_t i=0; i< 5; i++) Add2ESDsList(hPid[i],i+4,kTRUE);
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
 
+  TH2F*  hCkovP  = new TH2F("CkovP" , "#theta_{c}, [rad];P, [GeV]"   , 150,      0,  7  ,100, 0, 1)   ;
+  TH2F*  hSigP   = new TH2F("SigP"  ,"#sigma_{#theta_c} [mrad];[GeV]", 150,      0,  7  ,100, 0, 1)   ;
+  TH2F*  hDifXY  = new TH2F("DifXY" ,"diff"                          , 200,    -10, 10  ,200,-10,10)  ;
+  TH2F*  hMvsP = new TH2F("MvsP","Reconstructed Mass vs P",60,0,6,1000,0,1) ;
+  TH1F*  hPid[5];
+  hPid[0] = new TH1F("PidE" ,"electron response"              , 101, -0.005,1.005)             ;
+  hPid[1] = new TH1F("PidMu","#mu response"                   , 101, -0.005,1.005)             ;
+  hPid[2] = new TH1F("PidPi","#pi response"                   , 101, -0.005,1.005)             ;
+  hPid[3] = new TH1F("PidK" ,"K response"                     , 101, -0.005,1.005)             ;
+  hPid[4] = new TH1F("PidP" ,"p response"                     , 101, -0.005,1.005)             ;
+  
+  Add2ESDsList(hCkovP,0, !expert, image);
+  Add2ESDsList(hSigP ,1, expert, !image);
+  Add2ESDsList(hDifXY,2, !expert, image);
+  Add2ESDsList(hMvsP,3, expert, !image);
+  for(Int_t i=0; i< 5; i++) Add2ESDsList(hPid[i],i+4, expert, !image);
 }
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 void AliHMPIDQADataMakerRec::MakeRaws(AliRawReader *rawReader)
index 6776268..969be10 100644 (file)
@@ -74,49 +74,51 @@ AliHMPIDQADataMakerSim& AliHMPIDQADataMakerSim::operator = (const AliHMPIDQAData
 void AliHMPIDQADataMakerSim::InitHits()
 {
   // create Hits histograms in Hits subdir
-  Bool_t expert = kTRUE;
-
-     TH1F *hHitQdc=new TH1F("HitQdc","HMPID Hit Qdc all chamber;QDC",500,0,4000);
-     Add2HitsList(hHitQdc,0);
-     TH2F *hHitMap[7];
-     for(Int_t iCh=0;iCh<7;iCh++) {
-     hHitMap[iCh]=new TH2F(Form("HMPID HitMap%i",iCh),Form("Ch%i;x_{Hit};y_{Hit}",iCh),162,-1,161,146,-1,145);   
-    Add2HitsList(hHitMap[iCh],iCh+1,expert);
-    }
-
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  TH1F *hHitQdc=new TH1F("HitQdc","HMPID Hit Qdc all chamber;QDC",500,0,4000);
+  Add2HitsList(hHitQdc,0, !expert, image);
+  TH2F *hHitMap[7];
+  for(Int_t iCh=0;iCh<7;iCh++) {
+    hHitMap[iCh]=new TH2F(Form("HMPID HitMap%i",iCh),Form("Ch%i;x_{Hit};y_{Hit}",iCh),162,-1,161,146,-1,145);   
+    Add2HitsList(hHitMap[iCh],iCh+1,expert,!image);
+  }
 }
 
 //____________________________________________________________________________ 
 void AliHMPIDQADataMakerSim::InitDigits()
 {
   // create Digits histograms in Digits subdir
-
-  Bool_t expert = kTRUE;
-
-      TH1F *hDigChEvt = new TH1F("hDigChEvt","Chamber occupancy per event",AliHMPIDParam::kMaxCh+1,AliHMPIDParam::kMinCh,AliHMPIDParam::kMaxCh+1);
-      TH1F *hDigPcEvt = new TH1F("hDigPcEvt","PC occupancy",156,-1,77);
-      TH2F *hDigMap[7];
-      TH1F *hDigQ[42];
-      for(Int_t iCh =0; iCh < 7; iCh++){
-       hDigMap[iCh] = new TH2F(Form("MapCh%i",iCh),Form("Digit Map in Chamber %i",iCh),159,0,159,143,0,143);
-       for(Int_t iPc =0; iPc < 6; iPc++ ){
-        hDigQ[iCh*6+iPc] = new TH1F(Form("QCh%iPc%i        ",iCh,iPc),Form("Charge of digits (ADC) in Chamber %i and PC %i   ",iCh,iPc),4100,0,4100);
-      }
-     }
-
-   Add2DigitsList(hDigChEvt,0);
-   Add2DigitsList(hDigPcEvt,1,expert);
-   for(Int_t iMap=0; iMap < 7; iMap++) Add2DigitsList(hDigMap[iMap],2+iMap,expert);
-   for(Int_t iH =0; iH < 42 ; iH++) Add2DigitsList(hDigQ[iH]    ,9+iH,expert);
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  TH1F *hDigChEvt = new TH1F("hDigChEvt","Chamber occupancy per event",AliHMPIDParam::kMaxCh+1,AliHMPIDParam::kMinCh,AliHMPIDParam::kMaxCh+1);
+  TH1F *hDigPcEvt = new TH1F("hDigPcEvt","PC occupancy",156,-1,77);
+  TH2F *hDigMap[7];
+  TH1F *hDigQ[42];
+  for(Int_t iCh =0; iCh < 7; iCh++){
+    hDigMap[iCh] = new TH2F(Form("MapCh%i",iCh),Form("Digit Map in Chamber %i",iCh),159,0,159,143,0,143);
+    for(Int_t iPc =0; iPc < 6; iPc++ ){
+      hDigQ[iCh*6+iPc] = new TH1F(Form("QCh%iPc%i        ",iCh,iPc),Form("Charge of digits (ADC) in Chamber %i and PC %i   ",iCh,iPc),4100,0,4100);
+    }
+  }
+  
+  Add2DigitsList(hDigChEvt,0, !expert, image);
+  Add2DigitsList(hDigPcEvt,1,expert, !image);
+  for(Int_t iMap=0; iMap < 7; iMap++) Add2DigitsList(hDigMap[iMap],2+iMap,expert, !image);
+  for(Int_t iH =0; iH < 42 ; iH++) Add2DigitsList(hDigQ[iH]    ,9+iH,expert,!image);
 }
 
 //____________________________________________________________________________ 
 void AliHMPIDQADataMakerSim::InitSDigits()
 {
   // create SDigits histograms in SDigits subdir
-   TH1F   *hSDigits     = new TH1F("hHmpidSDigits",    "SDigits Q  distribution in HMPID",  500, 0., 5000.) ; 
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
 
-Add2SDigitsList(hSDigits,0);
+  TH1F   *hSDigits     = new TH1F("hHmpidSDigits",    "SDigits Q  distribution in HMPID",  500, 0., 5000.) ; 
+  Add2SDigitsList(hSDigits,0, !expert, image);
 }
 
 //____________________________________________________________________________ 
index a13d82f..6be5fa1 100644 (file)
@@ -137,6 +137,10 @@ void AliITSQASDDDataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/,
 void AliITSQASDDDataMakerRec::InitRaws()
 { 
   // Initialization for RAW data - SDD -
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t saveCorr = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   fGenRawsOffset = (fAliITSQADataMakerRec->fRawsQAList[AliRecoParam::kDefault])->GetEntries();
   AliCDBEntry *ddlMapSDD = AliCDBManager::Instance()->Get("ITS/Calib/DDLMapSDD");
   Bool_t cacheStatus = AliCDBManager::Instance()->GetCacheFlag();
@@ -185,7 +189,7 @@ void AliITSQASDDDataMakerRec::InitRaws()
   TH1D *h0 = new TH1D("SDDModPattern","HW Modules pattern",fgknSDDmodules,239.5,499.5); //0
   h0->GetXaxis()->SetTitle("Module Number");
   h0->GetYaxis()->SetTitle("Counts");
-  fAliITSQADataMakerRec->Add2RawsList((new TH1D(*h0)),0+fGenRawsOffset,kTRUE,kFALSE);
+  fAliITSQADataMakerRec->Add2RawsList((new TH1D(*h0)),0+fGenRawsOffset, expert, !image, !saveCorr);
   delete h0;
   fSDDhRawsTask++;
   
@@ -193,14 +197,14 @@ void AliITSQASDDDataMakerRec::InitRaws()
   TH2D *hphil3 = new TH2D("SDDphizL3","SDD #varphiz Layer3 ",6,0.5,6.5,14,0.5,14.5);
   hphil3->GetXaxis()->SetTitle("z[#Module L3 ]");
   hphil3->GetYaxis()->SetTitle("#varphi[#Ladder L3]");
-  fAliITSQADataMakerRec->Add2RawsList((new TH2D(*hphil3)),1+fGenRawsOffset, kFALSE,kTRUE); 
+  fAliITSQADataMakerRec->Add2RawsList((new TH2D(*hphil3)),1+fGenRawsOffset, !expert, image, saveCorr); 
   delete hphil3;
   fSDDhRawsTask++;
   
   TH2D *hphil4 = new TH2D("SDDphizL4","SDD #varphiz Layer4 ",8,0.5,8.5,22,0.5,22.5); 
   hphil4->GetXaxis()->SetTitle("z[#Module L4]");
   hphil4->GetYaxis()->SetTitle("#varphi[#Ladder L4]");
-  fAliITSQADataMakerRec->Add2RawsList((new TH2D(*hphil4)),2+fGenRawsOffset, kFALSE,kTRUE); 
+  fAliITSQADataMakerRec->Add2RawsList((new TH2D(*hphil4)),2+fGenRawsOffset, !expert, image, saveCorr); 
   delete hphil4;
   fSDDhRawsTask++;
   
@@ -212,7 +216,7 @@ void AliITSQASDDDataMakerRec::InitRaws()
       TH2D *hddl = new TH2D("SDDDDLPattern","SDD DDL Pattern ",24,-0.5,23.5,24,-0.5,23.5); 
       hddl->GetXaxis()->SetTitle("Channel");
       hddl->GetYaxis()->SetTitle("#DDL");
-      fAliITSQADataMakerRec->Add2RawsList((new TH2D(*hddl)),3+fGenRawsOffset, kTRUE,kFALSE);
+      fAliITSQADataMakerRec->Add2RawsList((new TH2D(*hddl)),3+fGenRawsOffset, expert, !image, !saveCorr);
       delete hddl;
       fSDDhRawsTask++;
       Int_t indexlast1 = 0;
@@ -232,7 +236,7 @@ void AliITSQASDDDataMakerRec::InitRaws()
          TProfile2D *fModuleChargeMapFSE = new TProfile2D(hname[0],hname[1],256/fTimeBinSize,-0.5,255.5,256,-0.5,255.5);
          fModuleChargeMapFSE->GetXaxis()->SetTitle("Time Bin");
          fModuleChargeMapFSE->GetYaxis()->SetTitle("Anode");
-         fAliITSQADataMakerRec->Add2RawsList((new TProfile2D(*fModuleChargeMapFSE)),indexlast1 + index1 + fGenRawsOffset,kTRUE,kFALSE);
+         fAliITSQADataMakerRec->Add2RawsList((new TProfile2D(*fModuleChargeMapFSE)),indexlast1 + index1 + fGenRawsOffset, expert, !image, !saveCorr);
          delete fModuleChargeMapFSE;
          
          fSDDhRawsTask++;
@@ -248,7 +252,7 @@ void AliITSQASDDDataMakerRec::InitRaws()
          TProfile2D *fModuleChargeMap = new TProfile2D(hname[0],hname[1],256/fTimeBinSize,-0.5,255.5,256,-0.5,255.5);
          fModuleChargeMap->GetXaxis()->SetTitle("Time Bin");
          fModuleChargeMap->GetYaxis()->SetTitle("Anode");
-         fAliITSQADataMakerRec->Add2RawsList((new TProfile2D(*fModuleChargeMap)),indexlast1 + index1 + fGenRawsOffset,kTRUE,kFALSE);
+         fAliITSQADataMakerRec->Add2RawsList((new TProfile2D(*fModuleChargeMap)),indexlast1 + index1 + fGenRawsOffset, expert, !image, !saveCorr);
          delete fModuleChargeMap;
          
          fSDDhRawsTask++;
@@ -393,7 +397,9 @@ void AliITSQASDDDataMakerRec::MakeRaws(AliRawReader* rawReader)
 void AliITSQASDDDataMakerRec::InitRecPoints()
 {
   // Initialization for RECPOINTS - SDD -
-
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   fGenRecPointsOffset = (fAliITSQADataMakerRec->fRecPointsQAList[AliRecoParam::kDefault])->GetEntries();
 
   Int_t nOnline=1;
@@ -412,14 +418,14 @@ void AliITSQASDDDataMakerRec::InitRecPoints()
   TH1F *h0 = new TH1F("SDDLay3TotCh","Layer 3 total charge",1000/nOnline,-0.5, 499.5); //position number 0
   h0->GetXaxis()->SetTitle("ADC value");
   h0->GetYaxis()->SetTitle("Entries");
-  fAliITSQADataMakerRec->Add2RecPointsList((new TH1F(*h0)), 0 +fGenRecPointsOffset,kFALSE);
+  fAliITSQADataMakerRec->Add2RecPointsList((new TH1F(*h0)), 0 +fGenRecPointsOffset, !expert, image);
   delete h0;
   fSDDhRecPointsTask++;
  
   TH1F *h1 = new TH1F("SDDLay4TotCh","Layer 4 total charge",1000/nOnline,-0.5, 499.5);//position number 1
   h1->GetXaxis()->SetTitle("ADC value");
   h1->GetYaxis()->SetTitle("Entries");
-  fAliITSQADataMakerRec->Add2RecPointsList((new TH1F(*h1)), 1 +fGenRecPointsOffset,kFALSE);
+  fAliITSQADataMakerRec->Add2RecPointsList((new TH1F(*h1)), 1 +fGenRecPointsOffset, !expert, image);
   delete h1;
   fSDDhRecPointsTask++;
 
@@ -427,53 +433,53 @@ void AliITSQASDDDataMakerRec::InitRecPoints()
   TH2F *h2 = new TH2F("SDDGlobalCoordDistribYX","YX Global Coord Distrib",5600/nOnline2,-28,28,5600/nOnline2,-28,28);//position number 2
   h2->GetYaxis()->SetTitle("Y[cm]");
   h2->GetXaxis()->SetTitle("X[cm]");
-  fAliITSQADataMakerRec->Add2RecPointsList((new TH2F(*h2)),2+fGenRecPointsOffset,kTRUE);
+  fAliITSQADataMakerRec->Add2RecPointsList((new TH2F(*h2)),2+fGenRecPointsOffset, expert, !image);
   delete h2;
   fSDDhRecPointsTask++;
 
   TH2F *h3 = new TH2F("SDDGlobalCoordDistribRZ","RZ Global Coord Distrib",6400/nOnline3,-32,32,1400/nOnline4,12,26);//position number 3
   h3->GetYaxis()->SetTitle("R[cm]");
   h3->GetXaxis()->SetTitle("Z[cm]");
-  fAliITSQADataMakerRec->Add2RecPointsList((new TH2F(*h3)),3+fGenRecPointsOffset,kTRUE);
+  fAliITSQADataMakerRec->Add2RecPointsList((new TH2F(*h3)),3+fGenRecPointsOffset, expert, !image);
   delete h3;
   fSDDhRecPointsTask++;
   
   TH2F *h4 = new TH2F("SDDGlobalCoordDistribL3PHIZ","#varphi Z Global Coord Distrib L3",6400/nOnline3,-32,32,360/nOnline,-TMath::Pi(),TMath::Pi());//position number 4
   h4->GetYaxis()->SetTitle("#phi[rad]");
   h4->GetXaxis()->SetTitle("Z[cm]");
-  fAliITSQADataMakerRec->Add2RecPointsList((new TH2F(*h4)),4+fGenRecPointsOffset,kFALSE);
+  fAliITSQADataMakerRec->Add2RecPointsList((new TH2F(*h4)),4+fGenRecPointsOffset, !expert, image);
   delete h4;
   fSDDhRecPointsTask++;
 
   TH2F *h5 = new TH2F("SDDGlobalCoordDistribL4PHIZ","#varphi Z Global Coord Distrib L4",6400/nOnline3,-32,32,360/nOnline,-TMath::Pi(),TMath::Pi());//position number 5
   h5->GetYaxis()->SetTitle("#phi[rad]");
   h5->GetXaxis()->SetTitle("Z[cm]");
-  fAliITSQADataMakerRec->Add2RecPointsList((new TH2F(*h5)),5+fGenRecPointsOffset,kFALSE);
+  fAliITSQADataMakerRec->Add2RecPointsList((new TH2F(*h5)),5+fGenRecPointsOffset, !expert, image);
   delete h5;
   fSDDhRecPointsTask++;
   
   TH1F *h6 = new TH1F("SDDModPatternRP","Modules pattern RP",fgknSDDmodules,239.5,499.5); //position number 6
   h6->GetXaxis()->SetTitle("Module number"); //spd offset = 240
   h6->GetYaxis()->SetTitle("Entries");
-  fAliITSQADataMakerRec->Add2RecPointsList((new TH1F(*h6)),6 +fGenRecPointsOffset,kTRUE);
+  fAliITSQADataMakerRec->Add2RecPointsList((new TH1F(*h6)),6 +fGenRecPointsOffset, expert, !image);
   delete h6;
   fSDDhRecPointsTask++;
   TH1F *h7 = new TH1F("SDDLadPatternL3RP","Ladder pattern L3 RP",14,0.5,14.5);  //position number 7
   h7->GetXaxis()->SetTitle("Ladder #, Layer 3");
   h7->GetYaxis()->SetTitle("Entries");
-  fAliITSQADataMakerRec->Add2RecPointsList((new TH1F(*h7)),7 +fGenRecPointsOffset,kTRUE);
+  fAliITSQADataMakerRec->Add2RecPointsList((new TH1F(*h7)),7 +fGenRecPointsOffset, expert, !image);
   delete h7;
   fSDDhRecPointsTask++;
   TH1F *h8 = new TH1F("SDDLadPatternL4RP","Ladder pattern L4 RP",22,0.5,22.5); //position number 8
   h8->GetXaxis()->SetTitle("Ladder #, Layer 4");
   h8->GetYaxis()->SetTitle("Entries");
-  fAliITSQADataMakerRec->Add2RecPointsList((new TH1F(*h8)),8 +fGenRecPointsOffset,kTRUE);
+  fAliITSQADataMakerRec->Add2RecPointsList((new TH1F(*h8)),8 +fGenRecPointsOffset, expert, !image);
   delete h8;
   fSDDhRecPointsTask++;
   TH2F *h9 = new TH2F("SDDLocalCoordDistrib","Local Coord Distrib",1000/nOnline,-4,4,1000/nOnline,-4,4);//position number 9
   h9->GetXaxis()->SetTitle("X local coord, drift, cm");
   h9->GetYaxis()->SetTitle("Z local coord, anode, cm");
-  fAliITSQADataMakerRec->Add2RecPointsList((new TH2F(*h9)),9 +fGenRecPointsOffset,kTRUE);
+  fAliITSQADataMakerRec->Add2RecPointsList((new TH2F(*h9)),9 +fGenRecPointsOffset, expert, !image);
   delete h9;
   fSDDhRecPointsTask++;
 
@@ -482,7 +488,7 @@ void AliITSQASDDDataMakerRec::InitRecPoints()
     h10->GetXaxis()->SetTitle("r[cm]");
     h10->GetXaxis()->CenterTitle();
     h10->GetYaxis()->SetTitle("Entries");
-    fAliITSQADataMakerRec->Add2RecPointsList((new TH1F(*h10)),10 +fGenRecPointsOffset,kTRUE);
+    fAliITSQADataMakerRec->Add2RecPointsList((new TH1F(*h10)),10 +fGenRecPointsOffset, expert, !image);
     delete h10;
     fSDDhRecPointsTask++;
 
@@ -490,7 +496,7 @@ void AliITSQASDDDataMakerRec::InitRecPoints()
     h11->GetXaxis()->SetTitle("r[cm]");
     h11->GetXaxis()->CenterTitle();
     h11->GetYaxis()->SetTitle("Entries");
-    fAliITSQADataMakerRec->Add2RecPointsList((new TH1F(*h11)),11 +fGenRecPointsOffset,kTRUE);
+    fAliITSQADataMakerRec->Add2RecPointsList((new TH1F(*h11)),11 +fGenRecPointsOffset, expert, !image);
     delete h11;
     fSDDhRecPointsTask++;
 
@@ -500,7 +506,7 @@ void AliITSQASDDDataMakerRec::InitRecPoints()
     h12->GetXaxis()->SetTitle("#varphi[rad]");
     h12->GetXaxis()->CenterTitle();
     h12->GetYaxis()->SetTitle("Entries");
-    fAliITSQADataMakerRec->Add2RecPointsList((new TH1F(*h12)),iLay+12+fGenRecPointsOffset,kTRUE);
+    fAliITSQADataMakerRec->Add2RecPointsList((new TH1F(*h12)),iLay+12+fGenRecPointsOffset, expert, !image);
     delete h12;
     fSDDhRecPointsTask++;
   }
@@ -510,14 +516,14 @@ void AliITSQASDDDataMakerRec::InitRecPoints()
       TH2F *h14 = new TH2F("SDDGlobalCoordDistribYXFSE","YX Global Coord Distrib FSE",5600/nOnline2,-28,28,5600/nOnline2,-28,28);//position number 14
       h14->GetYaxis()->SetTitle("Y[cm]");
       h14->GetXaxis()->SetTitle("X[cm]");
-      fAliITSQADataMakerRec->Add2RecPointsList((new TH2F(*h14)),14+fGenRecPointsOffset,kTRUE);
+      fAliITSQADataMakerRec->Add2RecPointsList((new TH2F(*h14)),14+fGenRecPointsOffset, expert, !image);
       delete h14;
       fSDDhRecPointsTask++;
       
       TH2F *h15 = new TH2F("SDDGlobalCoordDistribRZFSE","RZ Global Coord Distrib FSE",Int_t(6400/nOnline3),-32,32,1400/nOnline4,12,26);//position number 15
       h15->GetYaxis()->SetTitle("R[cm]");
       h15->GetXaxis()->SetTitle("Z[cm]");
-      fAliITSQADataMakerRec->Add2RecPointsList((new TH2F(*h15)),15+fGenRecPointsOffset,kTRUE);
+      fAliITSQADataMakerRec->Add2RecPointsList((new TH2F(*h15)),15+fGenRecPointsOffset, expert, !image);
       delete h15;
       fSDDhRecPointsTask++;
       
index 2e63f2b..4336977 100644 (file)
@@ -105,27 +105,30 @@ void AliITSQASDDDataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/,
 void AliITSQASDDDataMakerSim::InitDigits()\r
 { \r
   // Initialization for DIGIT data - SDD -  \r
+  const Bool_t expert   = kTRUE ; \r
+  const Bool_t image    = kTRUE ;\r
+  \r
   fGenOffsetD = (fAliITSQADataMakerSim->fDigitsQAList[AliRecoParam::kDefault])->GetEntries();\r
   //fSDDhTask must be incremented by one unit every time a histogram is ADDED to the QA List\r
   TH1F* h0=new TH1F("SDD DIGITS Module Pattern","SDD DIGITS Module Pattern",260,239.5,499.5);       //hmod\r
   h0->GetXaxis()->SetTitle("SDD Module Number");\r
   h0->GetYaxis()->SetTitle("# DIGITS");\r
-  fAliITSQADataMakerSim->Add2DigitsList(h0,fGenOffsetD);\r
+  fAliITSQADataMakerSim->Add2DigitsList(h0,fGenOffsetD, !expert, image);\r
   fSDDhDTask ++;\r
   TH1F* h1=new TH1F("SDD Anode Distribution","DIGITS Anode Distribution",512,-0.5,511.5);      //hanocc\r
   h1->GetXaxis()->SetTitle("Anode Number");\r
   h1->GetYaxis()->SetTitle("# DIGITS");\r
-  fAliITSQADataMakerSim->Add2DigitsList(h1,1+fGenOffsetD);\r
+  fAliITSQADataMakerSim->Add2DigitsList(h1,1+fGenOffsetD, !expert, image);\r
   fSDDhDTask ++;\r
   TH1F* h2=new TH1F("SDD Tbin Distribution","DIGITS Tbin Distribution",256,-0.5,255.5);      //htbocc\r
   h2->GetXaxis()->SetTitle("Tbin Number");\r
   h2->GetYaxis()->SetTitle("# DIGITS");\r
-  fAliITSQADataMakerSim->Add2DigitsList(h2,2+fGenOffsetD);\r
+  fAliITSQADataMakerSim->Add2DigitsList(h2,2+fGenOffsetD, !expert, image);\r
   fSDDhDTask ++;\r
   TH1F* h3=new TH1F("SDD ADC Counts Distribution","DIGITS ADC Counts Distribution",200,0.,1024.);          //hsig\r
   h3->GetXaxis()->SetTitle("ADC Value");\r
   h3->GetYaxis()->SetTitle("# DIGITS");\r
-  fAliITSQADataMakerSim->Add2DigitsList(h3,3+fGenOffsetD);\r
+  fAliITSQADataMakerSim->Add2DigitsList(h3,3+fGenOffsetD, !expert, image);\r
   fSDDhDTask ++;\r
   AliDebug(1,Form("%d SDD Digits histograms booked\n",fSDDhDTask));\r
 }\r
@@ -159,17 +162,20 @@ void AliITSQASDDDataMakerSim::MakeDigits(TTree * digits)
 void AliITSQASDDDataMakerSim::InitSDigits()\r
 { \r
   // Initialization for SDIGIT data - SDD -\r
+  const Bool_t expert   = kTRUE ; \r
+  const Bool_t image    = kTRUE ;\r
+  \r
   fGenOffsetS = (fAliITSQADataMakerSim->fSDigitsQAList[AliRecoParam::kDefault])->GetEntries();\r
   //fSDDhTask must be incremented by one unit every time a histogram is ADDED to the QA List\r
   TH1F* h0=new TH1F("SDD SDIGITS Module Pattern","SDIGITS SDD Module Pattern",260,239.5,499.5);       //hmod\r
   h0->GetXaxis()->SetTitle("SDD Module Number");\r
   h0->GetYaxis()->SetTitle("# SDIGITS");\r
-  fAliITSQADataMakerSim->Add2SDigitsList(h0,fGenOffsetS);\r
+  fAliITSQADataMakerSim->Add2SDigitsList(h0,fGenOffsetS, !expert, image);\r
   fSDDhSTask ++;\r
   TH1F* h1=new TH1F("SDD Anode Distribution","SDIGITS Anode Distribution",512,-0.5,511.5);      //hanocc\r
   h1->GetXaxis()->SetTitle("Anode Number");\r
   h1->GetYaxis()->SetTitle("# SDIGITS");\r
-  fAliITSQADataMakerSim->Add2SDigitsList(h1,1+fGenOffsetS);\r
+  fAliITSQADataMakerSim->Add2SDigitsList(h1,1+fGenOffsetS, !expert, image);\r
   fSDDhSTask ++;\r
   TH1F* h2=new TH1F("SDD Tbin Distribution","SDIGITS Tbin Distribution",256,-0.5,255.5);      //htbocc\r
   h2->GetXaxis()->SetTitle("Tbin Number");\r
@@ -179,7 +185,7 @@ void AliITSQASDDDataMakerSim::InitSDigits()
   TH1F* h3=new TH1F("SDD ADC Counts Distribution","SDIGITS ADC Counts Distribution",200,0.,1024.);          //hsig\r
   h3->GetXaxis()->SetTitle("ADC Value");\r
   h3->GetYaxis()->SetTitle("# SDIGITS");\r
-  fAliITSQADataMakerSim->Add2SDigitsList(h3,3+fGenOffsetS);\r
+  fAliITSQADataMakerSim->Add2SDigitsList(h3,3+fGenOffsetS, !expert, image);\r
   fSDDhSTask ++;\r
 \r
   AliDebug(1,Form("%d SDD SDigits histograms booked\n",fSDDhSTask));\r
@@ -231,28 +237,31 @@ void AliITSQASDDDataMakerSim::InitHits()
 { \r
 \r
   // Initialization for HITS data - SDD -\r
+  const Bool_t expert   = kTRUE ; \r
+  const Bool_t image    = kTRUE ;\r
+  \r
   fGenOffsetH = (fAliITSQADataMakerSim->fHitsQAList[AliRecoParam::kDefault])->GetEntries();\r
   //fSDDhTask must be incremented by one unit every time a histogram is ADDED to the QA List\r
   //printf("AliITSQASDDDataMakerSim::InitHits called \n");\r
   TH1F *h0=new TH1F("SDD HITS Module Pattern","SDD HITS Module Pattern",260,239.5,499.5);  \r
   h0->GetXaxis()->SetTitle("SDD Module Number");\r
   h0->GetYaxis()->SetTitle("# HITS");\r
-  fAliITSQADataMakerSim->Add2HitsList(h0,fGenOffsetH);\r
+  fAliITSQADataMakerSim->Add2HitsList(h0,fGenOffsetH, !expert, image);\r
   fSDDhHTask ++;\r
   TH1F *h1=new TH1F("SDD HIT lenght along local Y Coord","HIT lenght along local Y Coord",200,0.,350.);\r
   h1->GetXaxis()->SetTitle("HIT lenght (um)");\r
   h1->GetYaxis()->SetTitle("# HITS");\r
-  fAliITSQADataMakerSim->Add2HitsList(h1,1+fGenOffsetH);\r
+  fAliITSQADataMakerSim->Add2HitsList(h1,1+fGenOffsetH, !expert, image);\r
   fSDDhHTask ++;\r
   TH1F *h2=new TH1F("SDD HIT lenght along local Y Coord - Zoom","SDD HIT lenght along local Y Coord - Zoom",200,250.,350.);\r
   h2->GetXaxis()->SetTitle("HIT lenght (um)");\r
   h2->GetYaxis()->SetTitle("# HITS");\r
-  fAliITSQADataMakerSim->Add2HitsList(h2,2+fGenOffsetH);\r
+  fAliITSQADataMakerSim->Add2HitsList(h2,2+fGenOffsetH, !expert, image);\r
   fSDDhHTask ++;\r
   TH1F *h3=new TH1F("SDD Deposited Energy Distribution (loc Y > 200um)","SDD HITS Deposited Energy Distribution (loc Y > 200um)",200,0.,350.);\r
   h3->GetXaxis()->SetTitle("ADC counts ");\r
   h3->GetYaxis()->SetTitle("# HITS");\r
-  fAliITSQADataMakerSim->Add2HitsList(h3,3+fGenOffsetH);\r
+  fAliITSQADataMakerSim->Add2HitsList(h3,3+fGenOffsetH, !expert, image);\r
   fSDDhHTask ++;\r
   AliDebug(1,Form("%d SDD Hits histograms booked\n",fSDDhHTask));\r
 }\r
index ae96474..1950411 100644 (file)
@@ -110,6 +110,10 @@ void AliITSQASPDDataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/,
 void AliITSQASPDDataMakerRec::InitRaws()
 { 
   // Initialization for RAW data - SPD -
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t saveCorr = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   fGenRawsOffset = (fAliITSQADataMakerRec->fRawsQAList[AliRecoParam::kDefault])->GetEntries();
   fAdvLogger = new AliITSRawStreamSPDErrorLog();  
   AliInfo("Book Offline Histograms for SPD\n ");
@@ -120,7 +124,7 @@ void AliITSQASPDDataMakerRec::InitRaws()
   TH1F *hlayer = new TH1F("SPDLayPattern_SPD","Layer map - SPD",6,0.,6.);
   hlayer->GetXaxis()->SetTitle("Layer number");
   hlayer->GetYaxis()->SetTitle("Entries");
-  fAliITSQADataMakerRec->Add2RawsList(hlayer, 0+fGenRawsOffset, kTRUE);
+  fAliITSQADataMakerRec->Add2RawsList(hlayer, 0+fGenRawsOffset, expert, !image, !saveCorr);
   fSPDhRawsTask++;
 
   TH1F **hmod = new TH1F*[2];
@@ -132,7 +136,7 @@ void AliITSQASPDDataMakerRec::InitRaws()
     hmod[iLay]=new TH1F(name,title,fgknSPDmodules,0,fgknSPDmodules);
     hmod[iLay]->GetXaxis()->SetTitle("Module number");
     hmod[iLay]->GetYaxis()->SetTitle("Entries");
-    fAliITSQADataMakerRec->Add2RawsList(hmod[iLay], 1+iLay+fGenRawsOffset);
+    fAliITSQADataMakerRec->Add2RawsList(hmod[iLay], 1+iLay+fGenRawsOffset, !expert, image, !saveCorr);
     fSPDhRawsTask++;
   }
   for (Int_t iDDL=0; iDDL<20; iDDL++) {
@@ -141,14 +145,14 @@ void AliITSQASPDDataMakerRec::InitRaws()
     hhitMap[iDDL]=new TH2F(name,title,320,0,10*32,1536,0,6*256);
     hhitMap[iDDL]->GetXaxis()->SetTitle("Column");
     hhitMap[iDDL]->GetYaxis()->SetTitle("Row");
-    fAliITSQADataMakerRec->Add2RawsList(hhitMap[iDDL], 3+(2*iDDL)+fGenRawsOffset, kTRUE);
+    fAliITSQADataMakerRec->Add2RawsList(hhitMap[iDDL], 3+(2*iDDL)+fGenRawsOffset, expert, !image, !saveCorr);
     fSPDhRawsTask++;
     sprintf(name,"SPDErrors_SPD_DDL%d",iDDL+1);
     sprintf(title,"Error codes - SPD DDL %d",iDDL+1);
     herrors[iDDL] = new TH1F (name,title,fAdvLogger->GetNrErrorCodes(),0,fAdvLogger->GetNrErrorCodes());
     herrors[iDDL]->SetXTitle("Error Code");
     herrors[iDDL]->SetYTitle("Nr of errors");
-    fAliITSQADataMakerRec->Add2RawsList(herrors[iDDL], 4+(2*iDDL)+fGenRawsOffset, kTRUE);
+    fAliITSQADataMakerRec->Add2RawsList(herrors[iDDL], 4+(2*iDDL)+fGenRawsOffset, expert, !image, !saveCorr);
     fSPDhRawsTask++;
   }
 
@@ -159,7 +163,7 @@ void AliITSQASPDDataMakerRec::InitRaws()
     hMultSPDhits[iLay]=new TH1F(name,title,200,0.,200.);
     hMultSPDhits[iLay]->GetXaxis()->SetTitle("Hit multiplicity");
     hMultSPDhits[iLay]->GetYaxis()->SetTitle("Entries");
-    fAliITSQADataMakerRec->Add2RawsList(hMultSPDhits[iLay], 43+iLay+fGenRawsOffset, kTRUE);
+    fAliITSQADataMakerRec->Add2RawsList(hMultSPDhits[iLay], 43+iLay+fGenRawsOffset, expert, !image, !saveCorr);
     fSPDhRawsTask++;
   }
 
@@ -167,7 +171,7 @@ void AliITSQASPDDataMakerRec::InitRaws()
          = new TH2F("SPDHitMultCorrelation_SPD","Hit multiplicity correlation - SPD",200,0.,200.,200,0.,200.);
   hMultSPDhits2MultSPDhits1->GetXaxis()->SetTitle("Hit multiplicity (Layer 1)");
   hMultSPDhits2MultSPDhits1->GetYaxis()->SetTitle("Hit multiplicity (Layer 2)");
-  fAliITSQADataMakerRec->Add2RawsList(hMultSPDhits2MultSPDhits1, 45+fGenRawsOffset);
+  fAliITSQADataMakerRec->Add2RawsList(hMultSPDhits2MultSPDhits1, 45+fGenRawsOffset, !expert, image, !saveCorr);
   fSPDhRawsTask++;
  
   AliDebug(1,Form("%d SPD Raws histograms booked\n",fSPDhRawsTask));
@@ -234,11 +238,14 @@ void AliITSQASPDDataMakerRec::MakeRaws(AliRawReader* rawReader)
 void AliITSQASPDDataMakerRec::InitRecPoints()
 {
   // Initialization for RECPOINTS - SPD -
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   fGenRecPointsOffset = (fAliITSQADataMakerRec->fRecPointsQAList[AliRecoParam::kDefault])->GetEntries();
   TH1F* hlayer= new TH1F("SPDLayPattern_SPD","Layer map - SPD",6,0.,6.);
   hlayer->GetXaxis()->SetTitle("Layer number");
   hlayer->GetYaxis()->SetTitle("Entries");
-  fAliITSQADataMakerRec->Add2RecPointsList(hlayer, 0+fGenRecPointsOffset, kTRUE); 
+  fAliITSQADataMakerRec->Add2RecPointsList(hlayer, 0+fGenRecPointsOffset, expert, !image); 
   fSPDhRecPointsTask++;
 
   TH1F** hmod = new TH1F*[2];
@@ -264,7 +271,7 @@ void AliITSQASPDDataMakerRec::InitRecPoints()
     hmod[iLay]=new TH1F(name,title,fgknSPDmodules,0,fgknSPDmodules);
     hmod[iLay]->GetXaxis()->SetTitle("Module number");
     hmod[iLay]->GetYaxis()->SetTitle("Entries");
-    fAliITSQADataMakerRec->Add2RecPointsList(hmod[iLay], 1+(10*iLay)+fGenRecPointsOffset, kTRUE); 
+    fAliITSQADataMakerRec->Add2RecPointsList(hmod[iLay], 1+(10*iLay)+fGenRecPointsOffset, expert, !image); 
     fSPDhRecPointsTask++;
 
     sprintf(name,"SPDxLoc_SPD%d",iLay+1);
@@ -272,7 +279,7 @@ void AliITSQASPDDataMakerRec::InitRecPoints()
     hxl[iLay]=new TH1F(name,title,100,-4.,4.);
     hxl[iLay]->GetXaxis()->SetTitle("Local x [cm]");
     hxl[iLay]->GetYaxis()->SetTitle("Entries");
-    fAliITSQADataMakerRec->Add2RecPointsList(hxl[iLay], 2+(10*iLay)+fGenRecPointsOffset, kTRUE);
+    fAliITSQADataMakerRec->Add2RecPointsList(hxl[iLay], 2+(10*iLay)+fGenRecPointsOffset, expert, !image);
     fSPDhRecPointsTask++;
 
     sprintf(name,"SPDzLoc_SPD%d",iLay+1);
@@ -280,7 +287,7 @@ void AliITSQASPDDataMakerRec::InitRecPoints()
     hzl[iLay]=new TH1F(name,title,100,-4.,4.);
     hzl[iLay]->GetXaxis()->SetTitle("Local z [cm]");
     hzl[iLay]->GetYaxis()->SetTitle("Entries");
-    fAliITSQADataMakerRec->Add2RecPointsList(hzl[iLay], 3+(10*iLay)+fGenRecPointsOffset, kTRUE); 
+    fAliITSQADataMakerRec->Add2RecPointsList(hzl[iLay], 3+(10*iLay)+fGenRecPointsOffset, expert, !image); 
     fSPDhRecPointsTask++;
 
     sprintf(name,"SPDxGlob_SPD%d",iLay+1);
@@ -288,7 +295,7 @@ void AliITSQASPDDataMakerRec::InitRecPoints()
     hxg[iLay]=new TH1F(name,title,100,-xlim[iLay],xlim[iLay]);
     hxg[iLay]->GetXaxis()->SetTitle("Global x [cm]");
     hxg[iLay]->GetYaxis()->SetTitle("Entries");
-    fAliITSQADataMakerRec->Add2RecPointsList(hxg[iLay],4+(10*iLay)+fGenRecPointsOffset, kTRUE);  
+    fAliITSQADataMakerRec->Add2RecPointsList(hxg[iLay],4+(10*iLay)+fGenRecPointsOffset, expert, !image);  
     fSPDhRecPointsTask++;
 
     sprintf(name,"SPDyGlob_SPD%d",iLay+1);
@@ -296,7 +303,7 @@ void AliITSQASPDDataMakerRec::InitRecPoints()
     hyg[iLay]=new TH1F(name,title,100,-xlim[iLay],xlim[iLay]);
     hyg[iLay]->GetXaxis()->SetTitle("Global y [cm]");
     hyg[iLay]->GetYaxis()->SetTitle("Entries");
-    fAliITSQADataMakerRec->Add2RecPointsList(hyg[iLay], 5+(10*iLay)+fGenRecPointsOffset, kTRUE); 
+    fAliITSQADataMakerRec->Add2RecPointsList(hyg[iLay], 5+(10*iLay)+fGenRecPointsOffset, expert, !image); 
     fSPDhRecPointsTask++;
 
     sprintf(name,"SPDzGlob_SPD%d",iLay+1);
@@ -304,7 +311,7 @@ void AliITSQASPDDataMakerRec::InitRecPoints()
     hzg[iLay]=new TH1F(name,title,150,-zlim[iLay],zlim[iLay]);
     hzg[iLay]->GetXaxis()->SetTitle("Global z [cm]");
     hzg[iLay]->GetYaxis()->SetTitle("Entries");
-    fAliITSQADataMakerRec->Add2RecPointsList(hzg[iLay], 6+(10*iLay)+fGenRecPointsOffset, kTRUE); 
+    fAliITSQADataMakerRec->Add2RecPointsList(hzg[iLay], 6+(10*iLay)+fGenRecPointsOffset, expert, !image); 
     fSPDhRecPointsTask++;
 
     sprintf(name,"SPDr_SPD%d",iLay+1);
@@ -312,7 +319,7 @@ void AliITSQASPDDataMakerRec::InitRecPoints()
     hr[iLay]=new TH1F(name,title,100,0.,10.);
     hr[iLay]->GetXaxis()->SetTitle("r [cm]");
     hr[iLay]->GetYaxis()->SetTitle("Entries");
-    fAliITSQADataMakerRec->Add2RecPointsList(hr[iLay], 7+(10*iLay)+fGenRecPointsOffset, kTRUE);  
+    fAliITSQADataMakerRec->Add2RecPointsList(hr[iLay], 7+(10*iLay)+fGenRecPointsOffset, expert, !image);  
     fSPDhRecPointsTask++;
 
     sprintf(name,"SPDphi_SPD%d",iLay+1);
@@ -320,7 +327,7 @@ void AliITSQASPDDataMakerRec::InitRecPoints()
     hphi[iLay]=new TH1F(name,title,1000,0.,2*TMath::Pi());
     hphi[iLay]->GetXaxis()->SetTitle("#varphi [rad]");
     hphi[iLay]->GetYaxis()->SetTitle("Entries");
-    fAliITSQADataMakerRec->Add2RecPointsList(hphi[iLay], 8+(10*iLay)+fGenRecPointsOffset, kTRUE);
+    fAliITSQADataMakerRec->Add2RecPointsList(hphi[iLay], 8+(10*iLay)+fGenRecPointsOffset, expert, !image);
     fSPDhRecPointsTask++;
     
     sprintf(name,"SPDSizeYvsZ_SPD%d",iLay+1);
@@ -328,7 +335,7 @@ void AliITSQASPDDataMakerRec::InitRecPoints()
     hNyNz[iLay]=new TH2F(name,title,100,0.,100.,100,0.,100.);
     hNyNz[iLay]->GetXaxis()->SetTitle("z length");
     hNyNz[iLay]->GetYaxis()->SetTitle("y length");
-    fAliITSQADataMakerRec->Add2RecPointsList(hNyNz[iLay], 9+(10*iLay)+fGenRecPointsOffset, kTRUE); 
+    fAliITSQADataMakerRec->Add2RecPointsList(hNyNz[iLay], 9+(10*iLay)+fGenRecPointsOffset, expert, !image); 
     fSPDhRecPointsTask++;
 
     sprintf(name,"SPDphi_z_SPD%d",iLay+1);
@@ -336,7 +343,7 @@ void AliITSQASPDDataMakerRec::InitRecPoints()
     hPhiZ[iLay]=new TH2F(name,title,150,-zlim[iLay],zlim[iLay],200,0.,2*TMath::Pi());
     hPhiZ[iLay]->GetXaxis()->SetTitle("Global z [cm]");
     hPhiZ[iLay]->GetYaxis()->SetTitle("#varphi [rad]");
-    fAliITSQADataMakerRec->Add2RecPointsList(hPhiZ[iLay], 10+(10*iLay)+fGenRecPointsOffset);
+    fAliITSQADataMakerRec->Add2RecPointsList(hPhiZ[iLay], 10+(10*iLay)+fGenRecPointsOffset, !expert, image);
     fSPDhRecPointsTask++;
 
   }
@@ -344,13 +351,13 @@ void AliITSQASPDDataMakerRec::InitRecPoints()
   TH2F *hrPhi=new TH2F("SPDr_phi_SPD","#varphi vs r - SPD",100,0.,10.,100,0.,2*TMath::Pi());
   hrPhi->GetXaxis()->SetTitle("r [cm]");
   hrPhi->GetYaxis()->SetTitle("#varphi [rad]");
-  fAliITSQADataMakerRec->Add2RecPointsList(hrPhi, 21+fGenRecPointsOffset, kTRUE);
+  fAliITSQADataMakerRec->Add2RecPointsList(hrPhi, 21+fGenRecPointsOffset, expert, !image);
   fSPDhRecPointsTask++;
 
   TH2F *hxy=new TH2F("SPDx_y_SPD","Global y vs x - SPD",200,-10.,10.,200,-10.,10.);
   hxy->GetXaxis()->SetTitle("Global x [cm]");
   hxy->GetYaxis()->SetTitle("Global y [cm]");
-  fAliITSQADataMakerRec->Add2RecPointsList(hxy, 22+fGenRecPointsOffset);
+  fAliITSQADataMakerRec->Add2RecPointsList(hxy, 22+fGenRecPointsOffset, !expert, image);
   fSPDhRecPointsTask++;
 
   for (Int_t iLay=0;iLay<2;iLay++) {
@@ -359,7 +366,7 @@ void AliITSQASPDDataMakerRec::InitRecPoints()
     hMultSPDcl[iLay]=new TH1F(name,title,200,0.,200.);
     hMultSPDcl[iLay]->GetXaxis()->SetTitle("Cluster multiplicity");
     hMultSPDcl[iLay]->GetYaxis()->SetTitle("Entries");
-    fAliITSQADataMakerRec->Add2RecPointsList(hMultSPDcl[iLay], 23+iLay+fGenRecPointsOffset);
+    fAliITSQADataMakerRec->Add2RecPointsList(hMultSPDcl[iLay], 23+iLay+fGenRecPointsOffset, !expert, image);
     fSPDhRecPointsTask++;
   } 
 
@@ -367,7 +374,7 @@ void AliITSQASPDDataMakerRec::InitRecPoints()
         new TH2F("SPDMultCorrelation_SPD","Cluster multiplicity correlation - SPD",200,0.,200.,200,0.,200.);
   hMultSPDcl2MultSPDcl1->GetXaxis()->SetTitle("Clusters multiplicity (Layer 1)");
   hMultSPDcl2MultSPDcl1->GetYaxis()->SetTitle("Clusters multiplicity (Layer 2)"); 
-  fAliITSQADataMakerRec->Add2RecPointsList(hMultSPDcl2MultSPDcl1, 25+fGenRecPointsOffset, kFALSE);
+  fAliITSQADataMakerRec->Add2RecPointsList(hMultSPDcl2MultSPDcl1, 25+fGenRecPointsOffset, !expert, image);
   fSPDhRecPointsTask++;
 
   AliDebug(1,Form("%d SPD Recs histograms booked\n",fSPDhRecPointsTask));
index 5b9c287..ca708e9 100644 (file)
@@ -104,6 +104,9 @@ void AliITSQASPDDataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/,
 void AliITSQASPDDataMakerSim::InitDigits()
 { 
   // Initialization for DIGIT data - SPD -
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ;
+  
   fGenOffsetD = (fAliITSQADataMakerSim->fDigitsQAList[AliRecoParam::kDefault])->GetEntries();
   //fSPDhDTask must be incremented by one unit every time a histogram is ADDED to the QA List
 
@@ -113,7 +116,7 @@ void AliITSQASPDDataMakerSim::InitDigits()
   TH1F *hlayer = new TH1F("SPDLayPattern_SPD","Layer map - SPD",6,0.,6.);
   hlayer->GetXaxis()->SetTitle("Layer number");
   hlayer->GetYaxis()->SetTitle("Entries");
-  fAliITSQADataMakerSim->Add2DigitsList(hlayer,fGenOffsetD,kTRUE);
+  fAliITSQADataMakerSim->Add2DigitsList(hlayer,fGenOffsetD, expert, !image);
   fSPDhDTask++;
   
   TH1F **hmod = new TH1F*[2];
@@ -123,20 +126,20 @@ void AliITSQASPDDataMakerSim::InitDigits()
     hmod[iLay]=new TH1F(name,title,240,0,240);
     hmod[iLay]->GetXaxis()->SetTitle("Module number");
     hmod[iLay]->GetYaxis()->SetTitle("Entries");
-    fAliITSQADataMakerSim->Add2DigitsList(hmod[iLay],1+iLay+fGenOffsetD);
+    fAliITSQADataMakerSim->Add2DigitsList(hmod[iLay],1+iLay+fGenOffsetD, !expert, image);
     fSPDhDTask++;
   }
   
   TH1F *hcolumns = new TH1F("SPDColumns_SPD","Columns - SPD",160,0.,160.);
   hcolumns->GetXaxis()->SetTitle("Column number");
   hcolumns->GetYaxis()->SetTitle("Entries");
-  fAliITSQADataMakerSim->Add2DigitsList(hcolumns,3+fGenOffsetD,kTRUE);
+  fAliITSQADataMakerSim->Add2DigitsList(hcolumns,3+fGenOffsetD, expert, !image);
   fSPDhDTask++;
 
   TH1F *hrows = new TH1F("SPDRows_SPD","Rows - SPD",256,0.,256.);
   hrows->GetXaxis()->SetTitle("Row number");
   hrows->GetYaxis()->SetTitle("Entries");
-  fAliITSQADataMakerSim->Add2DigitsList(hrows,4+fGenOffsetD,kTRUE);
+  fAliITSQADataMakerSim->Add2DigitsList(hrows,4+fGenOffsetD, expert, !image);
   fSPDhDTask++;
 
   TH1F** hMultSPDdigits = new TH1F*[2];
@@ -146,7 +149,7 @@ void AliITSQASPDDataMakerSim::InitDigits()
     hMultSPDdigits[iLay]=new TH1F(name,title,200,0.,200.);
     hMultSPDdigits[iLay]->GetXaxis()->SetTitle("Digit multiplicity");
     hMultSPDdigits[iLay]->GetYaxis()->SetTitle("Entries");
-    fAliITSQADataMakerSim->Add2DigitsList(hMultSPDdigits[iLay], 5+iLay+fGenOffsetD);
+    fAliITSQADataMakerSim->Add2DigitsList(hMultSPDdigits[iLay], 5+iLay+fGenOffsetD, !expert, image);
     fSPDhDTask++;
   }
 
@@ -154,7 +157,7 @@ void AliITSQASPDDataMakerSim::InitDigits()
        = new TH2F("SPDDigitMultCorrelation_SPD","Digit multiplicity correlation - SPD",200,0.,200.,200,0.,200.);
   hMultSPDdig2MultSPDdig1->GetXaxis()->SetTitle("Digit multiplicity (Layer 1)");
   hMultSPDdig2MultSPDdig1->GetYaxis()->SetTitle("Digit multiplicity (Layer 2)");
-  fAliITSQADataMakerSim->Add2DigitsList(hMultSPDdig2MultSPDdig1,7+fGenOffsetD);
+  fAliITSQADataMakerSim->Add2DigitsList(hMultSPDdig2MultSPDdig1,7+fGenOffsetD, !expert, image);
   fSPDhDTask++;
 
   AliDebug(1,Form("%d SPD Digits histograms booked\n",fSPDhDTask));
@@ -202,6 +205,9 @@ void AliITSQASPDDataMakerSim::MakeDigits(TTree *digits)
 void AliITSQASPDDataMakerSim::InitSDigits()
 { 
   // Initialization for SDIGIT data - SPD -
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ;
+  
   fGenOffsetS = (fAliITSQADataMakerSim->fSDigitsQAList[AliRecoParam::kDefault])->GetEntries();
   //printf("--W-- AliITSQASPDDataMakerSim::InitSDigits()  fGenOffset= %d \n",fGenOffset);
   //fSPDhSTask must be incremented by one unit every time a histogram is ADDED to the QA List
@@ -212,7 +218,7 @@ void AliITSQASPDDataMakerSim::InitSDigits()
   TH1F *hlayer = new TH1F("SPDLayPattern_SPD","Layer map - SPD",6,0.,6.);
   hlayer->GetXaxis()->SetTitle("Layer number");
   hlayer->GetYaxis()->SetTitle("Entries");
-  fAliITSQADataMakerSim->Add2SDigitsList(hlayer,fGenOffsetS,kTRUE);
+  fAliITSQADataMakerSim->Add2SDigitsList(hlayer,fGenOffsetS, expert, !image);
   fSPDhSTask++;
 
   TH1F **hmod = new TH1F*[2];
@@ -222,7 +228,7 @@ void AliITSQASPDDataMakerSim::InitSDigits()
     hmod[iLay]=new TH1F(name,title,240,0,240);
     hmod[iLay]->GetXaxis()->SetTitle("Module number");
     hmod[iLay]->GetYaxis()->SetTitle("Entries");
-    fAliITSQADataMakerSim->Add2SDigitsList(hmod[iLay],1+iLay+fGenOffsetS);
+    fAliITSQADataMakerSim->Add2SDigitsList(hmod[iLay],1+iLay+fGenOffsetS, !expert, image);
     fSPDhSTask++;
   }
 
@@ -257,6 +263,9 @@ void AliITSQASPDDataMakerSim::MakeSDigits(TTree *sdigits)
 void AliITSQASPDDataMakerSim::InitHits()
 { 
   // Initialization for HITS data - SPD -
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ;
+  
   fGenOffsetH = (fAliITSQADataMakerSim->fHitsQAList[AliRecoParam::kDefault])->GetEntries();
   //printf("--W-- AliITSQASPDDataMakerSim::InitHits()  fGenOffset= %d \n",fGenOffset);
   //fSPDhHTask must be incremented by one unit every time a histogram is ADDED to the QA List
@@ -266,7 +275,7 @@ void AliITSQASPDDataMakerSim::InitHits()
   TH1F *hlayer = new TH1F("SPDLayPattern_SPD","Layer map - SPD",6,0.,6.);
   hlayer->GetXaxis()->SetTitle("Layer number");
   hlayer->GetYaxis()->SetTitle("Entries");
-  fAliITSQADataMakerSim->Add2HitsList(hlayer,fGenOffsetH,kTRUE);
+  fAliITSQADataMakerSim->Add2HitsList(hlayer,fGenOffsetH, expert, !image);
   fSPDhHTask++;
 
   TH1F **hmod = new TH1F*[2];
@@ -276,20 +285,20 @@ void AliITSQASPDDataMakerSim::InitHits()
     hmod[iLay]=new TH1F(name,title,240,0,240);
     hmod[iLay]->GetXaxis()->SetTitle("Module number");
     hmod[iLay]->GetYaxis()->SetTitle("Entries");
-    fAliITSQADataMakerSim->Add2HitsList(hmod[iLay],1+iLay+fGenOffsetH);
+    fAliITSQADataMakerSim->Add2HitsList(hmod[iLay],1+iLay+fGenOffsetH, !expert, image);
     fSPDhHTask++;
   }
 
   TH1F *hhitlenght = new TH1F("SPDLenght_SPD","Hit lenght along y_{loc} coord",210,0.,210.);
   hhitlenght->GetXaxis()->SetTitle("Hit lenght [#mum]");
   hhitlenght->GetYaxis()->SetTitle("# hits");
-  fAliITSQADataMakerSim->Add2HitsList(hhitlenght,3+fGenOffsetH);
+  fAliITSQADataMakerSim->Add2HitsList(hhitlenght,3+fGenOffsetH, !expert, image);
   fSPDhHTask++;
 
   TH1F *hEdepos = new TH1F("SPDEnergyDeposit_SPD","Deposited energy distribution (y_{loc}>180 #mum)",150,0.,300.); 
   hEdepos->GetXaxis()->SetTitle("Deposited energy [keV]"); 
   hEdepos->GetYaxis()->SetTitle("# hits");
-  fAliITSQADataMakerSim->Add2HitsList(hEdepos,4+fGenOffsetH);
+  fAliITSQADataMakerSim->Add2HitsList(hEdepos,4+fGenOffsetH, !expert, image);
   fSPDhHTask++;
 
   AliDebug(1,Form("%d SPD Hits histograms booked\n",fSPDhHTask));
index b553c31..b697c91 100644 (file)
@@ -286,6 +286,10 @@ void AliITSQASSDDataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/,
 //____________________________________________________________________________ 
 void AliITSQASSDDataMakerRec::InitRaws() {  
   // Initialization for RAW data - SSD -
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t saveCorr = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+
   fGenRawsOffset = (fAliITSQADataMakerRec->fRawsQAList[AliRecoParam::kDefault])->GetEntries();
 
   if(fkOnline) {
@@ -301,30 +305,30 @@ void AliITSQASSDDataMakerRec::InitRaws() {
                                     ";Event type;Events",
                                     31,-1,30);
   fAliITSQADataMakerRec->Add2RawsList(fHistSSDEventType, 
-                                     fGenRawsOffset+fSSDRawsOffset, kTRUE);
+                                     fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
   fSSDRawsOffset += 1;
   TH1D *fHistSSDDataSize = new TH1D("SSD/DataSize/fHistSSDDataSize",
                                    ";log(SSD data size) [Bytes];Events",
                                    100,3,8);
   fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSize, 
-                                     fGenRawsOffset+fSSDRawsOffset, kTRUE);
+                                     fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
   fSSDRawsOffset += 1;
   TH1D *fHistSSDDataSizePercentage = new TH1D("SSD/DataSize/fHistSSDDataSizePercentage",
                                              ";SSD data size [%];Events",
                                              100,0,100);
   fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizePercentage, 
-                                     fGenRawsOffset+fSSDRawsOffset, kTRUE);
+                                     fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
   fSSDRawsOffset += 1;
   TH1D *fHistSSDDDLId = new TH1D("SSD/DDL/fHistSSDDDLId",
                                 ";DDL id;Events",20,510.5,530.5);
   fAliITSQADataMakerRec->Add2RawsList(fHistSSDDDLId, 
-                                     fGenRawsOffset+fSSDRawsOffset, kTRUE);
+                                     fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
   fSSDRawsOffset += 1;
   TH1D *fHistSSDDataSizePerDDL = new TH1D("SSD/DataSize/fHistSSDDataSizePerDDL",
                                          ";DDL id;<SSD data size> [MB]",
                                          20,510.5,530.5);
   fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizePerDDL, 
-                                     fGenRawsOffset+fSSDRawsOffset);
+                                     fGenRawsOffset+fSSDRawsOffset, !expert, image, !saveCorr);
   fSSDRawsOffset += 1;
   TH1D *fHistSSDDataSizeDDL[fgkNumOfDDLs];
   for(Int_t i = 1; i < fgkNumOfDDLs+1; i++) {
@@ -333,19 +337,19 @@ void AliITSQASSDDataMakerRec::InitRaws() {
                                        ";log(SSD data size) [Bytes];Events",
                                        100,1,8);
     fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizeDDL[i-1], 
-                                       fGenRawsOffset+fSSDRawsOffset, kTRUE);
+                                       fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
     fSSDRawsOffset += 1;
   }
   
   TH1D *fHistSSDLDCId = new TH1D("SSD/LDC/fHistSSDLDCId",";LDC id;Events",10,0.5,10.5);
   fAliITSQADataMakerRec->Add2RawsList(fHistSSDLDCId, 
-                                     fGenRawsOffset+fSSDRawsOffset, kTRUE);
+                                     fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
   fSSDRawsOffset += 1;
   TH1D *fHistSSDDataSizePerLDC = new TH1D("SSD/DataSize/fHistSSDDataSizePerLDC",
                                          ";LDC id;<SSD data size> [MB]",
                                          20,0.5,20.5);
   fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizePerLDC, 
-                                     fGenRawsOffset+fSSDRawsOffset);
+                                     fGenRawsOffset+fSSDRawsOffset, !expert, image, !saveCorr);
   fSSDRawsOffset += 1;
   TH1D *fHistSSDDataSizeLDC[fgkNumOfLDCs];
   for(Int_t i = 1; i < fgkNumOfLDCs+1; i++) {
@@ -357,7 +361,7 @@ void AliITSQASSDDataMakerRec::InitRaws() {
                                        ";log(SSD data size) [Bytes];Events",
                                        100,1,8);
     fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizeLDC[i-1], 
-                                       fGenRawsOffset+fSSDRawsOffset, kTRUE);
+                                       fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
     fSSDRawsOffset += 1;
   }
   fSSDRawsCommonLevelOffset = fSSDRawsOffset;
@@ -389,7 +393,7 @@ void AliITSQASSDDataMakerRec::InitRaws() {
       fHistSSDOccupancyModule[i-500]->GetXaxis()->SetTitle("N_{strip}");
       fHistSSDOccupancyModule[i-500]->GetYaxis()->SetTitle("Occupancy [%]");
       fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyModule[i-500], 
-                                         fGenRawsOffset+fSSDRawsOffset, kTRUE);
+                                         fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
       fSSDRawsOffset += 1;
     }
 
@@ -422,7 +426,7 @@ void AliITSQASSDDataMakerRec::InitRaws() {
        fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitle("Module number");
        fHistSSDOccupancyLadder[occupancyCounter]->GetYaxis()->SetTitle("Occupancy [%]");
        fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLadder[occupancyCounter], 
-                                           fGenRawsOffset+fSSDRawsOffset, kTRUE);
+                                           fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
        occupancyCounter += 1; fSSDRawsOffset += 1;
        //N-side occupancy plots
        gTitle = "SSD/Occupancy/Layer"; gTitle += iLayer;
@@ -448,7 +452,7 @@ void AliITSQASSDDataMakerRec::InitRaws() {
        fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitle("Module number");
        fHistSSDOccupancyLadder[occupancyCounter]->GetYaxis()->SetTitle("Occupancy [%]");
        fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLadder[occupancyCounter], 
-                                           fGenRawsOffset+fSSDRawsOffset, kTRUE);
+                                           fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
        occupancyCounter += 1; fSSDRawsOffset += 1;
       }//ladder loop
     }//layer loop
@@ -469,7 +473,7 @@ void AliITSQASSDDataMakerRec::InitRaws() {
       fHistSSDOccupancyLayer5->GetXaxis()->SetBinLabel(iBin,fLabel);
     }
     fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLayer5, 
-                                       fGenRawsOffset+fSSDRawsOffset, kTRUE);
+                                       fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
     fSSDRawsOffset += 1;
     TH2D *fHistSSDOccupancyLayer6 = new TH2D("SSD/Occupancy/Layer6/fHistSSDOccupancyLayer6",
                                             ";N_{modules};N_{Ladders}",
@@ -484,7 +488,7 @@ void AliITSQASSDDataMakerRec::InitRaws() {
       fHistSSDOccupancyLayer6->GetXaxis()->SetBinLabel(iBin,fLabel);
     }
     fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLayer6, 
-                                       fGenRawsOffset+fSSDRawsOffset, kTRUE);
+                                       fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
     fSSDRawsOffset += 1;
 
     //occupancy per module - threshold @ 3%
@@ -501,7 +505,7 @@ void AliITSQASSDDataMakerRec::InitRaws() {
       fHistSSDOccupancyThresholdLayer5->GetXaxis()->SetBinLabel(iBin,fLabel);
      }
      fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyThresholdLayer5, 
-                                        fGenRawsOffset+fSSDRawsOffset, kTRUE);
+                                        fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
     fSSDRawsOffset += 1;
     TH2D *fHistSSDOccupancyThresholdLayer6 = new TH2D("SSD/Occupancy/Layer6/fHistSSDOccupancyThresholdLayer6",
                                             ";N_{modules};N_{Ladders}",
@@ -516,7 +520,7 @@ void AliITSQASSDDataMakerRec::InitRaws() {
       fHistSSDOccupancyThresholdLayer6->GetXaxis()->SetBinLabel(iBin,fLabel);
     }
     fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyThresholdLayer6, 
-                                       fGenRawsOffset+fSSDRawsOffset, kTRUE);
+                                       fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
     fSSDRawsOffset += 1;
 
     //Average occupancy per module
@@ -548,7 +552,7 @@ void AliITSQASSDDataMakerRec::InitRaws() {
       fHistSSDAverageOccupancyLayer6->GetXaxis()->SetBinLabel(iBin,fLabel);
     }
     fAliITSQADataMakerRec->Add2RawsList(fHistSSDAverageOccupancyLayer6, 
-                                       fGenRawsOffset+fSSDRawsOffset);
+                                       fGenRawsOffset+fSSDRawsOffset, !expert, image, !saveCorr);
     fSSDRawsOffset += 1;
 
     //Output of the DA
@@ -566,7 +570,7 @@ void AliITSQASSDDataMakerRec::InitRaws() {
     fHistPSideBadChannelMapLayer5->GetZaxis()->SetTitleOffset(1.6);
     fHistPSideBadChannelMapLayer5->GetZaxis()->SetTitle("Bad channels (p-side)[%]");
     fAliITSQADataMakerRec->Add2RawsList(fHistPSideBadChannelMapLayer5, 
-                                       fGenRawsOffset+fSSDRawsOffset, kTRUE);
+                                       fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
     fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
 
     TH2D *fHistNSideBadChannelMapLayer5 = new TH2D("SSD/BadChannels/fHistNSideBadChannelMapLayer5",
@@ -583,7 +587,7 @@ void AliITSQASSDDataMakerRec::InitRaws() {
     fHistNSideBadChannelMapLayer5->GetZaxis()->SetTitleOffset(1.6);
     fHistNSideBadChannelMapLayer5->GetZaxis()->SetTitle("Bad channels (n-side)[%]");
     fAliITSQADataMakerRec->Add2RawsList(fHistNSideBadChannelMapLayer5, 
-                                       fGenRawsOffset+fSSDRawsOffset, kTRUE);
+                                       fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
     fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
 
     TH2D *fHistPSideBadChannelMapLayer6 = new TH2D("SSD/BadChannels/fHistPSideBadChannelMapLayer6",
@@ -600,7 +604,7 @@ void AliITSQASSDDataMakerRec::InitRaws() {
     fHistPSideBadChannelMapLayer6->GetZaxis()->SetTitleOffset(1.6);
     fHistPSideBadChannelMapLayer6->GetZaxis()->SetTitle("Bad channels (p-side)[%]");
     fAliITSQADataMakerRec->Add2RawsList(fHistPSideBadChannelMapLayer6, 
-                                       fGenRawsOffset+fSSDRawsOffset, kTRUE);
+                                       fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
     fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
 
     TH2D *fHistNSideBadChannelMapLayer6 = new TH2D("SSD/BadChannels/fHistNSideBadChannelMapLayer6",
@@ -617,7 +621,7 @@ void AliITSQASSDDataMakerRec::InitRaws() {
     fHistNSideBadChannelMapLayer6->GetZaxis()->SetTitleOffset(1.6);
     fHistNSideBadChannelMapLayer6->GetZaxis()->SetTitle("Bad channels (n-side)[%]");
     fAliITSQADataMakerRec->Add2RawsList(fHistNSideBadChannelMapLayer6, 
-                                       fGenRawsOffset+fSSDRawsOffset, kTRUE);
+                                       fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
     fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
   }//online flag
 
@@ -881,6 +885,9 @@ void AliITSQASSDDataMakerRec::MonitorOCDBObjects() {
 void AliITSQASSDDataMakerRec::InitRecPoints()
 {
   // Initialization for RECPOINTS - SSD -
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   fGenRecPointsOffset = (fAliITSQADataMakerRec->fRecPointsQAList[AliRecoParam::kDefault])->GetEntries();
   //AliInfo(Form("**-------*-*-*-*-*-*-***************AliITSQASSDataMakerRec::MakeRecpoints offset %d \t %d \n",fGenOffset,fGenRecPointsOffset));
   Int_t nModuleOffset = 500;
@@ -892,7 +899,7 @@ void AliITSQASSDDataMakerRec::InitRecPoints()
                                       nModuleOffset - 0.5,
                                       nITSTotalModules-fgkSSDMODULESLAYER6+0.5);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDModuleIdLayer5, 
-                                          fGenRecPointsOffset + 0, kTRUE);
+                                          fGenRecPointsOffset + 0, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDModuleIdLayer6 = new TH1F("SSD/Statistics/fHistSSDModuleIdLayer6",
                                       "Module Id - Layer 6;Module Id;Entries",
@@ -900,201 +907,201 @@ void AliITSQASSDDataMakerRec::InitRecPoints()
                                       nModuleOffset+fgkSSDMODULESLAYER5 - 0.5,
                                       nITSTotalModules + 0.5);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDModuleIdLayer6, 
-                                          fGenRecPointsOffset + 1, kTRUE);
+                                          fGenRecPointsOffset + 1, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDClusterPerEventLayer5 = new TH1F("SSD/Statistics/fHistSSDClusterPerEventLayer5",
                                              "N_{clusters} - Layer 5;N_{clusters};Entries;",
                                              100,0.1,5000);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDClusterPerEventLayer5,
-                                          fGenRecPointsOffset + 2, kTRUE);
+                                          fGenRecPointsOffset + 2, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDClusterPerEventLayer6 = new TH1F("SSD/Statistics/fHistSSDClusterPerEventLayer6",
                                              "N_{clusters} - Layer 6;N_{clusters};Entries;",
                                              100,0.1,5000);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDClusterPerEventLayer6,
-                                          fGenRecPointsOffset + 3, kTRUE);
+                                          fGenRecPointsOffset + 3, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDLocalXLayer5 = new TH1F("SSD/Coordinates/fHistSSDLocalXLayer5",
                                     "Local x coord.- Layer 5;x [cm];Entries;",
                                     100,-4.,4.);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDLocalXLayer5,
-                                          fGenRecPointsOffset + 4, kTRUE);
+                                          fGenRecPointsOffset + 4, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDLocalXLayer6 = new TH1F("SSD/Coordinates/fHistSSDLocalXLayer6",
                                     "Local x coord.- Layer 6;x [cm];Entries;",
                                     100,-4.,4.);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDLocalXLayer6, 
-                                          fGenRecPointsOffset + 5, kTRUE);
+                                          fGenRecPointsOffset + 5, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDLocalZLayer5 = new TH1F("SSD/Coordinates/fHistSSDLocalZLayer5",
                                     "Local z coord.- Layer 5;z [cm];Entries;",
                                     100,-4.,4.);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDLocalZLayer5, 
-                                          fGenRecPointsOffset + 6, kTRUE);
+                                          fGenRecPointsOffset + 6, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDLocalZLayer6 = new TH1F("SSD/Coordinates/fHistSSDLocalZLayer6",
                                     "Local z coord.- Layer 6;z [cm];Entries;",
                                     100,-4.,4.);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDLocalZLayer6, 
-                                          fGenRecPointsOffset + 7, kTRUE);
+                                          fGenRecPointsOffset + 7, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDGlobalXLayer5 = new TH1F("SSD/Coordinates/fHistSSDGlobalXLayer5",
                                      "Global x - Layer 5;x [cm];Entries;",
                                      100,-40.,40.);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDGlobalXLayer5, 
-                                          fGenRecPointsOffset + 8, kTRUE);
+                                          fGenRecPointsOffset + 8, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDGlobalXLayer6 = new TH1F("SSD/Coordinates/fHistSSDGlobalXLayer6",
                                      "Global x - Layer 6;x [cm];Entries;",
                                      100,-45.,45.);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDGlobalXLayer6, 
-                                          fGenRecPointsOffset + 9, kTRUE);
+                                          fGenRecPointsOffset + 9, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDGlobalYLayer5 = new TH1F("SSD/Coordinates/fHistSSDGlobalYLayer5",
                                      "Global y - Layer 5;y [cm];Entries;",
                                      100,-40.,40);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDGlobalYLayer5, 
-                                          fGenRecPointsOffset + 10, kTRUE);
+                                          fGenRecPointsOffset + 10, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDGlobalYLayer6 = new TH1F("SSD/Coordinates/fHistSSDGlobalYLayer6",
                                      "Global y - Layer 6;y [cm];Entries;",
                                      100,-45.,45.);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDGlobalYLayer6, 
-                                          fGenRecPointsOffset + 11, kTRUE);
+                                          fGenRecPointsOffset + 11, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDGlobalZLayer5 = new TH1F("SSD/Coordinates/fHistSSDGlobalZLayer5",
                                      "Global z - Layer 5;z [cm];Entries;",
                                      100,-45.,45);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDGlobalZLayer5, 
-                                          fGenRecPointsOffset + 12, kTRUE);
+                                          fGenRecPointsOffset + 12, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDGlobalZLayer6 = new TH1F("SSD/Coordinates/fHistSSDGlobalZLayer6",
                                      "Global z - Layer 6;z [cm];Entries;",
                                      100,-55.,55.);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDGlobalZLayer6, 
-                                          fGenRecPointsOffset + 13, kTRUE);
+                                          fGenRecPointsOffset + 13, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDPhiLayer5 = new TH1F("SSD/Coordinates/fHistSSDPhiLayer5",
                                  "#phi - Layer 5;#phi [rad];Entries;",
                                  100,-TMath::Pi(),TMath::Pi());
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDPhiLayer5, 
-                                          fGenRecPointsOffset + 14, kTRUE);
+                                          fGenRecPointsOffset + 14, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDPhiLayer6 = new TH1F("SSD/Coordinates/fHistSSDPhiLayer6",
                                  "#phi - Layer 6;#phi [rad];Entries;",
                                  100,-TMath::Pi(),TMath::Pi());
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDPhiLayer6, 
-                                          fGenRecPointsOffset + 15, kTRUE);
+                                          fGenRecPointsOffset + 15, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDThetaLayer5 = new TH1F("SSD/Coordinates/fHistSSDThetaLayer5",
                                    "#theta - Layer 5;#theta [rad];Entries;",
                                    100,-TMath::Pi(),TMath::Pi());
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDThetaLayer5, 
-                                          fGenRecPointsOffset + 16, kTRUE);
+                                          fGenRecPointsOffset + 16, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDThetaLayer6 = new TH1F("SSD/Coordinates/fHistSSDThetaLayer6",
                                    "#theta - Layer 6;#theta [rad];Entries;",
                                    100,-TMath::Pi(),TMath::Pi());
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDThetaLayer6, 
-                                          fGenRecPointsOffset + 17, kTRUE);
+                                          fGenRecPointsOffset + 17, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDRadiusLayer5 = new TH1F("SSD/Coordinates/fHistSSDRadiusLayer5",
                                     "r - Layer 5;r [cm];Entries;",
                                     100,35.,50.);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDRadiusLayer5, 
-                                          fGenRecPointsOffset + 18, kTRUE);
+                                          fGenRecPointsOffset + 18, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDRadiusLayer6 = new TH1F("SSD/Coordinates/fHistSSDRadiusLayer6",
                                     "r - Layer 6;r [cm];Entries;",
                                     100,35.,50.);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDRadiusLayer6, 
-                                          fGenRecPointsOffset + 19, kTRUE);
+                                          fGenRecPointsOffset + 19, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDClusterTypeLayer5 = new TH1F("SSD/ClusterCharge/Layer5/fHistSSDClusterTypeLayer5",
                                          "CL type - Layer 5;Cluster type;Entries;",
                                          150,0,150);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDClusterTypeLayer5, 
-                                          fGenRecPointsOffset + 20, kTRUE);
+                                          fGenRecPointsOffset + 20, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDClusterTypeLayer6 = new TH1F("SSD/ClusterCharge/Layer6/fHistSSDClusterTypeLayer6",
                                          "CL type - Layer 6;Cluster type;Entries;",
                                          150,0,150);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDClusterTypeLayer6, 
-                                          fGenRecPointsOffset + 21, kTRUE);
+                                          fGenRecPointsOffset + 21, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDChargeRatioLayer5 = new TH1F("SSD/ClusterCharge/Layer5/fHistSSDChargeRatioLayer5",
                                          "Charge ratio - Layer 5;q_{ratio};Entries;",
                                          100,-2.0,2.0);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeRatioLayer5, 
-                                          fGenRecPointsOffset + 22, kTRUE);
+                                          fGenRecPointsOffset + 22, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDChargeRatioLayer6 = new TH1F("SSD/ClusterCharge/Layer6/fHistSSDChargeRatioLayer6",
                                          "Charge ratio - Layer 6;q_{ratio};Entries;",
                                          100,-2.0,2.0);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeRatioLayer6, 
-                                          fGenRecPointsOffset + 23, kTRUE);
+                                          fGenRecPointsOffset + 23, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDChargekeVLayer5 = new TH1F("SSD/ClusterCharge/Layer5/fHistSSDChargekeVLayer5",
                                        "Charge - Layer 5;q [keV];Entries;",
                                        100,0.,300.);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargekeVLayer5, 
-                                          fGenRecPointsOffset + 24);
+                                          fGenRecPointsOffset + 24, !expert, image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDChargekeVLayer6 = new TH1F("SSD/ClusterCharge/Layer6/fHistSSDChargekeVLayer6",
                                        "Charge - Layer 6;q [keV];Entries;",
                                        100,0.,300.);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargekeVLayer6, 
-                                          fGenRecPointsOffset + 25);
+                                          fGenRecPointsOffset + 25, !expert, image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDChargePSideLayer5 = new TH1F("SSD/ClusterCharge/Layer5/fHistSSDChargePSideLayer5",
                                           "Charge P- Layer 5;q_{P} [keV];Entries;",
                                           100,0.,300.);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargePSideLayer5,
-                                          fGenRecPointsOffset + 26, kTRUE);
+                                          fGenRecPointsOffset + 26, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDChargePSideLayer6 = new TH1F("SSD/ClusterCharge/Layer6/fHistSSDChargePSideLayer6",
                                           "Charge P- Layer 6;q_{P} [keV];Entries;",
                                           100,0.,300.);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargePSideLayer6,
-                                          fGenRecPointsOffset + 27, kTRUE);
+                                          fGenRecPointsOffset + 27, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDChargeNSideLayer5 = new TH1F("SSD/ClusterCharge/Layer5/fHistSSDChargeNSideLayer5",
                                           "Charge N- Layer 5;q_{N} [keV];Entries;",
                                           100,0.,300.);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeNSideLayer5,
-                                          fGenRecPointsOffset + 28, kTRUE);
+                                          fGenRecPointsOffset + 28, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDChargeNSideLayer6 = new TH1F("SSD/ClusterCharge/Layer6/fHistSSDChargeNSideLayer6",
                                           "Charge N- Layer 6;q_{N} [keV];Entries;",
                                           100,0.,300.);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeNSideLayer6,
-                                          fGenRecPointsOffset + 29, kTRUE);
+                                          fGenRecPointsOffset + 29, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDChargeRatio2Layer5 = new TH1F("SSD/ClusterCharge/Layer5/fHistSSDChargeRatio2Layer5",
                                           "Charge Ratio qN/qP - Layer 5;q_{N}/q_{P};Entries;",
                                           100,0,2);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeRatio2Layer5,
-                                          fGenRecPointsOffset + 30, kTRUE);
+                                          fGenRecPointsOffset + 30, expert, !image);
   fSSDhRecPointsTask += 1;
   TH1F *fHistSSDChargeRatio2Layer6 = new TH1F("SSD/ClusterCharge/Layer6/fHistSSDChargeRatio2Layer6",
                                           "Charge Ratio qN/qP - Layer 6;q_{N}/q_{P};Entries;",
                                           100,0,2);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeRatio2Layer6,
-                                          fGenRecPointsOffset + 31, kTRUE);
+                                          fGenRecPointsOffset + 31, expert, !image);
   fSSDhRecPointsTask += 1;
   TH2F *fHistSSDChargePNSideLayer5 = new TH2F("SSD/ClusterCharge/Layer5/fHistSSDChargePNSideLayer5",
                                            "Charge correlation - Layer 5;q_{P} [keV];q_{N} [keV]",
                                            100,0.,300.,
                                            100,0.,300.);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargePNSideLayer5,
-                                          fGenRecPointsOffset + 32, kTRUE);
+                                          fGenRecPointsOffset + 32, expert, !image);
   fSSDhRecPointsTask += 1;
   TH2F *fHistSSDChargePNSideLayer6 = new TH2F("SSD/ClusterCharge/Layer6/fHistSSDChargePNSideLayer6",
                                            "Charge correlation - Layer 6;q_{P} [keV];q_{N} [keV]",
                                            100,0.,300.,
                                            100,0.,300.);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargePNSideLayer6,
-                                          fGenRecPointsOffset + 33, kTRUE);
+                                          fGenRecPointsOffset + 33, expert, !image);
   fSSDhRecPointsTask += 1;
   TH2F *fHistSSDChargeMapLayer5 = new TH2F("SSD/ClusterCharge/Layer5/fHistSSDChargeMapLayer5",
                                        "Charge map;N_{modules};N_{Ladders}",
@@ -1103,7 +1110,7 @@ void AliITSQASSDDataMakerRec::InitRecPoints()
                                        3*fgkSSDLADDERSLAYER5,
                                        -0.5,fgkSSDLADDERSLAYER5+0.5);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeMapLayer5, 
-                                          fGenRecPointsOffset + 34, kTRUE);
+                                          fGenRecPointsOffset + 34, expert, !image);
   fSSDhRecPointsTask += 1;
   TH2F *fHistSSDChargeMapLayer6 = new TH2F("SSD/ClusterCharge/Layer6/fHistSSDChargeMapLayer6",
                                        "Charge map;N_{modules};N_{Ladders}",
@@ -1112,7 +1119,7 @@ void AliITSQASSDDataMakerRec::InitRecPoints()
                                        3*fgkSSDLADDERSLAYER6,
                                        -0.5,fgkSSDLADDERSLAYER6+0.5);
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeMapLayer6, 
-                                          fGenRecPointsOffset + 35, kTRUE);
+                                          fGenRecPointsOffset + 35, expert, !image);
   fSSDhRecPointsTask += 1;
   TH2F *fHistSSDClusterMapLayer5 = new TH2F("SSD/Statistics/Layer5/fHistSSDClusterMapLayer5",
                                          "Layer 5;N_{module};N_{ladder}",
@@ -1128,7 +1135,7 @@ void AliITSQASSDDataMakerRec::InitRecPoints()
   fHistSSDClusterMapLayer5->GetZaxis()->SetTitleOffset(1.4);
   fHistSSDClusterMapLayer5->GetZaxis()->SetTitle("N_{clusters}");
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDClusterMapLayer5,
-                                          fGenRecPointsOffset + 36);
+                                          fGenRecPointsOffset + 36, !expert, image);
   fSSDhRecPointsTask += 1;
   TH2F *fHistSSDClusterMapLayer6 = new TH2F("SSD/Statistics/Layer6/fHistSSDClusterMapLayer6",
                                          "Layer 6;N_{module};N_{ladder}",
@@ -1144,7 +1151,7 @@ void AliITSQASSDDataMakerRec::InitRecPoints()
   fHistSSDClusterMapLayer6->GetZaxis()->SetTitleOffset(1.4);
   fHistSSDClusterMapLayer6->GetZaxis()->SetTitle("N_{clusters}");
   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDClusterMapLayer6,
-                                           fGenRecPointsOffset + 37);
+                                           fGenRecPointsOffset + 37, !expert, image);
   fSSDhRecPointsTask += 1;
   //printf ("%d SSD Recs histograms booked\n",fSSDhRecPointsTask);
   AliDebug(1,Form("%d SSD Recs histograms booked\n",fSSDhRecPointsTask));
index 93b0f68..e54474c 100644 (file)
@@ -104,6 +104,9 @@ void AliITSQASSDDataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/,
 //____________________________________________________________________________ 
 void AliITSQASSDDataMakerSim::InitDigits() { 
   // Initialization for DIGIT data - SSD -
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   fGenOffsetD = (fAliITSQADataMakerSim->fDigitsQAList[AliRecoParam::kDefault])->GetEntries();
 
   // custom code here
@@ -111,13 +114,13 @@ void AliITSQASSDDataMakerSim::InitDigits() {
                                  ";SSD Module Number;N_{DIGITS}",
                                  1698,499.5,2197.5);  
   fAliITSQADataMakerSim->Add2DigitsList(fHistSSDModule,
-                                       fGenOffsetD + 0);
+                                       fGenOffsetD + 0, !expert, image);
   fSSDhDTask += 1;
   TH2F *fHistSSDModuleStrip = new TH2F("fHistSSDDigitsModuleStrip",
                                       ";N_{Strip};N_{Module}",
                                       1540,0,1540,1698,499.5,2197.5);  
   fAliITSQADataMakerSim->Add2DigitsList(fHistSSDModuleStrip,
-                                       fGenOffsetD + 1);
+                                       fGenOffsetD + 1, !expert, image);
   fSSDhDTask += 1;
 
   AliDebug(1,Form("%d SSD Digits histograms booked\n",fSSDhDTask));
@@ -149,6 +152,9 @@ void AliITSQASSDDataMakerSim::MakeDigits(TTree *digits) {
 //____________________________________________________________________________ 
 void AliITSQASSDDataMakerSim::InitSDigits() { 
   // Initialization for SDIGIT data - SSD -
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   fGenOffsetS = (fAliITSQADataMakerSim->fSDigitsQAList[AliRecoParam::kDefault])->GetEntries();
 
   // custom code here
@@ -156,7 +162,7 @@ void AliITSQASSDDataMakerSim::InitSDigits() {
                                  ";SSD Module Number;N_{SDIGITS}",
                                  1698,499.5,2197.5);  
   fAliITSQADataMakerSim->Add2SDigitsList(fHistSSDModule,
-                                        fGenOffsetS + 0);
+                                        fGenOffsetS + 0, !expert, image);
   fSSDhSTask += 1;  
 
   AliDebug(1,Form("%d SSD SDigits histograms booked\n",fSSDhSTask));
@@ -191,6 +197,9 @@ void AliITSQASSDDataMakerSim::MakeSDigits(TTree *sdigits) {
 //____________________________________________________________________________ 
 void AliITSQASSDDataMakerSim::InitHits() { 
   // Initialization for HITS data - SSD -
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   fGenOffsetH = (fAliITSQADataMakerSim->fHitsQAList[AliRecoParam::kDefault])->GetEntries();
 
   // custom code here
@@ -198,56 +207,56 @@ void AliITSQASSDDataMakerSim::InitHits() {
                                  ";SDD Module Number;N_{HITS}",
                                  1698,499.5,2197.5); 
   fAliITSQADataMakerSim->Add2HitsList(fHistSSDModule,
-                                     fGenOffsetH + 0);
+                                     fGenOffsetH + 0, !expert, image);
   fSSDhHTask += 1;
   TH1F *fHistSSDGlobalX = new TH1F("fHistSSDHitsGlobalX",
                                   ";x [cm];Entries",
                                   1000,-50.,50.);
   fAliITSQADataMakerSim->Add2HitsList(fHistSSDGlobalX,
-                                     fGenOffsetH + 1);
+                                     fGenOffsetH + 1, !expert, image);
   fSSDhHTask += 1;
   TH1F *fHistSSDGlobalY = new TH1F("fHistSSDHitsGlobalY",
                                   ";y [cm];Entries",
                                   1000,-50.,50.);
   fAliITSQADataMakerSim->Add2HitsList(fHistSSDGlobalY,
-                                     fGenOffsetH + 2);
+                                     fGenOffsetH + 2, !expert, image);
   fSSDhHTask += 1;
   TH1F *fHistSSDGlobalZ = new TH1F("fHistSSDHitsGlobalZ",
                                   ";z [cm];Entries",
                                   1000,-60.,60.);
   fAliITSQADataMakerSim->Add2HitsList(fHistSSDGlobalZ,
-                                     fGenOffsetH + 3);
+                                     fGenOffsetH + 3, !expert, image);
   fSSDhHTask += 1;
   TH1F *fHistSSDLocalX = new TH1F("fHistSSDHitsLocalX",
                                  ";x [cm];Entries",
                                  1000,-4.,4.);
   fAliITSQADataMakerSim->Add2HitsList(fHistSSDLocalX,
-                                     fGenOffsetH + 4);
+                                     fGenOffsetH + 4, !expert, image);
   fSSDhHTask += 1;
   TH1F *fHistSSDLocalY = new TH1F("fHistSSDHitsLocalY",
                                  ";y [cm];Entries",
                                  1000,-0.1,0.1);
   fAliITSQADataMakerSim->Add2HitsList(fHistSSDLocalY,
-                                     fGenOffsetH + 5);
+                                     fGenOffsetH + 5, !expert, image);
   fSSDhHTask += 1;
   TH1F *fHistSSDLocalZ = new TH1F("fHistSSDHitsLocalZ",
                                  ";z [cm];Entries",
                                  1000,-4.,4.);
   fAliITSQADataMakerSim->Add2HitsList(fHistSSDLocalZ,
-                                     fGenOffsetH + 6);
+                                     fGenOffsetH + 6, !expert, image);
   fSSDhHTask += 1;
   TH1F *fHistSSDIonization = new TH1F("fHistSSDHitsIonization",
                                      ";log(dE/dx) [KeV];N_{Hits}",
                                      100,-7,-2);
   fAliITSQADataMakerSim->Add2HitsList(fHistSSDIonization,
-                                     fGenOffsetH + 7 );
+                                     fGenOffsetH + 7, !expert, image);
   fSSDhHTask += 1;
   TH2F *fHistSSDGlobalXY = new TH2F("fHistSSDHitsGlobalXY",
                                    ";x [cm];y [cm]",
                                    1000,-50.,50.,
                                    1000,-50.,50.);
   fAliITSQADataMakerSim->Add2HitsList(fHistSSDGlobalXY,
-                                     fGenOffsetH + 8 );
+                                     fGenOffsetH + 8, !expert, image);
   fSSDhHTask += 1;
  
   AliDebug(1,Form("%d SSD Hits histograms booked\n",fSSDhHTask));
index b343c9f..338d20c 100644 (file)
@@ -441,7 +441,9 @@ void AliMUONQADataMakerRec::InitRaws()
        
   AliCodeTimerAuto("");
   
-  Bool_t forExpert(kTRUE);
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t saveCorr = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
   
        if ( ! AliCDBManager::Instance()->GetDefaultStorage() )
        {
@@ -456,7 +458,7 @@ void AliMUONQADataMakerRec::InitRaws()
        h3->GetXaxis()->SetTitle("Chamber");
        h3->GetYaxis()->SetTitle("Board");
        h3->GetZaxis()->SetTitle("Strip");
-       Add2RawsList(h3, kTriggerScalersBP,forExpert);
+       Add2RawsList(h3, kTriggerScalersBP, expert, !image, !saveCorr);
        
        TH3F* h4 = new TH3F("hTriggerScalersNonBendPlane", "Trigger scalers in non-bending plane",
                                                                                        4, 10.5, 14.5,
@@ -465,7 +467,7 @@ void AliMUONQADataMakerRec::InitRaws()
        h4->GetXaxis()->SetTitle("Chamber");
        h4->GetYaxis()->SetTitle("Board");
        h4->GetZaxis()->SetTitle("Strip");
-       Add2RawsList(h4, kTriggerScalersNBP,forExpert);
+       Add2RawsList(h4, kTriggerScalersNBP, expert, !image, !saveCorr);
        
        AliMUONTriggerDisplay triggerDisplay;
        TString histoName, histoTitle;
@@ -476,7 +478,7 @@ void AliMUONQADataMakerRec::InitRaws()
                        histoTitle = Form("Chamber %i: Scalers %s", 11+iChamber, cathName.Data());
                        TH2F* h5 = (TH2F*)triggerDisplay.GetEmptyDisplayHisto(histoName, AliMUONTriggerDisplay::kDisplayStrips, 
                                                                              iCath, iChamber, histoTitle);
-                       Add2RawsList(h5, kTriggerScalersDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber,!forExpert);
+                       Add2RawsList(h5, kTriggerScalersDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber, !expert, image, !saveCorr);
                }
        }
 
@@ -485,21 +487,21 @@ void AliMUONQADataMakerRec::InitRaws()
                            18, -0.5, 17.5);
        h6->GetXaxis()->SetTitle("Chamber");
        h6->GetYaxis()->SetTitle("RPC");
-       Add2RawsList(h6, kTriggerRPCi, forExpert);
+       Add2RawsList(h6, kTriggerRPCi, expert, !image, !saveCorr);
 
        TH2F* h7 = new TH2F("hTriggerRPCHV", "Trigger RPC HV",
                            4, 10.5, 14.5,
                            18, -0.5, 17.5);
        h7->GetXaxis()->SetTitle("Chamber");
        h7->GetYaxis()->SetTitle("RPC");
-       Add2RawsList(h7, kTriggerRPChv, forExpert);
+       Add2RawsList(h7, kTriggerRPChv, expert, !image, !saveCorr);
        
        for(Int_t iChamber=0; iChamber<AliMpConstants::NofTriggerChambers(); iChamber++){
          histoName = Form("hRPCIChamber%i", 11+iChamber);
          histoTitle = Form("Chamber %i: RPC Currents (#muA)", 11+iChamber);
          TH2F* h8 = (TH2F*)triggerDisplay.GetEmptyDisplayHisto(histoName, AliMUONTriggerDisplay::kDisplaySlats, 
                                                                0, iChamber, histoTitle);
-         Add2RawsList(h8, kTriggerIDisplay + iChamber, !forExpert);
+         Add2RawsList(h8, kTriggerIDisplay + iChamber, !expert, image, !saveCorr);
        }
 
        for(Int_t iChamber=0; iChamber<AliMpConstants::NofTriggerChambers(); iChamber++){
@@ -507,13 +509,13 @@ void AliMUONQADataMakerRec::InitRaws()
          histoTitle = Form("Chamber %i: RPC HV (V)", 11+iChamber);
          TH2F* h9 = (TH2F*)triggerDisplay.GetEmptyDisplayHisto(histoName, AliMUONTriggerDisplay::kDisplaySlats, 
                                                                0, iChamber, histoTitle);
-         Add2RawsList(h9, kTriggerHVDisplay + iChamber, !forExpert);
+         Add2RawsList(h9, kTriggerHVDisplay + iChamber, !expert, image, !saveCorr);
        }
 
        TH1F* h10 = new TH1F("hTriggerScalersTime", "Trigger scalers acquisition time", 1, 0.5, 1.5);
        h10->GetXaxis()->SetBinLabel(1, "One-bin histogram: bin is filled at each scaler event.");
        h10->GetYaxis()->SetTitle("Cumulated scaler time (s)");
-       Add2RawsList(h10, kTriggerScalersTime, !forExpert);
+       Add2RawsList(h10, kTriggerScalersTime, !expert, image, !saveCorr);
        
   Int_t nbp(0);
   TIter next(AliMpDDLStore::Instance()->CreateBusPatchIterator());
@@ -525,7 +527,7 @@ void AliMUONQADataMakerRec::InitRaws()
   TH1* hbp = new TH1F("hTrackerBusPatchOccupancy","Occupancy of bus patches",
                       nbp,-0.5,nbp-0.5);
   
-  Add2RawsList(hbp,kTrackerBusPatchOccupancy,!forExpert);
+  Add2RawsList(hbp,kTrackerBusPatchOccupancy, !expert, image, !saveCorr);
 
   const Bool_t histogram(kFALSE);
 
@@ -560,10 +562,11 @@ void AliMUONQADataMakerRec::InitRecPointsTracker()
 {
   /// create Reconstructed Points histograms in RecPoints subdir for the
   /// MUON tracker subsystem.
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
   
   AliCodeTimerAuto("");
   
-  Bool_t forExpert(kTRUE);
   TH1I *h1I;
   TH1F *h1F;
   TH2F *h2F;
@@ -573,43 +576,43 @@ void AliMUONQADataMakerRec::InitRecPointsTracker()
   for ( Int_t i = 0; i < nCh; ++i ) 
   {
     h1I = new TH1I(Form("hTrackerClusterMultiplicityForChamber%d",i+1), Form("cluster size distribution in chamber %d;size (n_{pads})",i+1), 100,0,100);
-    Add2RecPointsList(h1I,kTrackerClusterMultiplicityPerChamber+i,forExpert);
+    Add2RecPointsList(h1I,kTrackerClusterMultiplicityPerChamber+i, expert, !image);
     
     h1I = new TH1I(Form("hTrackerClusterChargeForChamber%d",i+1), Form("cluster charge distribution in chamber %d;charge (ADC counts)",i+1), 500,0,5000);
-    Add2RecPointsList(h1I,kTrackerClusterChargePerChamber+i,forExpert);
+    Add2RecPointsList(h1I,kTrackerClusterChargePerChamber+i, expert, !image);
     
     Float_t rMax = AliMUONConstants::Rmax(i/2);
     h2F = new TH2F(Form("hTrackerClusterHitMapForChamber%d",i+1), Form("cluster position distribution in chamber %d;X (cm);Y (cm)",i+1), 100, -rMax, rMax, 100, -rMax, rMax);
-    Add2RecPointsList(h2F, kTrackerClusterHitMapPerChamber+i,forExpert);
+    Add2RecPointsList(h2F, kTrackerClusterHitMapPerChamber+i, expert, !image);
   }
   
   // summary histograms per chamber
   h1I = new TH1I("hTrackerNumberOfClustersPerChamber", "Number of clusters per chamber;chamber ID;n_{clusters}", nCh,-0.5,nCh-0.5);
-  Add2RecPointsList(h1I,kTrackerNumberOfClustersPerChamber,forExpert);
+  Add2RecPointsList(h1I,kTrackerNumberOfClustersPerChamber, expert, !image);
   
   h1F = new TH1F("hTrackerClusterMultiplicityPerChMean", "cluster mean size per chamber;chamber ID;<size> (n_{pads})", nCh,-0.5,nCh-0.5);
   h1F->SetOption("P");
   h1F->SetMarkerStyle(kFullDotMedium);
   h1F->SetMarkerColor(kRed);
-  Add2RecPointsList(h1F, kTrackerClusterMultiplicityPerChMean,forExpert);
+  Add2RecPointsList(h1F, kTrackerClusterMultiplicityPerChMean, expert, !image);
   
   h1F = new TH1F("hTrackerClusterMultiplicityPerChSigma", "cluster size dispersion per chamber;chamber ID;#sigma_{size} (n_{pads})", nCh,-0.5,nCh-0.5);
   h1F->SetOption("P");
   h1F->SetMarkerStyle(kFullDotMedium);
   h1F->SetMarkerColor(kRed);
-  Add2RecPointsList(h1F, kTrackerClusterMultiplicityPerChSigma,forExpert);
+  Add2RecPointsList(h1F, kTrackerClusterMultiplicityPerChSigma, expert, !image);
   
   h1F = new TH1F("hTrackerClusterChargePerChMean", "cluster mean charge per chamber;chamber ID;<charge> (ADC counts)", nCh,-0.5,nCh-0.5);
   h1F->SetOption("P");
   h1F->SetMarkerStyle(kFullDotMedium);
   h1F->SetMarkerColor(kRed);
-  Add2RecPointsList(h1F, kTrackerClusterChargePerChMean,forExpert);
+  Add2RecPointsList(h1F, kTrackerClusterChargePerChMean, expert, !image);
   
   h1F = new TH1F("hTrackerClusterChargePerChSigma", "cluster charge dispersion per chamber;chamber ID;#sigma_{charge} (ADC counts)", nCh,-0.5,nCh-0.5);
   h1F->SetOption("P");
   h1F->SetMarkerStyle(kFullDotMedium);
   h1F->SetMarkerColor(kRed);
-  Add2RecPointsList(h1F, kTrackerClusterChargePerChSigma,forExpert);
+  Add2RecPointsList(h1F, kTrackerClusterChargePerChSigma, expert, !image);
   
   // histograms per DE
   Int_t ndes(0);
@@ -624,10 +627,10 @@ void AliMUONQADataMakerRec::InitRecPointsTracker()
       ndes = TMath::Max(ndes,detElemId);
       
       h1I = new TH1I(Form("hTrackerClusterMultiplicityForDE%04d",detElemId), Form("cluster size distribution in detection element %d;size (n_{pads})",detElemId), 100,0,100);
-      Add2RecPointsList(h1I,kTrackerClusterMultiplicityPerDE+detElemId,forExpert);
+      Add2RecPointsList(h1I,kTrackerClusterMultiplicityPerDE+detElemId, expert, !image);
       
       h1I = new TH1I(Form("hTrackerClusterChargeForDE%04d",detElemId), Form("cluster charge distribution in detection element %d;charge (ADC counts)",detElemId), 500,0,5000);
-      Add2RecPointsList(h1I,kTrackerClusterChargePerDE+detElemId,forExpert);
+      Add2RecPointsList(h1I,kTrackerClusterChargePerDE+detElemId, expert, !image);
     }
     
     it.Next();
@@ -635,19 +638,19 @@ void AliMUONQADataMakerRec::InitRecPointsTracker()
   
   // summary histograms per DE
   h1I = new TH1I("hTrackerNumberOfClustersPerDE", "Number of clusters per detection element;DetElem ID;n_{clusters}", ndes+1,-0.5,ndes+0.5);
-  Add2RecPointsList(h1I, kTrackerNumberOfClustersPerDE,!forExpert);
+  Add2RecPointsList(h1I, kTrackerNumberOfClustersPerDE, !expert, image);
   
   h1F = new TH1F("hTrackerClusterMultiplicityPerDEMean", "cluster mean size per DE;DetElem ID;<size> (n_{pads})", ndes+1,-0.5,ndes+0.5);
   h1F->SetOption("P");
   h1F->SetMarkerStyle(kFullDotMedium);
   h1F->SetMarkerColor(kRed);
-  Add2RecPointsList(h1F, kTrackerClusterMultiplicityPerDEMean,forExpert);
+  Add2RecPointsList(h1F, kTrackerClusterMultiplicityPerDEMean, expert, !image);
   
   h1F = new TH1F("hTrackerClusterChargePerDEMean", "cluster mean charge per DE;DetElem ID;<charge> (ADC counts)", ndes+1,-0.5,ndes+0.5);
   h1F->SetOption("P");
   h1F->SetMarkerStyle(kFullDotMedium);
   h1F->SetMarkerColor(kRed);
-  Add2RecPointsList(h1F, kTrackerClusterChargePerDEMean,forExpert);
+  Add2RecPointsList(h1F, kTrackerClusterChargePerDEMean, expert, !image);
   
   fIsInitRecPointsTracker=kTRUE;
 }
@@ -658,7 +661,8 @@ void AliMUONQADataMakerRec::InitRecPointsTrigger()
        /// create Reconstructed Points histograms in RecPoints subdir for the
        /// MUON Trigger subsystem.
        
-  Bool_t forExpert(kTRUE);
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
   
     TH3F* h0 = new TH3F("hTriggerDigitsBendPlane", "Trigger digits in bending plane",
                        4, 10.5, 14.5,
@@ -667,7 +671,7 @@ void AliMUONQADataMakerRec::InitRecPointsTrigger()
     h0->GetXaxis()->SetTitle("Chamber");
     h0->GetYaxis()->SetTitle("Board");
     h0->GetZaxis()->SetTitle("Strip");
-    Add2RecPointsList(h0, kTriggerDigitsBendPlane,forExpert);
+    Add2RecPointsList(h0, kTriggerDigitsBendPlane, expert, !image);
 
     TH3F* h1 = new TH3F("hTriggerDigitsNonBendPlane", "Trigger digits in non-bending plane",
                        4, 10.5, 14.5,
@@ -676,10 +680,10 @@ void AliMUONQADataMakerRec::InitRecPointsTrigger()
     h1->GetXaxis()->SetTitle("Chamber");
     h1->GetYaxis()->SetTitle("Board");
     h1->GetZaxis()->SetTitle("Strip");
-    Add2RecPointsList(h1, kTriggerDigitsNonBendPlane,forExpert);
+    Add2RecPointsList(h1, kTriggerDigitsNonBendPlane, expert, !image);
 
     TH1F* h2 = new TH1F("hTriggeredBoards", "Triggered boards", 234, 0.5, 234.5);
-    Add2RecPointsList(h2, kTriggeredBoards,forExpert);
+    Add2RecPointsList(h2, kTriggeredBoards, expert, !image);
 
     AliMUONTriggerDisplay triggerDisplay;
     TString histoName, histoTitle;
@@ -690,13 +694,13 @@ void AliMUONQADataMakerRec::InitRecPointsTrigger()
        histoTitle = Form("Chamber %i: Fired pads %s", 11+iChamber, cathName.Data());
        TH2F* h3 = (TH2F*)triggerDisplay.GetEmptyDisplayHisto(histoName, AliMUONTriggerDisplay::kDisplayStrips, 
                                                              iCath, iChamber, histoTitle);
-       Add2RecPointsList(h3, kTriggerDigitsDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber,!forExpert);
+       Add2RecPointsList(h3, kTriggerDigitsDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber, !expert, image);
       }
     }
 
     TH2F* h4 = (TH2F*)triggerDisplay.GetEmptyDisplayHisto("hFiredBoardsDisplay", AliMUONTriggerDisplay::kDisplayBoards,
                                                          0, 0, "Fired boards");
-    Add2RecPointsList(h4, kTriggerBoardsDisplay,!forExpert);
+    Add2RecPointsList(h4, kTriggerBoardsDisplay, !expert, image);
        
        fIsInitRecPointsTrigger = kTRUE;
 }
@@ -707,208 +711,209 @@ void AliMUONQADataMakerRec::InitESDs()
 {
   ///create ESDs histograms in ESDs subdir
   
-  Bool_t forExpert(kTRUE);
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
   
   Int_t nCh = AliMUONConstants::NTrackingCh();
   Int_t nDE = 1100;
   
   // track info
   TH1F* hESDnTracks = new TH1F("hESDnTracks", "number of tracks;n_{tracks}", 20, 0., 20.);
-  Add2ESDsList(hESDnTracks, kESDnTracks,!forExpert);
+  Add2ESDsList(hESDnTracks, kESDnTracks, !expert, image);
 
   TH1F* hESDMatchTrig = new TH1F("hESDMatchTrig", "number of tracks matched with trigger;n_{tracks}", 20, 0., 20.);
-  Add2ESDsList(hESDMatchTrig, kESDMatchTrig,!forExpert);
+  Add2ESDsList(hESDMatchTrig, kESDMatchTrig, !expert, image);
   
   TH1F* hESDMomentum = new TH1F("hESDMomentum", "momentum distribution;p (GeV/c)", 300, 0., 300);
-  Add2ESDsList(hESDMomentum, kESDMomentum,forExpert);
+  Add2ESDsList(hESDMomentum, kESDMomentum, expert, !image);
 
   TH1F* hESDPt = new TH1F("hESDPt", "transverse momentum distribution;p_{t} (GeV/c)", 200, 0., 50);
-  Add2ESDsList(hESDPt, kESDPt,forExpert);
+  Add2ESDsList(hESDPt, kESDPt, expert, !image);
 
   TH1F* hESDRapidity = new TH1F("hESDRapidity", "rapidity distribution;rapidity", 200, -4.5, -2.);
-  Add2ESDsList(hESDRapidity, kESDRapidity,forExpert);
+  Add2ESDsList(hESDRapidity, kESDRapidity, expert, !image);
 
   TH1F* hESDChi2 = new TH1F("hESDChi2", "normalized #chi^{2} distribution;#chi^{2} / ndf", 500, 0., 50.);
-  Add2ESDsList(hESDChi2, kESDChi2,forExpert);
+  Add2ESDsList(hESDChi2, kESDChi2, expert, !image);
   
   TH1F* hESDProbChi2 = new TH1F("hESDProbChi2", "distribution of probability of #chi^{2};prob(#chi^{2})", 100, 0., 1.);
-  Add2ESDsList(hESDProbChi2, kESDProbChi2,forExpert);
+  Add2ESDsList(hESDProbChi2, kESDProbChi2, expert, !image);
   
   // cluster info
   for (Int_t i = 0; i < nCh; i++) {
     Float_t rMax = AliMUONConstants::Rmax(i/2);
     TH2F* hESDClusterHitMap = new TH2F(Form("hESDClusterHitMap%d",i+1), Form("cluster position distribution in chamber %d;X (cm);Y (cm)",i+1),
                                       100, -rMax, rMax, 100, -rMax, rMax);
-    Add2ESDsList(hESDClusterHitMap, kESDClusterHitMap+i,forExpert);
+    Add2ESDsList(hESDClusterHitMap, kESDClusterHitMap+i, expert, !image);
   }
   
   TH1F* hESDnClustersPerTrack = new TH1F("hESDnClustersPerTrack", "number of associated clusters per track;n_{clusters}", 20, 0., 20.);
-  Add2ESDsList(hESDnClustersPerTrack, kESDnClustersPerTrack,!forExpert);
+  Add2ESDsList(hESDnClustersPerTrack, kESDnClustersPerTrack, !expert, image);
   
   TH1F* hESDnClustersPerCh = new TH1F("hESDnClustersPerCh", "averaged number of clusters per chamber per track;chamber ID;<n_{clusters}>", nCh, -0.5, nCh-0.5);
   hESDnClustersPerCh->SetFillColor(kRed);
-  Add2ESDsList(hESDnClustersPerCh, kESDnClustersPerCh,forExpert);
+  Add2ESDsList(hESDnClustersPerCh, kESDnClustersPerCh, expert, !image);
   
   TH1F* hESDnClustersPerDE = new TH1F("hESDnClustersPerDE", "averaged number of clusters per DE per track;DetElem ID;<n_{clusters}>", nDE+1, -0.5, nDE+0.5);
   hESDnClustersPerDE->SetFillColor(kRed);
-  Add2ESDsList(hESDnClustersPerDE, kESDnClustersPerDE,forExpert);
+  Add2ESDsList(hESDnClustersPerDE, kESDnClustersPerDE, expert, !image);
   
   for (Int_t i = 0; i < nCh; i++) {
     TH1F* hESDClusterChargeInCh = new TH1F(Form("hESDClusterChargeInCh%d",i+1), Form("cluster charge distribution in chamber %d;charge (ADC counts)",i+1), 500, 0., 5000.);
-    Add2ESDsList(hESDClusterChargeInCh, kESDClusterChargeInCh+i,forExpert);
+    Add2ESDsList(hESDClusterChargeInCh, kESDClusterChargeInCh+i, expert, !image);
   }
   
   TH1F* hESDClusterChargePerChMean = new TH1F("hESDClusterChargePerChMean", "cluster mean charge per chamber;chamber ID;<charge> (ADC counts)", nCh, -0.5, nCh-0.5);
   hESDClusterChargePerChMean->SetOption("P");
   hESDClusterChargePerChMean->SetMarkerStyle(kFullDotMedium);
   hESDClusterChargePerChMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDClusterChargePerChMean, kESDClusterChargePerChMean,forExpert);
+  Add2ESDsList(hESDClusterChargePerChMean, kESDClusterChargePerChMean, expert, !image);
   
   TH1F* hESDClusterChargePerChSigma = new TH1F("hESDClusterChargePerChSigma", "cluster charge dispersion per chamber;chamber ID;#sigma_{charge} (ADC counts)", nCh, -0.5, nCh-0.5);
   hESDClusterChargePerChSigma->SetOption("P");
   hESDClusterChargePerChSigma->SetMarkerStyle(kFullDotMedium);
   hESDClusterChargePerChSigma->SetMarkerColor(kRed);
-  Add2ESDsList(hESDClusterChargePerChSigma, kESDClusterChargePerChSigma,forExpert);
+  Add2ESDsList(hESDClusterChargePerChSigma, kESDClusterChargePerChSigma, expert, !image);
   
   TH1F* hESDClusterChargePerDE = new TH1F("hESDClusterChargePerDE", "cluster mean charge per DE;DetElem ID;<charge> (ADC counts)", nDE+1, -0.5, nDE+0.5);
   hESDClusterChargePerDE->SetOption("P");
   hESDClusterChargePerDE->SetMarkerStyle(kFullDotMedium);
   hESDClusterChargePerDE->SetMarkerColor(kRed);
-  Add2ESDsList(hESDClusterChargePerDE, kESDClusterChargePerDE,forExpert);
+  Add2ESDsList(hESDClusterChargePerDE, kESDClusterChargePerDE, expert, !image);
   
   for (Int_t i = 0; i < nCh; i++) {
     TH1F* hESDClusterSizeInCh = new TH1F(Form("hESDClusterSizeInCh%d",i+1), Form("cluster size distribution in chamber %d;size (n_{pads})",i+1), 200, 0., 200.);
-    Add2ESDsList(hESDClusterSizeInCh, kESDClusterSizeInCh+i,forExpert);
+    Add2ESDsList(hESDClusterSizeInCh, kESDClusterSizeInCh+i, expert, !image);
   }
   
   TH1F* hESDClusterSizePerChMean = new TH1F("hESDClusterSizePerChMean", "cluster mean size per chamber;chamber ID;<size> (n_{pads})", nCh, -0.5, nCh-0.5);
   hESDClusterSizePerChMean->SetOption("P");
   hESDClusterSizePerChMean->SetMarkerStyle(kFullDotMedium);
   hESDClusterSizePerChMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDClusterSizePerChMean, kESDClusterSizePerChMean,forExpert);
+  Add2ESDsList(hESDClusterSizePerChMean, kESDClusterSizePerChMean, expert, !image);
   
   TH1F* hESDClusterSizePerChSigma = new TH1F("hESDClusterSizePerChSigma", "cluster size dispersion per chamber;chamber ID;#sigma_{size} (n_{pads})", nCh, -0.5, nCh-0.5);
   hESDClusterSizePerChSigma->SetOption("P");
   hESDClusterSizePerChSigma->SetMarkerStyle(kFullDotMedium);
   hESDClusterSizePerChSigma->SetMarkerColor(kRed);
-  Add2ESDsList(hESDClusterSizePerChSigma, kESDClusterSizePerChSigma,forExpert);
+  Add2ESDsList(hESDClusterSizePerChSigma, kESDClusterSizePerChSigma, expert, !image);
   
   TH1F* hESDClusterSizePerDE = new TH1F("hESDClusterSizePerDE", "cluster mean size per DE;DetElem ID;<size> (n_{pads})", nDE+1, -0.5, nDE+0.5);
   hESDClusterSizePerDE->SetOption("P");
   hESDClusterSizePerDE->SetMarkerStyle(kFullDotMedium);
   hESDClusterSizePerDE->SetMarkerColor(kRed);
-  Add2ESDsList(hESDClusterSizePerDE, kESDClusterSizePerDE,forExpert);
+  Add2ESDsList(hESDClusterSizePerDE, kESDClusterSizePerDE, expert, !image);
   
   // cluster - track info
   for (Int_t i = 0; i < nCh; i++) {
     TH1F* hESDResidualXInCh = new TH1F(Form("hESDResidualXInCh%d",i+1), Form("cluster-track residual-X distribution in chamber %d;#Delta_{X} (cm)",i+1), 1000, -5., 5.);
-    Add2ESDsList(hESDResidualXInCh, kESDResidualXInCh+i,forExpert);
+    Add2ESDsList(hESDResidualXInCh, kESDResidualXInCh+i, expert, !image);
     
     TH1F* hESDResidualYInCh = new TH1F(Form("hESDResidualYInCh%d",i+1), Form("cluster-track residual-Y distribution in chamber %d;#Delta_{Y} (cm)",i+1), 1000, -1., 1.);
-    Add2ESDsList(hESDResidualYInCh, kESDResidualYInCh+i,forExpert);
+    Add2ESDsList(hESDResidualYInCh, kESDResidualYInCh+i, expert, !image);
     
     TH1F* hESDLocalChi2XInCh = new TH1F(Form("hESDLocalChi2XInCh%d",i+1), Form("local chi2-X distribution in chamber %d;local #chi^{2}_{X}",i+1), 1000, 0., 25);
-    Add2ESDsList(hESDLocalChi2XInCh, kESDLocalChi2XInCh+i,forExpert);
+    Add2ESDsList(hESDLocalChi2XInCh, kESDLocalChi2XInCh+i, expert, !image);
     
     TH1F* hESDLocalChi2YInCh = new TH1F(Form("hESDLocalChi2YInCh%d",i+1), Form("local chi2-Y distribution in chamber %d;local #chi^{2}_{Y}",i+1), 1000, 0., 25);
-    Add2ESDsList(hESDLocalChi2YInCh, kESDLocalChi2YInCh+i,forExpert);
+    Add2ESDsList(hESDLocalChi2YInCh, kESDLocalChi2YInCh+i, expert, !image);
   }
   
   TH1F* hESDResidualXPerChMean = new TH1F("hESDResidualXPerChMean", "cluster-track residual-X per Ch: mean;chamber ID;<#Delta_{X}> (cm)", nCh, -0.5, nCh-0.5);
   hESDResidualXPerChMean->SetOption("P");
   hESDResidualXPerChMean->SetMarkerStyle(kFullDotMedium);
   hESDResidualXPerChMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDResidualXPerChMean, kESDResidualXPerChMean,forExpert);
+  Add2ESDsList(hESDResidualXPerChMean, kESDResidualXPerChMean, expert, !image);
   
   TH1F* hESDResidualYPerChMean = new TH1F("hESDResidualYPerChMean", "cluster-track residual-Y per Ch: mean;chamber ID;<#Delta_{Y}> (cm)", nCh, -0.5, nCh-0.5);
   hESDResidualYPerChMean->SetOption("P");
   hESDResidualYPerChMean->SetMarkerStyle(kFullDotMedium);
   hESDResidualYPerChMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDResidualYPerChMean, kESDResidualYPerChMean,forExpert);
+  Add2ESDsList(hESDResidualYPerChMean, kESDResidualYPerChMean, expert, !image);
   
   TH1F* hESDResidualXPerChSigma = new TH1F("hESDResidualXPerChSigma", "cluster-track residual-X per Ch: sigma;chamber ID;#sigma_{X} (cm)", nCh, -0.5, nCh-0.5);
   hESDResidualXPerChSigma->SetOption("P");
   hESDResidualXPerChSigma->SetMarkerStyle(kFullDotMedium);
   hESDResidualXPerChSigma->SetMarkerColor(kRed);
-  Add2ESDsList(hESDResidualXPerChSigma, kESDResidualXPerChSigma,forExpert);
+  Add2ESDsList(hESDResidualXPerChSigma, kESDResidualXPerChSigma, expert, !image);
   
   TH1F* hESDResidualYPerChSigma = new TH1F("hESDResidualYPerChSigma", "cluster-track residual-Y per Ch: sigma;chamber ID;#sigma_{Y} (cm)", nCh, -0.5, nCh-0.5);
   hESDResidualYPerChSigma->SetOption("P");
   hESDResidualYPerChSigma->SetMarkerStyle(kFullDotMedium);
   hESDResidualYPerChSigma->SetMarkerColor(kRed);
-  Add2ESDsList(hESDResidualYPerChSigma, kESDResidualYPerChSigma,forExpert);
+  Add2ESDsList(hESDResidualYPerChSigma, kESDResidualYPerChSigma, expert, !image);
   
   TH1F* hESDLocalChi2XPerChMean = new TH1F("hESDLocalChi2XPerChMean", "local chi2-X per Ch: mean;chamber ID;<local #chi^{2}_{X}>", nCh, -0.5, nCh-0.5);
   hESDLocalChi2XPerChMean->SetOption("P");
   hESDLocalChi2XPerChMean->SetMarkerStyle(kFullDotMedium);
   hESDLocalChi2XPerChMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDLocalChi2XPerChMean, kESDLocalChi2XPerChMean,forExpert);
+  Add2ESDsList(hESDLocalChi2XPerChMean, kESDLocalChi2XPerChMean, expert, !image);
   
   TH1F* hESDLocalChi2YPerChMean = new TH1F("hESDLocalChi2YPerChMean", "local chi2-Y per Ch: mean;chamber ID;<local #chi^{2}_{Y}>", nCh, -0.5, nCh-0.5);
   hESDLocalChi2YPerChMean->SetOption("P");
   hESDLocalChi2YPerChMean->SetMarkerStyle(kFullDotMedium);
   hESDLocalChi2YPerChMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDLocalChi2YPerChMean, kESDLocalChi2YPerChMean,forExpert);
+  Add2ESDsList(hESDLocalChi2YPerChMean, kESDLocalChi2YPerChMean, expert, !image);
   
   TH1F* hESDResidualXPerDEMean = new TH1F("hESDResidualXPerDEMean", "cluster-track residual-X per DE: mean;DetElem ID;<#Delta_{X}> (cm)", nDE+1, -0.5, nDE+0.5);
   hESDResidualXPerDEMean->SetOption("P");
   hESDResidualXPerDEMean->SetMarkerStyle(kFullDotMedium);
   hESDResidualXPerDEMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDResidualXPerDEMean, kESDResidualXPerDEMean,forExpert);
+  Add2ESDsList(hESDResidualXPerDEMean, kESDResidualXPerDEMean, expert, !image);
   
   TH1F* hESDResidualYPerDEMean = new TH1F("hESDResidualYPerDEMean", "cluster-track residual-Y per DE: mean;DetElem ID;<#Delta_{Y}> (cm)", nDE+1, -0.5, nDE+0.5);
   hESDResidualYPerDEMean->SetOption("P");
   hESDResidualYPerDEMean->SetMarkerStyle(kFullDotMedium);
   hESDResidualYPerDEMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDResidualYPerDEMean, kESDResidualYPerDEMean,forExpert);
+  Add2ESDsList(hESDResidualYPerDEMean, kESDResidualYPerDEMean, expert, !image);
   
   TH1F* hESDResidualXPerDESigma = new TH1F("hESDResidualXPerDESigma", "cluster-track residual-X per DE: sigma;DetElem ID;#sigma_{X} (cm)", nDE+1, -0.5, nDE+0.5);
   hESDResidualXPerDESigma->SetOption("P");
   hESDResidualXPerDESigma->SetMarkerStyle(kFullDotMedium);
   hESDResidualXPerDESigma->SetMarkerColor(kRed);
-  Add2ESDsList(hESDResidualXPerDESigma, kESDResidualXPerDESigma,forExpert);
+  Add2ESDsList(hESDResidualXPerDESigma, kESDResidualXPerDESigma, expert, !image);
   
   TH1F* hESDResidualYPerDESigma = new TH1F("hESDResidualYPerDESigma", "cluster-track residual-Y per DE: sigma;DetElem ID;#sigma_{Y} (cm)", nDE+1, -0.5, nDE+0.5);
   hESDResidualYPerDESigma->SetOption("P");
   hESDResidualYPerDESigma->SetMarkerStyle(kFullDotMedium);
   hESDResidualYPerDESigma->SetMarkerColor(kRed);
-  Add2ESDsList(hESDResidualYPerDESigma, kESDResidualYPerDESigma,forExpert);
+  Add2ESDsList(hESDResidualYPerDESigma, kESDResidualYPerDESigma, expert, !image);
   
   TH1F* hESDLocalChi2XPerDEMean = new TH1F("hESDLocalChi2XPerDEMean", "local chi2-X per DE: mean;DetElem ID;<local #chi^{2}_{X}>", nDE+1, -0.5, nDE+0.5);
   hESDLocalChi2XPerDEMean->SetOption("P");
   hESDLocalChi2XPerDEMean->SetMarkerStyle(kFullDotMedium);
   hESDLocalChi2XPerDEMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDLocalChi2XPerDEMean, kESDLocalChi2XPerDEMean,forExpert);
+  Add2ESDsList(hESDLocalChi2XPerDEMean, kESDLocalChi2XPerDEMean, expert, !image);
   
   TH1F* hESDLocalChi2YPerDEMean = new TH1F("hESDLocalChi2YPerDEMean", "local chi2-Y per DE: mean;DetElem ID;<local #chi^{2}_{Y}>", nDE+1, -0.5, nDE+0.5);
   hESDLocalChi2YPerDEMean->SetOption("P");
   hESDLocalChi2YPerDEMean->SetMarkerStyle(kFullDotMedium);
   hESDLocalChi2YPerDEMean->SetMarkerColor(kRed);
-  Add2ESDsList(hESDLocalChi2YPerDEMean, kESDLocalChi2YPerDEMean,forExpert);
+  Add2ESDsList(hESDLocalChi2YPerDEMean, kESDLocalChi2YPerDEMean, expert, !image);
   
   // intermediate histograms
   TH1F* hESDnTotClustersPerCh = new TH1F("hESDnTotClustersPerCh", "total number of associated clusters per chamber;chamber ID;#Sigma(n_{clusters})", nCh, -0.5, nCh-0.5);
-  Add2ESDsList(hESDnTotClustersPerCh, kESDnTotClustersPerCh, forExpert);
+  Add2ESDsList(hESDnTotClustersPerCh, kESDnTotClustersPerCh, expert, !image);
   TH1F* hESDnTotClustersPerDE = new TH1F("hESDnTotClustersPerDE", "total number of associated clusters per DE;DetElem ID;#Sigma(n_{clusters})", nDE+1, -0.5, nDE+0.5);
-  Add2ESDsList(hESDnTotClustersPerDE, kESDnTotClustersPerDE, forExpert);
+  Add2ESDsList(hESDnTotClustersPerDE, kESDnTotClustersPerDE, expert, !image);
   TH1F* hESDnTotFullClustersPerDE = new TH1F("hESDnTotFullClustersPerDE", "total number of associated clusters containing pad info per DE;DetElem ID;#Sigma(n_{full clusters})", nDE+1, -0.5, nDE+0.5);
-  Add2ESDsList(hESDnTotFullClustersPerDE, kESDnTotFullClustersPerDE, forExpert);
+  Add2ESDsList(hESDnTotFullClustersPerDE, kESDnTotFullClustersPerDE, expert, !image);
   TH1F* hESDSumClusterChargePerDE = new TH1F("hESDSumClusterChargePerDE", "sum of cluster charge per DE;DetElem ID;#Sigma(charge) (ADC counts)", nDE+1, -0.5, nDE+0.5);
-  Add2ESDsList(hESDSumClusterChargePerDE, kESDSumClusterChargePerDE, forExpert);
+  Add2ESDsList(hESDSumClusterChargePerDE, kESDSumClusterChargePerDE, expert, !image);
   TH1F* hESDSumClusterSizePerDE = new TH1F("hESDSumClusterSizePerDE", "sum of cluster size per DE;DetElem ID;#Sigma(size) (n_{pads})", nDE+1, -0.5, nDE+0.5);
-  Add2ESDsList(hESDSumClusterSizePerDE, kESDSumClusterSizePerDE, forExpert);
+  Add2ESDsList(hESDSumClusterSizePerDE, kESDSumClusterSizePerDE, expert, !image);
   TH1F* hESDSumResidualXPerDE = new TH1F("hESDSumResidualXPerDE", "sum of cluster-track residual-X per DE;DetElem ID;#Sigma(#Delta_{X}) (cm)", nDE+1, -0.5, nDE+0.5);
-  Add2ESDsList(hESDSumResidualXPerDE, kESDSumResidualXPerDE, forExpert);
+  Add2ESDsList(hESDSumResidualXPerDE, kESDSumResidualXPerDE, expert, !image);
   TH1F* hESDSumResidualYPerDE = new TH1F("hESDSumResidualYPerDE", "sum of cluster-track residual-Y per DE;DetElem ID;#Sigma(#Delta_{Y}) (cm)", nDE+1, -0.5, nDE+0.5);
-  Add2ESDsList(hESDSumResidualYPerDE, kESDSumResidualYPerDE, forExpert);
+  Add2ESDsList(hESDSumResidualYPerDE, kESDSumResidualYPerDE, expert, !image);
   TH1F* hESDSumResidualX2PerDE = new TH1F("hESDSumResidualX2PerDE", "sum of cluster-track residual-X**2 per DE;DetElem ID;#Sigma(#Delta_{X}^{2}) (cm^{2})", nDE+1, -0.5, nDE+0.5);
-  Add2ESDsList(hESDSumResidualX2PerDE, kESDSumResidualX2PerDE, forExpert);
+  Add2ESDsList(hESDSumResidualX2PerDE, kESDSumResidualX2PerDE, expert, !image);
   TH1F* hESDSumResidualY2PerDE = new TH1F("hESDSumResidualY2PerDE", "sum of cluster-track residual-Y**2 per DE;DetElem ID;#Sigma(#Delta_{Y}^{2}) (cm^{2})", nDE+1, -0.5, nDE+0.5);
-  Add2ESDsList(hESDSumResidualY2PerDE, kESDSumResidualY2PerDE, forExpert);
+  Add2ESDsList(hESDSumResidualY2PerDE, kESDSumResidualY2PerDE, expert, !image);
   TH1F* hESDSumLocalChi2XPerDE = new TH1F("hESDSumLocalChi2XPerDE", "sum of local chi2-X per DE;DetElem ID;#Sigma(local #chi^{2}_{X})", nDE+1, -0.5, nDE+0.5);
-  Add2ESDsList(hESDSumLocalChi2XPerDE, kESDSumLocalChi2XPerDE, forExpert);
+  Add2ESDsList(hESDSumLocalChi2XPerDE, kESDSumLocalChi2XPerDE, expert, !image);
   TH1F* hESDSumLocalChi2YPerDE = new TH1F("hESDSumLocalChi2YPerDE", "sum of local chi2-Y per DE;DetElem ID;#Sigma(local #chi^{2}_{Y})", nDE+1, -0.5, nDE+0.5);
-  Add2ESDsList(hESDSumLocalChi2YPerDE, kESDSumLocalChi2YPerDE, forExpert);
+  Add2ESDsList(hESDSumLocalChi2YPerDE, kESDSumLocalChi2YPerDE, expert, !image);
   
   fIsInitESDs =  kTRUE;
 }
index fb859cc..b7dbad3 100644 (file)
@@ -104,11 +104,14 @@ AliMUONQADataMakerSim::~AliMUONQADataMakerSim()
 void AliMUONQADataMakerSim::InitHits() 
 {
   /// Initialized hit spectra
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TH1F* h0 = new TH1F("hHitDetElem", "DetElemId distribution in Hits", 1400, 100., 1500.); 
-  Add2HitsList(h0, 0);
+  Add2HitsList(h0, 0, !expert, image);
 
   TH1F* h1 = new TH1F("hHitPtot", "P distribution in Hits ", 300, 0., 300.); 
-  Add2HitsList(h1, 1);
+  Add2HitsList(h1, 1, !expert, image);
   return;
 } 
 
@@ -116,11 +119,14 @@ void AliMUONQADataMakerSim::InitHits()
 void AliMUONQADataMakerSim::InitSDigits() 
 {
   /// Initialized SDigits spectra
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TH1I* h0 = new TH1I("hSDigitsDetElem", "Detection element distribution in SDigits",  1400, 100, 1500); 
-  Add2SDigitsList(h0, 0);
+  Add2SDigitsList(h0, 0, !expert, image);
 
   TH1F* h1 = new TH1F("hSDigitsCharge", "Charge distribution in SDigits", 4096, 0, 4095); 
-  Add2SDigitsList(h1, 1);
+  Add2SDigitsList(h1, 1, !expert, image);
 
 }  
 
@@ -128,11 +134,14 @@ void AliMUONQADataMakerSim::InitSDigits()
 void AliMUONQADataMakerSim::InitDigits() 
 {
   /// Initialized Digits spectra 
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TH1I* h0 = new TH1I("hDigitsDetElem", "Detection element distribution in Digits",  1400, 100, 1500); 
-  Add2DigitsList(h0, 0);
+  Add2DigitsList(h0, 0, !expert, image);
 
   TH1I* h1 = new TH1I("hDigitsADC", "ADC distribution in Digits", 4096, 0, 4095); 
-  Add2DigitsList(h1, 1);  
+  Add2DigitsList(h1, 1, !expert, image);  
 
 } 
 
index 9b5057c..b89d83d 100644 (file)
@@ -97,23 +97,24 @@ void AliPHOSQADataMakerRec::InitESDs()
 {
   //Create histograms to controll ESD
  
-  Bool_t expert   = kTRUE ; 
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
 
   TH1F * h1 = new TH1F("hESDPhosSpectrum",  "ESDs spectrum in PHOS"                ,  200, 0.,   20.) ;
   h1->Sumw2() ;
-  Add2ESDsList(h1, kESDSpec, !expert)  ;
+  Add2ESDsList(h1, kESDSpec, !expert, image)  ;
 
   TH1I * h2 = new TH1I("hESDPhosMul",       "ESDs multiplicity distribution in PHOS", 100, 0,   100 ) ; 
   h2->Sumw2() ;
-  Add2ESDsList(h2, kESDNtot, !expert) ;
+  Add2ESDsList(h2, kESDNtot, !expert, image) ;
  
   TH1F * h3 = new TH1F("hESDPhosEtot",      "ESDs total energy"                     , 2000, 0,  200.) ; 
   h3->Sumw2() ;
-  Add2ESDsList(h3, kESDEtot, !expert) ;  //Expert histo
+  Add2ESDsList(h3, kESDEtot, !expert, image) ;  //Expert histo
  
   TH1F * h4 = new TH1F("hESDpid",           "ESDs PID distribution in PHOS"         , 100, 0.,    1.) ;
   h4->Sumw2() ;
-  Add2ESDsList(h4, kESDpid, !expert) ; //Expert histo
+  Add2ESDsList(h4, kESDpid, !expert, image) ; //Expert histo
        
 }
 
@@ -121,206 +122,208 @@ void AliPHOSQADataMakerRec::InitESDs()
 void AliPHOSQADataMakerRec::InitRecPoints()
 {
   // create Reconstructed Points histograms in RecPoints subdir
-  Bool_t expert   = kTRUE ; 
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
   
   TH2I * h0 = new TH2I("hRpPHOSxyMod1","RecPoints Rows x Columns for PHOS module 1", 64, -72., 72., 56, -63., 63.) ;                             
-  Add2RecPointsList(h0,kRPmod1, expert) ;
+  Add2RecPointsList(h0,kRPmod1, expert, !image) ;
   TH2I * h1 = new TH2I("hRpPHOSxyMod2","RecPoints Rows x Columns for PHOS module 2", 64, -72., 72., 56, -63., 63.) ;                             
-  Add2RecPointsList(h1,kRPmod2, expert) ;
+  Add2RecPointsList(h1,kRPmod2, expert, !image) ;
   TH2I * h2 = new TH2I("hRpPHOSxyMod3","RecPoints Rows x Columns for PHOS module 3", 64, -72., 72., 56, -63., 63.) ;                             
-  Add2RecPointsList(h2,kRPmod3, expert) ;
+  Add2RecPointsList(h2,kRPmod3, expert, !image) ;
   TH2I * h3 = new TH2I("hRpPHOSxyMod4","RecPoints Rows x Columns for PHOS module 4", 64, -72., 72., 56, -63., 63.) ;                             
-  Add2RecPointsList(h3,kRPmod4, expert) ;
+  Add2RecPointsList(h3,kRPmod4, expert, !image) ;
   TH2I * h4 = new TH2I("hRpPHOSxyMod5","RecPoints Rows x Columns for PHOS module 5", 64, -72., 72., 56, -63., 63.) ;                             
-  Add2RecPointsList(h4,kRPmod5, expert) ;
+  Add2RecPointsList(h4,kRPmod5, expert, !image) ;
  
   TH1F * h5 = new TH1F("hEmcPhosRecPointsSpectrum",  "EMC RecPoints spectrum in PHOS",   2000, 0., 20.) ; 
   h5->Sumw2() ;
-  Add2RecPointsList(h5, kRPSpec, !expert)  ;
+  Add2RecPointsList(h5, kRPSpec, !expert, image)  ;
 
   TH1I * h6 = new TH1I("hEmcPhosRecPointsMul", "EMCA RecPoints multiplicity distribution in PHOS", 100, 0,  100) ; 
   h6->Sumw2() ;
-  Add2RecPointsList(h6, kRPNtot, !expert) ;
+  Add2RecPointsList(h6, kRPNtot, !expert, image) ;
 
   TH1I * h7 = new TH1I("hEmcPhosRecPointsEtot", "EMC RecPoints Etot", 200, 0,  200.) ; 
   h7->Sumw2() ;
-  Add2RecPointsList(h7, kRPEtot, !expert) ;
+  Add2RecPointsList(h7, kRPEtot, !expert, image) ;
 
   TH1I * h8 = new TH1I("hCpvPhosRecPointsMul", "CPV RecPoints multiplicity distribution in PHOS", 100, 0,  100) ; 
   h8->Sumw2() ;
-  Add2RecPointsList(h8, kRPNcpv, !expert) ;
+  Add2RecPointsList(h8, kRPNcpv, !expert, image) ;
 }
 
 //____________________________________________________________________________ 
 void AliPHOSQADataMakerRec::InitRaws()
 {
   // create Raws histograms in Raws subdir
-  Bool_t expert   = kTRUE ; 
-  Bool_t saveCorr = kTRUE ; 
-  
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t saveCorr = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+
   TH2I * h0 = new TH2I("hHighPHOSxyMod1","High Gain Rows x Columns for PHOS module 1", 64, 0, 64, 56, 0, 56) ;
-  Add2RawsList(h0,kHGmod1, expert, !saveCorr) ;
+  Add2RawsList(h0,kHGmod1, expert, !image, !saveCorr) ;
   TH2I * h1 = new TH2I("hHighPHOSxyMod2","High Gain Rows x Columns for PHOS module 2", 64, 0, 64, 56, 0, 56) ;
-  Add2RawsList(h1,kHGmod2, expert, !saveCorr) ;
+  Add2RawsList(h1,kHGmod2, expert, !image, !saveCorr) ;
   TH2I * h2 = new TH2I("hHighPHOSxyMod3","High Gain Rows x Columns for PHOS module 3", 64, 0, 64, 56, 0, 56) ;
-  Add2RawsList(h2,kHGmod3, expert, !saveCorr) ;
+  Add2RawsList(h2,kHGmod3, expert, !image, !saveCorr) ;
   TH2I * h3 = new TH2I("hHighPHOSxyMod4","High Gain Rows x Columns for PHOS module 4", 64, 0, 64, 56, 0, 56) ;
-  Add2RawsList(h3,kHGmod4, expert, !saveCorr) ;
+  Add2RawsList(h3,kHGmod4, expert, !image, !saveCorr) ;
   TH2I * h4 = new TH2I("hHighPHOSxyMod5","High Gain Rows x Columns for PHOS module 5", 64, 0, 64, 56, 0, 56) ;
-  Add2RawsList(h4,kHGmod5, expert, !saveCorr) ;
+  Add2RawsList(h4,kHGmod5, expert, !image, !saveCorr) ;
   TH2I * h5 = new TH2I("hLowPHOSxyMod1","Low Gain Rows x Columns for PHOS module 1", 64, 0, 64, 56, 0, 56) ;
-  Add2RawsList(h5,kLGmod1, expert, !saveCorr) ;
+  Add2RawsList(h5,kLGmod1, expert, !image, !saveCorr) ;
   TH2I * h6 = new TH2I("hLowPHOSxyMod2","Low Gain Rows x Columns for PHOS module 2", 64, 0, 64, 56, 0, 56) ;
-  Add2RawsList(h6,kLGmod2, expert, !saveCorr) ;
+  Add2RawsList(h6,kLGmod2, expert, !image, !saveCorr) ;
   TH2I * h7 = new TH2I("hLowPHOSxyMod3","Low Gain Rows x Columns for PHOS module 3", 64, 0, 64, 56, 0, 56) ;
-  Add2RawsList(h7,kLGmod3, expert, !saveCorr) ;
+  Add2RawsList(h7,kLGmod3, expert, !image, !saveCorr) ;
   TH2I * h8 = new TH2I("hLowPHOSxyMod4","Low Gain Rows x Columns for PHOS module 4", 64, 0, 64, 56, 0, 56) ;
-  Add2RawsList(h8,kLGmod4, expert, !saveCorr) ;
+  Add2RawsList(h8,kLGmod4, expert, !image, !saveCorr) ;
   TH2I * h9 = new TH2I("hLowPHOSxyMod5","Low Gain Rows x Columns for PHOS module 5", 64, 0, 64, 56, 0, 56) ;
-  Add2RawsList(h9,kLGmod5, expert, !saveCorr) ;
+  Add2RawsList(h9,kLGmod5, expert, !image, !saveCorr) ;
 
   TH1I * h10 = new TH1I("hLowPhosModules",    "Low Gain Hits in EMCA PHOS modules",       6, 0, 6) ;
   h10->Sumw2() ;
-  Add2RawsList(h10, kNmodLG, !expert, !saveCorr) ;
+  Add2RawsList(h10, kNmodLG, !expert, image, !saveCorr) ;
   TH1I * h11 = new TH1I("hHighPhosModules",   "High Gain Hits in EMCA PHOS modules",       6, 0, 6) ;
   h11->Sumw2() ;
-  Add2RawsList(h11, kNmodHG, !expert, !saveCorr) ;
+  Add2RawsList(h11, kNmodHG, !expert, image, !saveCorr) ;
 
   TH1F * h12 = new TH1F("hLowPhosRawtime", "Low Gain Time of raw hits in PHOS", 500, -50., 200.) ;
   h12->Sumw2() ;
-  Add2RawsList(h12, kLGtime, !expert, !saveCorr) ;
+  Add2RawsList(h12, kLGtime, !expert, image, !saveCorr) ;
   TH1F * h13 = new TH1F("hHighPhosRawtime", "High Gain Time of raw hits in PHOS", 500, -50., 200.) ;
   h13->Sumw2() ;
-  Add2RawsList(h13, kHGtime, !expert, !saveCorr) ;
+  Add2RawsList(h13, kHGtime, !expert, image, !saveCorr) ;
 
   TH1F * h14 = new TH1F("hLowPhosRawEnergy", "Low Gain Energy of raw hits in PHOS", 500, 0., 1000.) ;
   h14->Sumw2() ;
-  Add2RawsList(h14, kSpecLG, !expert, !saveCorr) ;
+  Add2RawsList(h14, kSpecLG, !expert, image, !saveCorr) ;
   TH1F * h15 = new TH1F("hHighPhosRawEnergy", "High Gain Energy of raw hits in PHOS",500,0., 1000.) ;
   h15->Sumw2() ;
-  Add2RawsList(h15, kSpecHG, !expert, !saveCorr) ;
+  Add2RawsList(h15, kSpecHG, !expert, image, !saveCorr) ;
 
   TH1F * h16 = new TH1F("hLowNtot", "Low Gain Total Number of raw hits in PHOS", 500, 0., 5000.) ;
   h16->Sumw2() ;
-  Add2RawsList(h16, kNtotLG, !expert, saveCorr) ;
+  Add2RawsList(h16, kNtotLG, !expert, saveCorr, image) ;
   TH1F * h17 = new TH1F("hHighNtot", "High Gain Total Number of raw hits in PHOS",500,0., 5000.) ;
   h17->Sumw2() ;
-  Add2RawsList(h17, kNtotHG, !expert, saveCorr) ;
+  Add2RawsList(h17, kNtotHG, !expert, saveCorr, image) ;
 
   TH1F * h18 = new TH1F("hLowEtot", "Low Gain Total Energy of raw hits in PHOS", 500, 0., 5000.) ;
   h18->Sumw2() ;
-  Add2RawsList(h18, kEtotLG, !expert, saveCorr) ;
+  Add2RawsList(h18, kEtotLG, !expert, saveCorr, image) ;
   TH1F * h19 = new TH1F("hHighEtot", "High Gain Total Energy of raw hits in PHOS",500,0., 100000.) ;
   h19->Sumw2() ;
-  Add2RawsList(h19, kEtotHG, !expert, saveCorr) ;
+  Add2RawsList(h19, kEtotHG, !expert, saveCorr, image) ;
 
   TH2F * h20 = new TH2F("hQualHGxyMod1","High Gain signal quality Rows x Columns module 1", 64, 0, 64, 56, 0, 56) ;
   h20->SetOption("colz");
-  Add2RawsList(h20,kHGqualMod1, expert, !saveCorr) ;
+  Add2RawsList(h20,kHGqualMod1, expert, !image, !saveCorr) ;
   TH2F * h21 = new TH2F("hQualHGxyMod2","High Gain signal quality Rows x Columns module 2", 64, 0, 64, 56, 0, 56) ;
   h21->SetOption("colz");
-  Add2RawsList(h21,kHGqualMod2, expert, !saveCorr) ;
+  Add2RawsList(h21,kHGqualMod2, expert, !image, !saveCorr) ;
   TH2F * h22 = new TH2F("hQualHGxyMod3","High Gain signal quality Rows x Columns module 3", 64, 0, 64, 56, 0, 56) ;
   h22->SetOption("colz");
-  Add2RawsList(h22,kHGqualMod3, expert, !saveCorr) ;
+  Add2RawsList(h22,kHGqualMod3, expert, !image, !saveCorr) ;
   TH2F * h23 = new TH2F("hQualHGxyMod4","High Gain signal quality Rows x Columns module 4", 64, 0, 64, 56, 0, 56) ;
   h23->SetOption("colz");
-  Add2RawsList(h23,kHGqualMod4, expert, !saveCorr) ;
+  Add2RawsList(h23,kHGqualMod4, expert, !image, !saveCorr) ;
   TH2F * h24 = new TH2F("hQualHGxyMod5","High Gain signal quality Rows x Columns module 5", 64, 0, 64, 56, 0, 56) ;
   h24->SetOption("colz");
-  Add2RawsList(h24,kHGqualMod5, expert, !saveCorr) ;
+  Add2RawsList(h24,kHGqualMod5, expert, !image, !saveCorr) ;
   TH2F * h25 = new TH2F("hQualLGxyMod1","Low Gain signal quality Rows x Columns module 1", 64, 0, 64, 56, 0, 56) ;
   h25->SetOption("colz");
-  Add2RawsList(h25,kLGqualMod1, expert, !saveCorr) ;
+  Add2RawsList(h25,kLGqualMod1, expert, !image, !saveCorr) ;
   TH2F * h26 = new TH2F("hQualLGxyMod2","Low Gain signal quality Rows x Columns module 2", 64, 0, 64, 56, 0, 56) ;
   h26->SetOption("colz");
-  Add2RawsList(h26,kLGqualMod2, expert, !saveCorr) ;
+  Add2RawsList(h26,kLGqualMod2, expert, !image, !saveCorr) ;
   TH2F * h27 = new TH2F("hQualLGxyMod3","Low Gain signal quality Rows x Columns module 3", 64, 0, 64, 56, 0, 56) ;
   h27->SetOption("colz");
-  Add2RawsList(h27,kLGqualMod3, expert, !saveCorr) ;
+  Add2RawsList(h27,kLGqualMod3, expert, !image, !saveCorr) ;
   TH2F * h28 = new TH2F("hQualLGxyMod4","Low Gain signal quality Rows x Columns module 4", 64, 0, 64, 56, 0, 56) ;
   h28->SetOption("colz");
-  Add2RawsList(h28,kLGqualMod4, expert, !saveCorr) ;
+  Add2RawsList(h28,kLGqualMod4, expert, !image, !saveCorr) ;
   TH2F * h29 = new TH2F("hQualLGxyMod5","Low Gain signal quality Rows x Columns module 5", 64, 0, 64, 56, 0, 56) ;
   h29->SetOption("colz");
-  Add2RawsList(h29,kLGqualMod5, expert, !saveCorr) ;
+  Add2RawsList(h29,kLGqualMod5, expert, !image, !saveCorr) ;
 
   TH1F * h30 = new TH1F("hLGpedRMS","Low Gain pedestal RMS",200,0.,20.) ;
   h30->Sumw2() ;
-  Add2RawsList(h30,kLGpedRMS, !expert, !saveCorr) ;
+  Add2RawsList(h30,kLGpedRMS, !expert, image, !saveCorr) ;
   TH1F * h31 = new TH1F("hHGpedRMS","High Gain pedestal RMS",200,0.,20.) ;
   h31->Sumw2() ;
-  Add2RawsList(h31,kHGpedRMS, !expert, !saveCorr) ;
+  Add2RawsList(h31,kHGpedRMS, !expert, image, !saveCorr) ;
 
   TH2F * h32 = new TH2F("hpedRMSHGxyMod1","High Gain pedestal RMS Rows x Columns module 1", 64, 0, 64, 56, 0, 56) ;
   h32->SetOption("colz");
-  Add2RawsList(h32,kHGpedRMSMod1, expert, !saveCorr) ;
+  Add2RawsList(h32,kHGpedRMSMod1, expert, !image, !saveCorr) ;
   TH2F * h33 = new TH2F("hpedRMSHGxyMod2","High Gain pedestal RMS Rows x Columns module 2", 64, 0, 64, 56, 0, 56) ;
   h33->SetOption("colz");
-  Add2RawsList(h33,kHGpedRMSMod2, expert, !saveCorr) ;
+  Add2RawsList(h33,kHGpedRMSMod2, expert, !image, !saveCorr) ;
   TH2F * h34 = new TH2F("hpedRMSHGxyMod3","High Gain pedestal RMS Rows x Columns module 3", 64, 0, 64, 56, 0, 56) ;
   h34->SetOption("colz");
-  Add2RawsList(h34,kHGpedRMSMod3, expert, !saveCorr) ;
+  Add2RawsList(h34,kHGpedRMSMod3, expert, !image, !saveCorr) ;
   TH2F * h35 = new TH2F("hpedRMSHGxyMod4","High Gain pedestal RMS Rows x Columns module 4", 64, 0, 64, 56, 0, 56) ;
   h35->SetOption("colz");
-  Add2RawsList(h35,kHGpedRMSMod4, expert, !saveCorr) ;
+  Add2RawsList(h35,kHGpedRMSMod4, expert, !image, !saveCorr) ;
   TH2F * h36 = new TH2F("hpedRMSHGxyMod5","High Gain pedestal RMS Rows x Columns module 5", 64, 0, 64, 56, 0, 56) ;
   h36->SetOption("colz");
-  Add2RawsList(h36,kHGpedRMSMod5, expert, !saveCorr) ;
+  Add2RawsList(h36,kHGpedRMSMod5, expert, !image, !saveCorr) ;
   TH2F * h37 = new TH2F("hpedRMSLGxyMod1","Low Gain pedestal RMS Rows x Columns module 1", 64, 0, 64, 56, 0, 56) ;
   h37->SetOption("colz");
-  Add2RawsList(h37,kLGpedRMSMod1, expert, !saveCorr) ;
+  Add2RawsList(h37,kLGpedRMSMod1, expert, !image, !saveCorr) ;
   TH2F * h38 = new TH2F("hpedRMSLGxyMod2","Low Gain pedestal RMS Rows x Columns module 2", 64, 0, 64, 56, 0, 56) ;
   h38->SetOption("colz");
-  Add2RawsList(h38,kLGpedRMSMod2, expert, !saveCorr) ;
+  Add2RawsList(h38,kLGpedRMSMod2, expert, !image, !saveCorr) ;
   TH2F * h39 = new TH2F("hpedRMSLGxyMod3","Low Gain pedestal RMS Rows x Columns module 3", 64, 0, 64, 56, 0, 56) ;
   h39->SetOption("colz");
-  Add2RawsList(h39,kLGpedRMSMod3, expert, !saveCorr) ;
+  Add2RawsList(h39,kLGpedRMSMod3, expert, !image, !saveCorr) ;
   TH2F * h40 = new TH2F("hpedRMSLGxyMod4","Low Gain pedestal RMS Rows x Columns module 4", 64, 0, 64, 56, 0, 56) ;
   h40->SetOption("colz");
-  Add2RawsList(h40,kLGpedRMSMod4, expert, !saveCorr) ;
+  Add2RawsList(h40,kLGpedRMSMod4, expert, !image, !saveCorr) ;
   TH2F * h41 = new TH2F("hpedRMSLGxyMod5","Low Gain pedestal RMS Rows x Columns module 5", 64, 0, 64, 56, 0, 56) ;
   h41->SetOption("colz");
-  Add2RawsList(h41,kLGpedRMSMod5, expert, !saveCorr) ;
+  Add2RawsList(h41,kLGpedRMSMod5, expert, !image, !saveCorr) ;
 
   /*
   TH1F * h42 = new TH1F("hLGpedMean","Low Gain pedestal Mean",200,0.,20.) ;
   h42->Sumw2() ;
-  Add2RawsList(h42,kLGpedMean, !expert, !saveCorr) ;
+  Add2RawsList(h42,kLGpedMean, !expert, image, !saveCorr) ;
   TH1F * h43 = new TH1F("hHGpedMean","High Gain pedestal Mean",200,0.,20.) ;
   h43->Sumw2() ;
-  Add2RawsList(h43,kHGpedMean, !expert, !saveCorr) ;
+  Add2RawsList(h43,kHGpedMean, !expert, image, !saveCorr) ;
 
   TH2F * h44 = new TH2F("hpedMeanHGxyMod1","High Gain pedestal Mean Rows x Columns module 1", 64, 0, 64, 56, 0, 56) ;
   h44->SetOption("colz");
-  Add2RawsList(h44,kHGpedMeanMod1, expert, !saveCorr) ;
+  Add2RawsList(h44,kHGpedMeanMod1, expert, !image, !saveCorr) ;
   TH2F * h45 = new TH2F("hpedMeanHGxyMod2","High Gain pedestal Mean Rows x Columns module 2", 64, 0, 64, 56, 0, 56) ;
   h45->SetOption("colz");
-  Add2RawsList(h45,kHGpedMeanMod2, expert, !saveCorr) ;
+  Add2RawsList(h45,kHGpedMeanMod2, expert, !image, !saveCorr) ;
   TH2F * h46 = new TH2F("hpedMeanHGxyMod3","High Gain pedestal Mean Rows x Columns module 3", 64, 0, 64, 56, 0, 56) ;
   h46->SetOption("colz");
-  Add2RawsList(h46,kHGpedMeanMod3, expert, !saveCorr) ;
+  Add2RawsList(h46,kHGpedMeanMod3, expert, !image, !saveCorr) ;
   TH2F * h47 = new TH2F("hpedMeanHGxyMod4","High Gain pedestal Mean Rows x Columns module 4", 64, 0, 64, 56, 0, 56) ;
   h47->SetOption("colz");
-  Add2RawsList(h47,kHGpedMeanMod4, expert, !saveCorr) ;
+  Add2RawsList(h47,kHGpedMeanMod4, expert, !image, !saveCorr) ;
   TH2F * h48 = new TH2F("hpedMeanHGxyMod5","High Gain pedestal Mean Rows x Columns module 5", 64, 0, 64, 56, 0, 56) ;
   h48->SetOption("colz");
-  Add2RawsList(h48,kHGpedMeanMod5, expert, !saveCorr) ;
+  Add2RawsList(h48,kHGpedMeanMod5, expert, !image, !saveCorr) ;
   TH2F * h49 = new TH2F("hpedMeanLGxyMod1","Low Gain pedestal Mean Rows x Columns module 1", 64, 0, 64, 56, 0, 56) ;
   h49->SetOption("colz");
-  Add2RawsList(h49,kLGpedMeanMod1, expert, !saveCorr) ;
+  Add2RawsList(h49,kLGpedMeanMod1, expert, !image, !saveCorr) ;
   TH2F * h50 = new TH2F("hpedMeanLGxyMod2","Low Gain pedestal Mean Rows x Columns module 2", 64, 0, 64, 56, 0, 56) ;
   h50->SetOption("colz");
-  Add2RawsList(h50,kLGpedMeanMod2, expert, !saveCorr) ;
+  Add2RawsList(h50,kLGpedMeanMod2, expert, !image, !saveCorr) ;
   TH2F * h51 = new TH2F("hpedMeanLGxyMod3","Low Gain pedestal Mean Rows x Columns module 3", 64, 0, 64, 56, 0, 56) ;
   h51->SetOption("colz");
-  Add2RawsList(h51,kLGpedMeanMod3, expert, !saveCorr) ;
+  Add2RawsList(h51,kLGpedMeanMod3, expert, !image, !saveCorr) ;
   TH2F * h52 = new TH2F("hpedMeanLGxyMod4","Low Gain pedestal Mean Rows x Columns module 4", 64, 0, 64, 56, 0, 56) ;
   h52->SetOption("colz");
-  Add2RawsList(h52,kLGpedMeanMod4, expert, !saveCorr) ;
+  Add2RawsList(h52,kLGpedMeanMod4, expert, !image, !saveCorr) ;
   TH2F * h53 = new TH2F("hpedMeanLGxyMod5","Low Gain pedestal Mean Rows x Columns module 5", 64, 0, 64, 56, 0, 56) ;
   h53->SetOption("colz");
-  Add2RawsList(h53,kLGpedMeanMod5, expert, !saveCorr) ;
+  Add2RawsList(h53,kLGpedMeanMod5, expert, !image, !saveCorr) ;
   */
 }
 
index 963bae7..80f59e0 100644 (file)
@@ -83,13 +83,14 @@ void AliPHOSQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjAr
 void AliPHOSQADataMakerSim::InitHits()
 {
   // create Hits histograms in Hits subdir
-  Bool_t expert   = kTRUE ; 
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
   TH1F * h0 = new TH1F("hPhosHits",    "Hits energy distribution in PHOS",       100, 0., 100.) ; 
   h0->Sumw2() ;
-  Add2HitsList(h0, kHits, !expert) ;
+  Add2HitsList(h0, kHits, !expert, image) ;
   TH1I * h1 = new TH1I("hPhosHitsMul", "Hits multiplicity distribution in PHOS", 500, 0., 10000) ; 
   h1->Sumw2() ;
-  Add2HitsList(h1, kHitsMul, !expert) ;
+  Add2HitsList(h1, kHitsMul, !expert, image) ;
   
 }
 
@@ -97,26 +98,28 @@ void AliPHOSQADataMakerSim::InitHits()
 void AliPHOSQADataMakerSim::InitDigits()
 {
   // create Digits histograms in Digits subdir
-  Bool_t expert   = kTRUE ; 
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
   TH1I * h0 = new TH1I("hPhosDigits",    "Digits amplitude distribution in PHOS",    500, 0, 1000) ; 
   h0->Sumw2() ;
-  Add2DigitsList(h0, kDigits, !expert) ;
+  Add2DigitsList(h0, kDigits, !expert, image) ;
   TH1I * h1 = new TH1I("hPhosDigitsMul", "Digits multiplicity distribution in PHOS", 2000, 0, 10000) ; 
   h1->Sumw2() ;
-  Add2DigitsList(h1, kDigitsMul, !expert) ;
+  Add2DigitsList(h1, kDigitsMul, !expert, image) ;
 }
 
 //____________________________________________________________________________ 
 void AliPHOSQADataMakerSim::InitSDigits()
 {
   // create SDigits histograms in SDigits subdir
-  Bool_t expert   = kTRUE ; 
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
   TH1F * h0 = new TH1F("hPhosSDigits",    "SDigits energy distribution in PHOS",       500, 0., 1000.) ; 
   h0->Sumw2() ;
-  Add2SDigitsList(h0, kSDigits, !expert) ;
+  Add2SDigitsList(h0, kSDigits, !expert, image) ;
   TH1I * h1 = new TH1I("hPhosSDigitsMul", "SDigits multiplicity distribution in PHOS", 500, 0,  1000) ; 
   h1->Sumw2() ;
-  Add2SDigitsList(h1, kSDigitsMul, !expert) ;
+  Add2SDigitsList(h1, kSDigitsMul, !expert, image) ;
 }
 
 //____________________________________________________________________________
index 0fbdf94..0fb3e68 100644 (file)
@@ -75,211 +75,213 @@ void AliPMDQADataMakerRec::InitRaws()
 {
   // create Raws histograms in Raws subdir
 
-  const Bool_t saveForCorr = kTRUE;
-    // Preshower plane
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t saveCorr = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  // Preshower plane
 
     TH1I * h0 = new TH1I("hPreEdepM0","ADC Distribution PRE - Module 0", 100, 0, 2000);
     h0->Sumw2();
-    Add2RawsList(h0, 0); 
+    Add2RawsList(h0, 0, !expert, image, !saveCorr); 
 
     TH1I * h1 = new TH1I("hPreEdepM1","ADC Distribution PRE - Module 1", 100, 0, 2000);
     h1->Sumw2();
-    Add2RawsList(h1, 1); 
+    Add2RawsList(h1, 1, !expert, image, !saveCorr); 
 
     TH1I * h2 = new TH1I("hPreEdepM2","ADC Distribution PRE - Module 2", 100, 0, 2000);
     h2->Sumw2();
-    Add2RawsList(h2, 2); 
+    Add2RawsList(h2, 2, !expert, image, !saveCorr); 
     
     TH1I * h3 = new TH1I("hPreEdepM3","ADC Distribution PRE - Module 3", 100, 0, 2000);
     h3->Sumw2(); 
-    Add2RawsList(h3, 3); 
+    Add2RawsList(h3, 3, !expert, image, !saveCorr); 
 
     TH1I * h4 = new TH1I("hPreEdepM4","ADC Distribution PRE - Module 4", 100, 0, 2000);
     h4->Sumw2(); 
-    Add2RawsList(h4, 4); 
+    Add2RawsList(h4, 4, !expert, image, !saveCorr); 
 
     TH1I * h5 = new TH1I("hPreEdepM5","ADC Distribution PRE - Module 5", 100, 0, 2000);
     h5->Sumw2(); 
-    Add2RawsList(h5, 5); 
+    Add2RawsList(h5, 5, !expert, image, !saveCorr); 
 
     TH1I * h6 = new TH1I("hPreEdepM6","ADC Distribution PRE - Module 6", 100, 0, 2000);
     h6->Sumw2(); 
-    Add2RawsList(h6, 6); 
+    Add2RawsList(h6, 6, !expert, image, !saveCorr); 
 
     TH1I * h7 = new TH1I("hPreEdepM7","ADC Distribution PRE - Module 7", 100, 0, 2000);
     h7->Sumw2(); 
-    Add2RawsList(h7, 7); 
+    Add2RawsList(h7, 7, !expert, image, !saveCorr); 
 
     TH1I * h8 = new TH1I("hPreEdepM8","ADC Distribution PRE - Module 8", 100, 0, 2000);
     h8->Sumw2(); 
-    Add2RawsList(h8, 8); 
+    Add2RawsList(h8, 8, !expert, image, !saveCorr); 
 
     TH1I * h9 = new TH1I("hPreEdepM9","ADC Distribution PRE - Module 9", 100, 0, 2000);
     h9->Sumw2(); 
-    Add2RawsList(h9, 9); 
+    Add2RawsList(h9, 9, !expert, image, !saveCorr); 
 
     TH1I * h10 = new TH1I("hPreEdepM10","ADC Distribution PRE - Module 10", 100, 0, 2000);
     h10->Sumw2(); 
-    Add2RawsList(h10, 10); 
+    Add2RawsList(h10, 10, !expert, image, !saveCorr); 
 
     TH1I * h11 = new TH1I("hPreEdepM11","ADC Distribution PRE - Module 11", 100, 0, 2000);
     h11->Sumw2(); 
-    Add2RawsList(h11, 11); 
+    Add2RawsList(h11, 11, !expert, image, !saveCorr); 
 
     TH1I * h12 = new TH1I("hPreEdepM12","ADC Distribution PRE - Module 12", 100, 0, 2000);
     h12->Sumw2(); 
-    Add2RawsList(h12, 12); 
+    Add2RawsList(h12, 12, !expert, image, !saveCorr); 
 
     TH1I * h13 = new TH1I("hPreEdepM13","ADC Distribution PRE - Module 13", 100, 0, 2000);
     h13->Sumw2(); 
-    Add2RawsList(h13, 13); 
+    Add2RawsList(h13, 13, !expert, image, !saveCorr); 
 
     TH1I * h14 = new TH1I("hPreEdepM14","ADC Distribution PRE - Module 14", 100, 0, 2000);
     h14->Sumw2(); 
-    Add2RawsList(h14, 14); 
+    Add2RawsList(h14, 14, !expert, image, !saveCorr); 
 
     TH1I * h15 = new TH1I("hPreEdepM15","ADC Distribution PRE - Module 15", 100, 0, 2000);
     h15->Sumw2(); 
-    Add2RawsList(h15, 15); 
+    Add2RawsList(h15, 15, !expert, image, !saveCorr); 
 
     TH1I * h16 = new TH1I("hPreEdepM16","ADC Distribution PRE - Module 16", 100, 0, 2000);
     h16->Sumw2(); 
-    Add2RawsList(h16, 16); 
+    Add2RawsList(h16, 16, !expert, image, !saveCorr); 
 
     TH1I * h17 = new TH1I("hPreEdepM17","ADC Distribution PRE - Module 17", 100, 0, 2000);
     h17->Sumw2(); 
-    Add2RawsList(h17, 17); 
+    Add2RawsList(h17, 17, !expert, image, !saveCorr); 
 
     TH1I * h18 = new TH1I("hPreEdepM18","ADC Distribution PRE - Module 18", 100, 0, 2000);
     h18->Sumw2(); 
-    Add2RawsList(h18, 18); 
+    Add2RawsList(h18, 18, !expert, image, !saveCorr); 
 
     TH1I * h19 = new TH1I("hPreEdepM19","ADC Distribution PRE - Module 19", 100, 0, 2000);
     h19->Sumw2(); 
-    Add2RawsList(h19, 19); 
+    Add2RawsList(h19, 19, !expert, image, !saveCorr); 
 
     TH1I * h20 = new TH1I("hPreEdepM20","ADC Distribution PRE - Module 20", 100, 0, 2000);
     h20->Sumw2(); 
-    Add2RawsList(h20, 20);
+    Add2RawsList(h20, 20, !expert, image, !saveCorr);
  
     TH1I * h21 = new TH1I("hPreEdepM21","ADC Distribution PRE - Module 21", 100, 0, 2000);
     h21->Sumw2(); 
-    Add2RawsList(h21, 21); 
+    Add2RawsList(h21, 21, !expert, image, !saveCorr); 
 
     TH1I * h22 = new TH1I("hPreEdepM22","ADC Distribution PRE - Module 22", 100, 0, 2000);
     h22->Sumw2(); 
-    Add2RawsList(h22, 22); 
+    Add2RawsList(h22, 22, !expert, image, !saveCorr); 
 
     TH1I * h23 = new TH1I("hPreEdepM23","ADC Distribution PRE - Module 23", 100, 0, 2000);
     h23->Sumw2(); 
-    Add2RawsList(h23, 23);
+    Add2RawsList(h23, 23, !expert, image, !saveCorr);
 
     // CPV histos
 
     TH1I * h24 = new TH1I("hCpvEdepM24","ADC Distribution CPV - Module 24", 100, 0, 2000);
     h24->Sumw2();
-    Add2RawsList(h24, 24); 
+    Add2RawsList(h24, 24, !expert, image, !saveCorr); 
 
     TH1I * h25 = new TH1I("hCpvEdepM25","ADC Distribution CPV - Module 25", 100, 0, 2000);
     h25->Sumw2(); 
-    Add2RawsList(h25, 25); 
+    Add2RawsList(h25, 25, !expert, image, !saveCorr); 
 
     TH1I * h26 = new TH1I("hCpvEdepM26","ADC Distribution CPV - Module 26", 100, 0, 2000);
     h26->Sumw2(); 
-    Add2RawsList(h26, 26); 
+    Add2RawsList(h26, 26, !expert, image, !saveCorr); 
 
     TH1I * h27 = new TH1I("hCpvEdepM27","ADC Distribution CPV - Module 27", 100, 0, 2000);
     h27->Sumw2(); 
-    Add2RawsList(h27, 27); 
+    Add2RawsList(h27, 27, !expert, image, !saveCorr); 
 
     TH1I * h28 = new TH1I("hCpvEdepM28","ADC Distribution CPV - Module 28", 100, 0, 2000);
     h28->Sumw2(); 
-    Add2RawsList(h28, 28); 
+    Add2RawsList(h28, 28, !expert, image, !saveCorr); 
 
     TH1I * h29 = new TH1I("hCpvEdepM29","ADC Distribution CPV - Module 29", 100, 0, 2000);
     h29->Sumw2(); 
-    Add2RawsList(h29, 29); 
+    Add2RawsList(h29, 29, !expert, image, !saveCorr); 
 
     TH1I * h30 = new TH1I("hCpvEdepM30","ADC Distribution CPV - Module 30", 100, 0, 2000);
     h30->Sumw2(); 
-    Add2RawsList(h30, 30); 
+    Add2RawsList(h30, 30, !expert, image, !saveCorr); 
 
     TH1I * h31 = new TH1I("hCpvEdepM31","ADC Distribution CPV - Module 31", 100, 0, 2000);
     h31->Sumw2(); 
-    Add2RawsList(h31, 31); 
+    Add2RawsList(h31, 31, !expert, image, !saveCorr); 
 
     TH1I * h32 = new TH1I("hCpvEdepM32","ADC Distribution CPV - Module 32", 100, 0, 2000);
     h32->Sumw2();
-    Add2RawsList(h32, 32); 
+    Add2RawsList(h32, 32, !expert, image, !saveCorr); 
 
     TH1I * h33 = new TH1I("hCpvEdepM33","ADC Distribution CPV - Module 33", 100, 0, 2000);
     h33->Sumw2();
-    Add2RawsList(h33, 33); 
+    Add2RawsList(h33, 33, !expert, image, !saveCorr); 
 
     TH1I * h34 = new TH1I("hCpvEdepM34","ADC Distribution CPV - Module 34", 100, 0, 2000);
     h34->Sumw2(); 
-    Add2RawsList(h34, 34); 
+    Add2RawsList(h34, 34, !expert, image, !saveCorr); 
 
     TH1I * h35 = new TH1I("hCpvEdepM35","ADC Distribution CPV - Module 35", 100, 0, 2000);
     h35->Sumw2(); 
-    Add2RawsList(h35, 35); 
+    Add2RawsList(h35, 35, !expert, image, !saveCorr); 
 
     TH1I * h36 = new TH1I("hCpvEdepM36","ADC Distribution CPV - Module 36", 100, 0, 2000);
     h36->Sumw2(); 
-    Add2RawsList(h36, 36); 
+    Add2RawsList(h36, 36, !expert, image, !saveCorr); 
 
     TH1I * h37 = new TH1I("hCpvEdepM37","ADC Distribution CPV - Module 37", 100, 0, 2000);
     h37->Sumw2(); 
-    Add2RawsList(h37, 37); 
+    Add2RawsList(h37, 37, !expert, image, !saveCorr); 
 
     TH1I * h38 = new TH1I("hCpvEdepM38","ADC Distribution CPV - Module 38", 100, 0, 2000);
     h38->Sumw2(); 
-    Add2RawsList(h38, 38); 
+    Add2RawsList(h38, 38, !expert, image, !saveCorr); 
 
     TH1I * h39 = new TH1I("hCpvEdepM39","ADC Distribution CPV - Module 39", 100, 0, 2000);
     h39->Sumw2(); 
-    Add2RawsList(h39, 39); 
+    Add2RawsList(h39, 39, !expert, image, !saveCorr); 
 
     TH1I * h40 = new TH1I("hCpvEdepM40","ADC Distribution CPV - Module 40", 100, 0, 2000);
     h40->Sumw2(); 
-    Add2RawsList(h40, 40); 
+    Add2RawsList(h40, 40, !expert, image, !saveCorr); 
 
     TH1I * h41 = new TH1I("hCpvEdepM41","ADC Distribution CPV - Module 41", 100, 0, 2000);
     h41->Sumw2();
-    Add2RawsList(h41, 41); 
+    Add2RawsList(h41, 41, !expert, image, !saveCorr); 
 
     TH1I * h42 = new TH1I("hCpvEdepM42","ADC Distribution CPV - Module 42", 100, 0, 2000);
     h42->Sumw2(); 
-    Add2RawsList(h42, 42); 
+    Add2RawsList(h42, 42, !expert, image, !saveCorr); 
 
     TH1I * h43 = new TH1I("hCpvEdepM43","ADC Distribution CPV - Module 43", 100, 0, 2000);
     h43->Sumw2(); 
-    Add2RawsList(h43, 43); 
+    Add2RawsList(h43, 43, !expert, image, !saveCorr); 
 
     TH1I * h44 = new TH1I("hCpvEdepM44","ADC Distribution CPV - Module 44", 100, 0, 2000);
     h44->Sumw2(); 
-    Add2RawsList(h44, 44); 
+    Add2RawsList(h44, 44, !expert, image, !saveCorr); 
 
     TH1I * h45 = new TH1I("hCpvEdepM45","ADC Distribution CPV - Module 45", 100, 0, 2000);
     h45->Sumw2();
-    Add2RawsList(h45, 45); 
+    Add2RawsList(h45, 45, !expert, image, !saveCorr); 
 
     TH1I * h46 = new TH1I("hCpvEdepM46","ADC Distribution CPV - Module 46", 100, 0, 2000);
     h46->Sumw2(); 
-    Add2RawsList(h46, 46); 
+    Add2RawsList(h46, 46, !expert, image, !saveCorr); 
 
     TH1I * h47 = new TH1I("hCpvEdepM47","ADC Distribution CPV - Module 47", 100, 0, 2000);
     h47->Sumw2(); 
-    Add2RawsList(h47, 47); 
+    Add2RawsList(h47, 47, !expert, image, !saveCorr); 
 
 
     // Y vs. X for PRE and CPV planes
 
     TH2F * h48 = new TH2F("hPreXY","PRE plane",200,-100.,100.,200,-100.,100.);
-    Add2RawsList(h48, 48,saveForCorr);//Ajay
+    Add2RawsList(h48, 48, !expert, !image, saveCorr);//Ajay
     //Add2RawsList(h48, 48);//Ajay
     TH2F * h49 = new TH2F("hCpvXY","CPV plane",200,-100.,100.,200,-100.,100.);
-    Add2RawsList(h49, 49,saveForCorr);//Ajay
+    Add2RawsList(h49, 49, !expert, !image, saveCorr);//Ajay
     //Add2RawsList(h49, 49);//Ajay
 
 }
@@ -300,45 +302,48 @@ void AliPMDQADataMakerRec::InitRecPoints()
   
     // PRE plane
 
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+
   TH1F * h0 = new TH1F("hPreDdl0Ncell","PRE: Ddl0 Ncell in a cluster",50,0.,50.);
   h0->Sumw2();
-  Add2RecPointsList(h0, 0);
+  Add2RecPointsList(h0, 0, !expert, image);
 
 
   TH1F * h1 = new TH1F("hPreDdl1Ncell","PRE: Ddl1 Ncell in a cluster",50,0.,50.);
   h1->Sumw2();
-  Add2RecPointsList(h1, 1);
+  Add2RecPointsList(h1, 1, !expert, image);
 
 
   TH1F * h2 = new TH1F("hPreDdl2Ncell","PRE: Ddl2 Ncell in a cluster",50,0.,50.);
   h2->Sumw2();
-  Add2RecPointsList(h2, 2);
+  Add2RecPointsList(h2, 2, !expert, image);
 
 
   TH1F * h3 = new TH1F("hPreDdl3Ncell","PRE: Ddl3 Ncell in a cluster",50,0.,50.);
   h3->Sumw2();
-  Add2RecPointsList(h3, 3);
+  Add2RecPointsList(h3, 3, !expert, image);
 
   // CPV plane
 
   TH1F * h4 = new TH1F("hCpvDdl4Ncell","CPV: Ddl4 Ncell in a cluster",50,0.,50.);
   h4->Sumw2();
-  Add2RecPointsList(h4, 4);
+  Add2RecPointsList(h4, 4, !expert, image);
 
   TH1F * h5 = new TH1F("hCpvDdl5Ncell","CPV: Ddl5 Ncell in a cluster",50,0.,50.);
   h5->Sumw2();
-  Add2RecPointsList(h5, 5);
+  Add2RecPointsList(h5, 5, !expert, image);
 
   // Correlation plot
 
   TH2I *h6 = new TH2I("hPre10","Cluster - DDL1 vs DDL0", 100,0,200,100,0,200);
-  Add2RecPointsList(h6,6);
+  Add2RecPointsList(h6,6, !expert, image);
 
   TH2I *h7 = new TH2I("hPre32","Cluster - DDL3 vs DDL2", 100,0,200,100,0,200);
-  Add2RecPointsList(h7,7);
+  Add2RecPointsList(h7,7, !expert, image);
 
   TH2I *h8 = new TH2I("hCpv54","Cluster - DDL5 vs DDL4", 100,0,200,100,0,200);
-  Add2RecPointsList(h8,8);
+  Add2RecPointsList(h8,8, !expert, image);
 
 
 
@@ -350,22 +355,25 @@ void AliPMDQADataMakerRec::InitESDs()
 {
   //Create histograms to controll ESD
 
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+
   TH1F *h0 = new TH1F("hPreClADC","Cluster ADC of PRE plane",500,0.,10000.);
   h0->Sumw2();
-  Add2ESDsList(h0, 0)  ;
+  Add2ESDsList(h0, 0, !expert, image)  ;
 
   TH1F *h1 = new TH1F("hCpvClADC","Cluster ADC of CPV plane",500,0.,10000.);
   h1->Sumw2();
-  Add2ESDsList(h1, 1)  ;
+  Add2ESDsList(h1, 1, !expert, image)  ;
 
   TH2I *h2 = new TH2I("hPmdClMult","Cluster Multiplicity: PRE vs. CPVplane",100,0,1000,100,0,1000);
   h2->Sumw2();
-  Add2ESDsList(h2, 2)  ;
+  Add2ESDsList(h2, 2, !expert, image)  ;
 
 /*
   TH1I * h3 = new TH1I("hCpvClMult","Cluster Multiplicity of CPV plane",100,0.,1000.);
   h3->Sumw2();
-  Add2ESDsList(h3, 3)  ;
+  Add2ESDsList(h3, 3, !expert, image)  ;
 */
 
 }
index 81c1918..c19afe6 100644 (file)
@@ -70,68 +70,74 @@ AliPMDQADataMakerSim& AliPMDQADataMakerSim::operator = (const AliPMDQADataMakerS
 void AliPMDQADataMakerSim::InitHits()
 {
     // create Hits histograms in Hits subdir
-
-    TH1F *h0 = new TH1F("hPreHitsEdep","Hits energy distribution in (keV)PRE(PMD)", 500, 0., 500.); 
-    h0->Sumw2() ;
-    Add2HitsList(h0, 0) ;
-
-    TH1F *h1 = new TH1F("hCpvHitsEdep","Hits energy distribution in (keV)CPV(PMD)", 500, 0., 500.); 
-    h1->Sumw2() ;
-    Add2HitsList(h1, 1) ;
-
-    TH1I *h2 = new TH1I("hPreHitsMult","Hits multiplicity distribution in PRE(PMD)", 500, 0, 3000) ; 
-    h2->Sumw2() ;
-    Add2HitsList(h2, 2) ;
-
-    TH1I *h3 = new TH1I("hCpvHitsMult","Hits multiplicity distribution in PRE(PMD)", 500, 0, 3000) ; 
-    h2->Sumw2() ;
-    Add2HitsList(h3, 3) ;
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  TH1F *h0 = new TH1F("hPreHitsEdep","Hits energy distribution in (keV)PRE(PMD)", 500, 0., 500.); 
+  h0->Sumw2() ;
+  Add2HitsList(h0, 0, !expert, image) ;
+  
+  TH1F *h1 = new TH1F("hCpvHitsEdep","Hits energy distribution in (keV)CPV(PMD)", 500, 0., 500.); 
+  h1->Sumw2() ;
+  Add2HitsList(h1, 1, !expert, image) ;
+  
+  TH1I *h2 = new TH1I("hPreHitsMult","Hits multiplicity distribution in PRE(PMD)", 500, 0, 3000) ; 
+  h2->Sumw2() ;
+  Add2HitsList(h2, 2, !expert, image) ;
+  
+  TH1I *h3 = new TH1I("hCpvHitsMult","Hits multiplicity distribution in PRE(PMD)", 500, 0, 3000) ; 
+  h2->Sumw2() ;
+  Add2HitsList(h3, 3, !expert, image) ;
 }
 
 //____________________________________________________________________________ 
 void AliPMDQADataMakerSim::InitSDigits()
 {
     // create SDigits histograms in SDigits subdir
-
-    TH1F *h0 = new TH1F("hPreSDigitsEdep","SDigits energy distribution in(keV) PRE(PMD)", 500, 0., 500.);
-    h0->Sumw2();
-    Add2SDigitsList(h0, 0);
-
-    TH1F *h1 = new TH1F("hCpvSDigitsEdep","SDigits energy distribution in (keV)CPV(PMD)", 500, 0., 500.);
-    h1->Sumw2();
-    Add2SDigitsList(h1, 1);
-
-    TH1I *h2 = new TH1I("hPreSDigitsMult","SDigits multiplicity distribution in PRE(PMD)", 500, 0., 1000.);
-    h2->Sumw2();
-    Add2SDigitsList(h2, 2);
-
-    TH1I *h3 = new TH1I("hCpvSDigitsMult","SDigits multiplicity distribution in CPV(PMD)", 500, 0., 1000.);
-    h3->Sumw2();
-    Add2SDigitsList(h3, 3);
-
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  TH1F *h0 = new TH1F("hPreSDigitsEdep","SDigits energy distribution in(keV) PRE(PMD)", 500, 0., 500.);
+  h0->Sumw2();
+  Add2SDigitsList(h0, 0, !expert, image);
+  
+  TH1F *h1 = new TH1F("hCpvSDigitsEdep","SDigits energy distribution in (keV)CPV(PMD)", 500, 0., 500.);
+  h1->Sumw2();
+  Add2SDigitsList(h1, 1, !expert, image);
+  
+  TH1I *h2 = new TH1I("hPreSDigitsMult","SDigits multiplicity distribution in PRE(PMD)", 500, 0., 1000.);
+  h2->Sumw2();
+  Add2SDigitsList(h2, 2, !expert, image);
+  
+  TH1I *h3 = new TH1I("hCpvSDigitsMult","SDigits multiplicity distribution in CPV(PMD)", 500, 0., 1000.);
+  h3->Sumw2();
+  Add2SDigitsList(h3, 3, !expert, image);
+  
 }
 
 //____________________________________________________________________________
 void AliPMDQADataMakerSim::InitDigits()
 {
     // create Digits histograms in Digits subdir
-
-    TH1F *h0 = new TH1F("hPreDigitsEdep","Digits energy distribution in PRE(PMD)", 100, 0., 2000.);
-    h0->Sumw2();
-    Add2DigitsList(h0, 0);
-
-    TH1F *h1 = new TH1F("hCpvDigitsEdep","Digits energy distribution in CPV(PMD)", 100, 0., 2000.); 
-    h1->Sumw2();
-    Add2DigitsList(h1, 1);
-
-    TH1I *h2 = new TH1I("hPreDigitsMult","Digits multiplicity distribution in PRE(PMD)", 500, 0, 1000) ; 
-    h2->Sumw2();
-    Add2DigitsList(h2, 2);
-
-    TH1I *h3 = new TH1I("hCpvDigitsMult","Digits multiplicity distribution in CPV(PMD)", 500, 0, 1000);
-    h3->Sumw2();
-    Add2DigitsList(h3, 3);
-
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  TH1F *h0 = new TH1F("hPreDigitsEdep","Digits energy distribution in PRE(PMD)", 100, 0., 2000.);
+  h0->Sumw2();
+  Add2DigitsList(h0, 0, !expert, image);
+  
+  TH1F *h1 = new TH1F("hCpvDigitsEdep","Digits energy distribution in CPV(PMD)", 100, 0., 2000.); 
+  h1->Sumw2();
+  Add2DigitsList(h1, 1, !expert, image);
+
+  TH1I *h2 = new TH1I("hPreDigitsMult","Digits multiplicity distribution in PRE(PMD)", 500, 0, 1000) ; 
+  h2->Sumw2();
+  Add2DigitsList(h2, 2, !expert, image);
+  
+  TH1I *h3 = new TH1I("hCpvDigitsMult","Digits multiplicity distribution in CPV(PMD)", 500, 0, 1000);
+  h3->Sumw2();
+  Add2DigitsList(h3, 3, !expert, image);
+  
 }
 
 //____________________________________________________________________________ 
index 41a6a56..34259cc 100644 (file)
@@ -91,7 +91,7 @@ AliQADataMaker::AliQADataMaker(const AliQADataMaker& qadm) :
 }
 
 //____________________________________________________________________________
-Int_t AliQADataMaker::Add2List(TH1 * hist, const Int_t index, TObjArray ** list, const Bool_t expert, const Bool_t saveForCorr) 
+Int_t AliQADataMaker::Add2List(TH1 * hist, const Int_t index, TObjArray ** list, const Bool_t expert, const Bool_t image, const Bool_t saveForCorr) 
 { 
        // Set histograms memory resident and add to the list
        // Maximm allowed is 10000
@@ -105,8 +105,10 @@ Int_t AliQADataMaker::Add2List(TH1 * hist, const Int_t index, TObjArray ** list,
                AliError("Max number of authorized QA objects is 10000") ; 
   } else {    
     if (expert) 
-      hist->SetBit(AliQAv1::GetExpertBit()) ; 
-               TH1 * histClone[AliRecoParam::kNSpecies] ; 
+      hist->SetBit(AliQAv1::GetExpertBit()) ;
+    if (image) 
+      hist->SetBit(AliQAv1::GetImageBit()) ;  
+    TH1 * histClone[AliRecoParam::kNSpecies] ; 
     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
       histClone[specie] = CloneMe(hist, specie) ; 
       histClone[specie]->SetDirectory(0) ; 
@@ -179,3 +181,4 @@ TObject * AliQADataMaker::GetData(TObjArray ** list, const Int_t index)
                return NULL ;           
        }
 }
+
index 1c25652..e07b211 100644 (file)
@@ -41,12 +41,12 @@ public:
        AliQADataMaker(const AliQADataMaker& qadm) ;   
        virtual ~AliQADataMaker() {} // dtor
   
-       virtual Int_t Add2DigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE)          = 0 ; 
-       virtual Int_t Add2ESDsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE)            = 0 ; 
-       virtual Int_t Add2HitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE)            = 0 ; 
-       virtual Int_t Add2RecPointsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE)       = 0 ; 
-       virtual Int_t Add2RawsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t saveForCorr = kFALSE)            = 0 ; 
-       virtual Int_t Add2SDigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE)         = 0 ; 
+       virtual Int_t Add2DigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE)          = 0 ; 
+       virtual Int_t Add2ESDsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE)            = 0 ; 
+       virtual Int_t Add2HitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE)            = 0 ; 
+       virtual Int_t Add2RecPointsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE)       = 0 ; 
+       virtual Int_t Add2RawsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t saveForCorr = kFALSE, const Bool_t image = kFALSE)            = 0 ; 
+       virtual Int_t Add2SDigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE)         = 0 ; 
        virtual void        Exec(AliQAv1::TASKINDEX_t, TObject * data)                                       = 0 ;
        virtual void        EndOfCycle()                                           = 0 ;
        virtual void        EndOfCycle(AliQAv1::TASKINDEX_t        )                 = 0 ;
@@ -63,6 +63,7 @@ public:
        virtual TObjArray** Init(AliQAv1::TASKINDEX_t, Int_t cycles = -1)                               = 0 ;
        virtual void        Init(AliQAv1::TASKINDEX_t, TObjArray ** list, Int_t run, Int_t cycles = -1) = 0 ;
        Bool_t              IsCycleDone() const { return fCycleCounter > fCycle ? kTRUE : kFALSE ; }
+  virtual void        MakeImage(AliQAv1::TASKINDEX_t task) = 0 ; 
        void                Reset() { fCycleCounter = 0 ; }
        void                SetCycle(Int_t nevts) { fCycle = nevts ; } 
   void                SetWriteExpert() { fWriteExpert = kTRUE ; }
@@ -76,7 +77,7 @@ public:
          
 protected: 
 
-       Int_t          Add2List(TH1 * hist, const Int_t index, TObjArray ** list, const Bool_t expert = kFALSE, const Bool_t saveForCorr = kFALSE) ;
+       Int_t          Add2List(TH1 * hist, const Int_t index, TObjArray ** list, const Bool_t expert = kFALSE, const Bool_t image = kFALSE, const Bool_t saveForCorr = kFALSE) ;
   TH1 *          CloneMe(TH1 * hist, Int_t specie) const ; 
        virtual void   DefaultEndOfDetectorCycle(AliQAv1::TASKINDEX_t task ) ; 
        virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list ) = 0 ; 
index f6d0522..ca25a02 100644 (file)
@@ -24,6 +24,7 @@
 //
 
 // --- ROOT system ---
+#include <TCanvas.h>
 #include <TFile.h>
 #include <TTree.h>
 #include <TNtupleD.h>
@@ -182,8 +183,87 @@ void AliQADataMakerRec::EndOfCycle(AliQAv1::TASKINDEX_t task)
     }
     fOutput->Save() ; 
        }
+  MakeImage(task) ; 
 }
+
+//____________________________________________________________________________ 
+void AliQADataMakerRec::MakeImage(AliQAv1::TASKINDEX_t task)
+{
+  // create a drawing of detetor defined histograms
+  TObjArray ** list = NULL ;  
+  switch (task) {
+    case AliQAv1::kRAWS:
+      list = fRawsQAList ; 
+      break;
+    case AliQAv1::kHITS:
+      break;
+    case AliQAv1::kSDIGITS:
+      break;  
+    case AliQAv1::kDIGITS:
+      break;  
+    case AliQAv1::kRECPOINTS:
+      list = fRecPointsQAList ; 
+      break;
+    case AliQAv1::kTRACKSEGMENTS:
+      break;
+    case AliQAv1::kRECPARTICLES:
+      break;
+    case AliQAv1::kESDS:
+      list = fESDsQAList ; 
+      break;
+    case AliQAv1::kNTASKINDEX:
+      break;
+    default:
+      break;
+  }
+  if ( !list) {
+    AliError("data not initialized, call AliQADataMaker::Init"); 
+    return ; 
+  }
+  TIter next(list[0]) ;  
+  TH1 * hdata = NULL ; 
+  Int_t nImages = 0 ;
+  while ( (hdata=dynamic_cast<TH1 *>(next())) ) {
+    if ( hdata->TestBit(AliQAv1::GetImageBit()) )
+      nImages++; 
+  }
+  if ( nImages == 0 ) {
+    AliInfo(Form("No histogram will be plotted for %s %s\n", GetName(), AliQAv1::GetTaskName(task).Data())) ;  
+  } else {
+    AliInfo(Form("%d histograms will be plotted for %s %s\n", nImages, GetName(), AliQAv1::GetTaskName(task).Data())) ;  
+    Double_t w  = 1000 ;
+    Double_t h  = 1000 ;
+    for (Int_t esIndex = 0 ; esIndex < AliRecoParam::kNSpecies ; esIndex++) {
+      TCanvas * canvasQA = new TCanvas(Form("QA_%s_%s_%s", 
+                                            GetName(), 
+                                            AliQAv1::GetTaskName(task).Data(), 
+                                            AliRecoParam::GetEventSpecieName(esIndex)), 
+                                       Form("QA control plots for det=%s task=%s eventspecie=%s", 
+                                            GetName(), 
+                                            AliQAv1::GetTaskName(task).Data(), 
+                                            AliRecoParam::GetEventSpecieName(esIndex)), 
+                                       w, h) ;
+      canvasQA->SetWindowSize(w + (w - canvasQA->GetWw()), h + (h - canvasQA->GetWh())) ;
+      Int_t nx = TMath::Sqrt(nImages) ; 
+      Int_t ny = nx  ; 
+      if ( nx < TMath::Sqrt(nImages)) 
+        ny++ ; 
+      canvasQA->Divide(nx, ny) ; 
+      TIter nexthist(list[esIndex]) ; 
+      TH1* hist = NULL ;
+      Int_t npad = 1 ; 
+      canvasQA->cd(npad) ; 
+      while ( (hist=dynamic_cast<TH1*>(nexthist())) ) {
+        if(hist->TestBit(AliQAv1::GetImageBit())) {
+          hist->Draw() ; 
+          canvasQA->cd(++npad) ; 
+        }
+      }
+      canvasQA->Print() ; 
+    }
+  }
+}
+
 //____________________________________________________________________________
 void AliQADataMakerRec::Exec(AliQAv1::TASKINDEX_t task, TObject * data) 
 { 
index 0af5701..187d703 100644 (file)
@@ -31,12 +31,13 @@ public:
        AliQADataMakerRec& operator = (const AliQADataMakerRec& qadm) ;
        virtual ~AliQADataMakerRec() ; // dtor
   
-       virtual Int_t Add2DigitsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/)    { return -1 ; } 
-       virtual Int_t Add2ESDsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE)  { return Add2List(hist, index, fESDsQAList, expert) ; }
-       virtual Int_t Add2HitsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/)       { return -1 ; }  
-       virtual Int_t Add2RecPointsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE)  { return Add2List(hist, index, fRecPointsQAList, expert) ; }
-       virtual Int_t Add2RawsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t saveForCorr = kFALSE)  { return Add2List(hist, index, fRawsQAList, expert, saveForCorr) ; }
-       virtual Int_t Add2SDigitsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/)   { return -1 ; } 
+       virtual Int_t Add2DigitsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/, const Bool_t /*image = kFALSE*/)    { return -1 ; } 
+       virtual Int_t Add2ESDsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE)  { return Add2List(hist, index, fESDsQAList, expert, image) ; }
+       virtual Int_t Add2HitsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/, const Bool_t /*image = kFALSE*/)       { return -1 ; }  
+       virtual Int_t Add2RecPointsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE)  { return Add2List(hist, index, fRecPointsQAList, expert, image) ; }
+       virtual Int_t Add2RawsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t saveForCorr = kFALSE, const Bool_t image = kFALSE)  { 
+    return Add2List(hist, index, fRawsQAList, expert, saveForCorr, image) ; }
+       virtual Int_t Add2SDigitsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/, const Bool_t /*image = kFALSE*/)   { return -1 ; } 
        virtual void        Exec(AliQAv1::TASKINDEX_t task, TObject * data) ;
        virtual void        EndOfCycle() ;
        virtual void        EndOfCycle(AliQAv1::TASKINDEX_t task) ;
@@ -47,6 +48,7 @@ public:
        virtual TH1 *       GetRecPointsData(const Int_t index)  { return dynamic_cast<TH1 *>(GetData(fRecPointsQAList, index)) ; }
        virtual TH1 *       GetRawsData(const Int_t index)       { return dynamic_cast<TH1 *>(GetData(fRawsQAList, index))  ; }
        virtual TH1 *       GetSDigitsData(const Int_t /*index*/)   { return NULL ; }  
+  virtual void        MakeImage(AliQAv1::TASKINDEX_t task) ; 
        virtual TObjArray** Init(AliQAv1::TASKINDEX_t task, Int_t cycles = -1) ;
        virtual void        Init(AliQAv1::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles = -1) ;
        virtual void        StartOfCycle(Int_t run = -1) ;
index 2dd293f..c8c7a89 100644 (file)
@@ -24,6 +24,7 @@
 //
 
 // --- ROOT system ---
+#include <TCanvas.h>
 #include <TFile.h>
 #include <TTree.h>
 #include <TClonesArray.h>
@@ -151,7 +152,7 @@ void AliQADataMakerSim::EndOfCycle(AliQAv1::TASKINDEX_t task)
     }
     fOutput->Save() ; 
   }
-  ResetCycle() ; 
+  MakeImage(task) ; 
 }
  
 //____________________________________________________________________________
@@ -202,6 +203,84 @@ void AliQADataMakerSim::Exec(AliQAv1::TASKINDEX_t task, TObject * data)
 }
 
 //____________________________________________________________________________ 
+void AliQADataMakerSim::MakeImage(AliQAv1::TASKINDEX_t task)
+{
+  // create a drawing of detetor defined histograms
+  TObjArray ** list = NULL ;  
+  switch (task) {
+    case AliQAv1::kRAWS:
+      break;
+    case AliQAv1::kHITS:
+      list = fHitsQAList ;
+      break;
+    case AliQAv1::kSDIGITS:
+      list = fSDigitsQAList ;
+      break;  
+    case AliQAv1::kDIGITS:
+      list = fDigitsQAList ;
+      break;  
+    case AliQAv1::kRECPOINTS:
+      break;
+    case AliQAv1::kTRACKSEGMENTS:
+      break;
+    case AliQAv1::kRECPARTICLES:
+      break;
+    case AliQAv1::kESDS:
+      break;
+    case AliQAv1::kNTASKINDEX:
+      break;
+    default:
+    break;
+  }
+  if ( !list) {
+    AliFatal("data not initialized, call AliQADataMaker::Init"); 
+  return ; 
+  }
+  TIter next(list[0]) ;  
+  TH1 * hdata = NULL ; 
+  Int_t nImages = 0 ;
+  while ( (hdata=dynamic_cast<TH1 *>(next())) ) {
+    if ( hdata->TestBit(AliQAv1::GetImageBit()) )
+      nImages++; 
+  }
+  if ( nImages == 0 ) {
+    AliInfo(Form("No histogram will be plotted for %s %s\n", GetName(), AliQAv1::GetTaskName(task).Data())) ;  
+  } else {
+    AliInfo(Form("%d histograms will be plotted for %s %s\n", nImages, GetName(), AliQAv1::GetTaskName(task).Data())) ;  
+    Double_t w  = 1000 ;
+    Double_t h  = 1000 ;
+    for (Int_t esIndex = 0 ; esIndex < AliRecoParam::kNSpecies ; esIndex++) {
+      TCanvas * canvasQA = new TCanvas(Form("QA_%s_%s_%s", 
+                                            GetName(), 
+                                            AliQAv1::GetTaskName(task).Data(), 
+                                            AliRecoParam::GetEventSpecieName(esIndex)), 
+                                       Form("QA control plots for det=%s task=%s eventspecie=%s", 
+                                            GetName(), 
+                                            AliQAv1::GetTaskName(task).Data(), 
+                                            AliRecoParam::GetEventSpecieName(esIndex)), 
+                                       w, h) ;
+      canvasQA->SetWindowSize(w + (w - canvasQA->GetWw()), h + (h - canvasQA->GetWh())) ;
+      Int_t nx = TMath::Sqrt(nImages) ; 
+      Int_t ny = nx  ; 
+      if ( nx < TMath::Sqrt(nImages)) 
+        ny++ ; 
+      canvasQA->Divide(nx, ny) ; 
+      TIter nexthist(list[esIndex]) ; 
+      TH1* hist = NULL ;
+      Int_t npad = 1 ; 
+      canvasQA->cd(npad) ; 
+      while ( (hist=dynamic_cast<TH1*>(nexthist())) ) {
+        if(hist->TestBit(AliQAv1::GetImageBit())) {
+          hist->Draw() ; 
+          canvasQA->cd(++npad) ; 
+        }
+      }
+      canvasQA->Print() ; 
+    }
+  }
+}
+
+//____________________________________________________________________________ 
 TObjArray **  AliQADataMakerSim::Init(AliQAv1::TASKINDEX_t task, Int_t cycles)
 {
   // general intialisation
index 143688e..3b7a0a2 100644 (file)
@@ -28,12 +28,12 @@ public:
        AliQADataMakerSim& operator = (const AliQADataMakerSim& qadm) ;
        virtual ~AliQADataMakerSim() ; // dtor
   
-       virtual Int_t Add2DigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE)    { return Add2List(hist, index, fDigitsQAList, expert) ; }
-       virtual Int_t Add2ESDsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/)      { return -1 ; } 
-       virtual Int_t Add2HitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE)      { return Add2List(hist, index, fHitsQAList, expert) ; }
-       virtual Int_t Add2RecPointsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/) { return -1 ; } 
-       virtual Int_t Add2RawsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/, const Bool_t /*saveForCorr = kFALSE*/)      { return -1 ; }  
-       virtual Int_t Add2SDigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE)   { return Add2List(hist, index, fSDigitsQAList, expert) ; }
+       virtual Int_t Add2DigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE)    { return Add2List(hist, index, fDigitsQAList, expert, image) ; }
+       virtual Int_t Add2ESDsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/, const Bool_t /*image = kFALSE*/)      { return -1 ; } 
+       virtual Int_t Add2HitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE)      { return Add2List(hist, index, fHitsQAList, expert, image) ; }
+       virtual Int_t Add2RecPointsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/, const Bool_t /*image = kFALSE*/) { return -1 ; } 
+       virtual Int_t Add2RawsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/, const Bool_t /*saveForCorr = kFALSE*/, const Bool_t /*image = kFALSE*/)      { return -1 ; }  
+       virtual Int_t Add2SDigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE)   { return Add2List(hist, index, fSDigitsQAList, expert, image) ; }
        virtual void        Exec(AliQAv1::TASKINDEX_t task, TObject * data) ;
        virtual void        EndOfCycle() ;
        virtual void        EndOfCycle(AliQAv1::TASKINDEX_t task) ;
@@ -46,6 +46,7 @@ public:
        virtual TH1 *       GetSDigitsData(const Int_t index)   { return dynamic_cast<TH1 *>(GetData(fSDigitsQAList, index)) ; }
        virtual TObjArray** Init(AliQAv1::TASKINDEX_t task, Int_t cycles = -1) ;
        virtual void        Init(AliQAv1::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles = -1) ;
+  virtual void        MakeImage(AliQAv1::TASKINDEX_t task) ; 
        virtual void        StartOfCycle(Int_t run = -1) ;
        virtual void        StartOfCycle(AliQAv1::TASKINDEX_t task, Int_t run, const Bool_t sameCycle = kFALSE) ;
 
@@ -70,7 +71,7 @@ protected:
 
        TObjArray * *    fDigitsQAList ;    //! list of the digits QA data objects
        TObjArray * *    fHitsQAList ;      //! list of the hits QA data objects
-       TObjArray * *   fSDigitsQAList ;   //! list of the sdigits QA data objects
+       TObjArray * *    fSDigitsQAList ;   //! list of the sdigits QA data objects
   
  ClassDef(AliQADataMakerSim,1)  // description 
 
index 6118e53..7db371b 100644 (file)
@@ -46,7 +46,7 @@
 
 
 ClassImp(AliQAv1)
-AliQAv1    * AliQAv1::fgQA                   = 0x0 ;
+AliQAv1  * AliQAv1::fgQA                   = 0x0 ;
 TFile    * AliQAv1::fgQADataFile           = 0x0 ;   
 TString    AliQAv1::fgQADataFileName       = "QA" ;  // will transform into Det.QA.run.root  
 TFile    * AliQAv1::fgQARefFile            = 0x0 ;   
@@ -71,6 +71,7 @@ const TString AliQAv1::fgkQARefOCDBDefault = "alien://folder=/alice/QA/20"  ;
 const TString AliQAv1::fgkExpert           = "Expert" ; 
 const UInt_t  AliQAv1::fgkExpertBit        = 16 ; 
 const UInt_t  AliQAv1::fgkQABit            = 17 ; 
+const UInt_t  AliQAv1::fgkImageBit         = 18 ; 
 
 //____________________________________________________________________________
 AliQAv1::AliQAv1() : 
index 1404407..8e3a017 100644 (file)
@@ -49,6 +49,7 @@ public:
   Bool_t *               GetEventSpecies() { return fEventSpecies ; }
   static const TString   GetExpert() { return fgkExpert ; }
   static       UInt_t    GetExpertBit() { return fgkExpertBit ; }
+  static       UInt_t    GetImageBit()  { return fgkImageBit ; }
   static const TString   GetLabLocalFile() { return fgkLabLocalFile ; } 
   static const TString   GetLabLocalOCDB() { return fgkLabLocalOCDB ; } 
   static const TString   GetLabAliEnOCDB() { return fgkLabAliEnOCDB ; } 
@@ -136,6 +137,7 @@ private:
   static TString       fgTaskNames[]           ; //! list of tasks names   
   static const TString fgkExpert              ; //! name for the expert directory
   static const UInt_t  fgkExpertBit           ; //! TObject bit identifing the object as "expert"
+  static const UInt_t  fgkImageBit            ; //! TObject bit identifing the object to be plotted on the QA image
   static const TString fgkLabLocalFile        ; //! label to identify a file as local 
   static const TString fgkLabLocalOCDB        ; //! label to identify a file as local OCDB 
   static const TString fgkLabAliEnOCDB        ; //! label to identify a file as AliEn OCDB 
index 3da4b08..1df4f68 100644 (file)
@@ -127,11 +127,15 @@ void AliT0QADataMakerRec::StartOfDetectorCycle()
 void AliT0QADataMakerRec::InitRaws()
 {
   // create Raw histograms in Raw subdir
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t saveCorr = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TString timename, ampname, qtcname, ledname;
   TString timeCalname, ampCalname, ledCalname, qtcCalname;
 
   TH1F* fhRefPoint = new TH1F("hRefPoint","Ref Point", 10,1252170, 1252180);
-  Add2RawsList( fhRefPoint,0);
+  Add2RawsList( fhRefPoint,0, !expert, image, !saveCorr);
    
   TH1F *fhRawCFD[24]; TH1F * fhRawLEDamp[24];
   TH1F *fhRawQTC[24]; TH1F * fhRawLED[24];
@@ -149,27 +153,25 @@ void AliT0QADataMakerRec::InitRaws()
       qtcname += i;
       ledname += i;
       fhRawCFD[i] = new TH1F(timename.Data(), timename.Data(),500,-250,250);
-      Add2RawsList( fhRawCFD[i],i+1);
+      Add2RawsList( fhRawCFD[i],i+1, !expert, image, !saveCorr);
       fhRawLED[i] = new TH1F(ledname.Data(), ledname.Data(),2000,-1000,1000);
-      Add2RawsList( fhRawLED[i],i+24+1);
+      Add2RawsList( fhRawLED[i],i+24+1, !expert, image, !saveCorr);
       fhRawLEDamp[i] = new TH1F(ampname.Data(), ampname.Data(),100,300,600);
-      Add2RawsList( fhRawLEDamp[i],i+48+1);
+      Add2RawsList( fhRawLEDamp[i],i+48+1, !expert, image, !saveCorr);
       fhRawQTC[i] = new TH1F(qtcname.Data(), qtcname.Data(),1500,1000,7000);
-      Add2RawsList( fhRawQTC[i],i+72+1);
+      Add2RawsList( fhRawQTC[i],i+72+1, !expert, image, !saveCorr);
      }
-  //  const Bool_t saveForCorr = kTRUE;
-  const Bool_t saveForCorr = kFALSE;
   TH1F* fhRawTrigger = new TH1F("hRawTrigger"," phys triggers",5,0,5);
-  Add2RawsList(fhRawTrigger ,97);
+  Add2RawsList(fhRawTrigger ,97, !expert, image, !saveCorr);
   
   TH1F* fhRawMean = new TH1F("hRawMean","online mean signal", 100,2400,2500);
-  Add2RawsList( fhRawMean,98);
+  Add2RawsList( fhRawMean,98, !expert, image, !saveCorr);
   TH1F* fhRawVertex = new TH1F("hRawVertex","online vertex signal", 100,0,600);
-  Add2RawsList( fhRawVertex,99);
+  Add2RawsList( fhRawVertex,99, !expert, image, !saveCorr);
   TH1F* fhRawORA = new TH1F("hRawORA","online OR A", 100,2500,2800);
-  Add2RawsList( fhRawORA,100);
+  Add2RawsList( fhRawORA,100, !expert, image, !saveCorr);
   TH1F* fhRawORC = new TH1F("hRawORC","online OR C", 100,2000,2300);
-  Add2RawsList( fhRawORC,101);
+  Add2RawsList( fhRawORC,101, !expert, image, !saveCorr);
   
   for (Int_t i=0; i<24; i++)
     {
@@ -183,54 +185,54 @@ void AliT0QADataMakerRec::InitRaws()
       ampCalname += i;
       qtcCalname += i;
       fhRawCFDcal[i] = new TH1F(timeCalname.Data(), timeCalname.Data(),2000,-1000,1000);
-      Add2RawsList( fhRawCFDcal[i],101+i+1);
+      Add2RawsList( fhRawCFDcal[i],101+i+1, !expert, image, !saveCorr);
       fhRawLEDcal[i] = new TH1F(ledCalname.Data(), ledCalname.Data(),2000,-1000,1000);
-      Add2RawsList( fhRawLEDcal[i],101+i+24+1);
+      Add2RawsList( fhRawLEDcal[i],101+i+24+1, !expert, image, !saveCorr);
       fhRawLEDampcal[i] = new TH1F(ampCalname.Data(), ampCalname.Data(),300,300,600);
-      Add2RawsList( fhRawLEDampcal[i],101+i+48+1);
+      Add2RawsList( fhRawLEDampcal[i],101+i+48+1, !expert, image, !saveCorr);
       fhRawQTCcal[i] = new TH1F(qtcCalname.Data(), qtcCalname.Data(),1000,0,7000);
-      Add2RawsList( fhRawQTCcal[i],101+i+72+1);
+      Add2RawsList( fhRawQTCcal[i],101+i+72+1, !expert, image, !saveCorr);
     }
 
   TH1F* fhRawTriggerCal = new TH1F("hRawTriggerCal"," laser triggers",6,0,6);
-  Add2RawsList(fhRawTriggerCal ,197 ,saveForCorr);
+  Add2RawsList(fhRawTriggerCal ,197 , !expert, !image, saveCorr);
 
   TH1F* fhRawMeanCal = new TH1F("hRawMeanCal","online mean signal, calibration event",
                                10000,0,10000);
   Add2RawsList( fhRawMeanCal,198);
   TH1F* fhRawVertexCal = new TH1F("hRawVertexCal","online vertex signal, calibration even ",
                                  10000,0,10000);
-  Add2RawsList( fhRawVertexCal,199);
+  Add2RawsList( fhRawVertexCal,199, !expert, image, !saveCorr);
   TH1F* fhRawORAcal = new TH1F("hRawORAcal","online OR A", 10000,0,10000);
-  Add2RawsList( fhRawORAcal,200 );
+  Add2RawsList( fhRawORAcal,200, !expert, image, !saveCorr );
   TH1F* fhRawORCcal = new TH1F("hRawORCcal","online OR C", 10000,0,10000);
-  Add2RawsList( fhRawORCcal,201);
+  Add2RawsList( fhRawORCcal,201, !expert, image, !saveCorr);
   TH1F* fhMultcal = new TH1F("hMultcal","full mulltiplicity", 10000,0,10000);
-  Add2RawsList( fhMultcal,202 );
+  Add2RawsList( fhMultcal,202, !expert, image, !saveCorr );
   TH1F* fhMultScal = new TH1F("hMultScal","full multiplicity with semi-central trigger",
                              10000,0,10000);
-  Add2RawsList( fhMultScal,203);
+  Add2RawsList( fhMultScal,203, !expert, image, !saveCorr);
   TH1F* fhMultCcal = new TH1F("hMultCcal","full multiplicity with central trigger", 
                              1000,0,10000);
-  Add2RawsList( fhMultCcal,204);
+  Add2RawsList( fhMultCcal,204, !expert, image, !saveCorr);
 
   //  TH2F* fhEffCFD = new TH2F("hEffCFD"," CFD time",24, 0 ,24, 
   //                 100,-500,500);
   TH2F* fhEffCFD = new TH2F("hEffCFD"," CFD time",24, 0 ,24, 50, 0,5); 
 
-  Add2RawsList( fhEffCFD,205, saveForCorr);
+  Add2RawsList( fhEffCFD,205, !expert, !image, saveCorr);
   TH2F* fhEffLED = new TH2F("hEffLED","LED time",24, 0 ,24, 
                            100, 0, 5); 
   //100,-500,500);
 
-  Add2RawsList( fhEffLED,206, saveForCorr);
+  Add2RawsList( fhEffLED,206, !expert, !image, saveCorr);
   TH2F* fhEffQTC = new TH2F("hEffQTC","QTC amplitude",24, 0 ,24, 
                              100,0,7000);
-  Add2RawsList( fhEffQTC,207, saveForCorr);
+  Add2RawsList( fhEffQTC,207, !expert, !image, saveCorr);
   //yeys guide line
   //  TH2F* fhLineQTC = new TH2F("hLineQTC","QTC amplitude boeder",24, 0 ,24, 
   //                         100,0,7000);
-//  Add2RawsList( fhLineQTC,208, saveForCorr);
+//  Add2RawsList( fhLineQTC,208, !expert, !image, saveCorr);
 }
 
 //____________________________________________________________________________ 
@@ -238,30 +240,32 @@ void AliT0QADataMakerRec::InitRaws()
 void AliT0QADataMakerRec::InitRecPoints()
 {
   // create cluster histograms in RecPoint subdir
-
-
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
 
   TH2F* fhRecCFD = new TH2F("hRecCFD"," CFD time",24, 0 ,24, 
                              100,-50,50);
-  Add2RecPointsList ( fhRecCFD,0);
+  Add2RecPointsList ( fhRecCFD,0, !expert, image);
 
   TH2F* fhRecAmpDiff = new TH2F("hRecAmpDiff"," LED-CFD  min QTC amplitude",
                                24, 0 ,24, 200,-10,10);
-  Add2RecPointsList (fhRecAmpDiff, 1);
+  Add2RecPointsList (fhRecAmpDiff, 1, !expert, image);
   
   TH1F *fhMean = new TH1F("hMean","online - rec mean",1000, -5000, 5000);
-  Add2RecPointsList ( fhMean,2);
+  Add2RecPointsList ( fhMean,2, !expert, image);
  }
 
 //____________________________________________________________________________
 void AliT0QADataMakerRec::InitESDs()
 {
   //create ESDs histograms in ESDs subdir
-
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TH1F *fhESDMean = new TH1F("hESDmean"," ESD mean",100,2400,2500);
-  Add2ESDsList(fhESDMean, 0) ;
+  Add2ESDsList(fhESDMean, 0, !expert, image) ;
   TH1F * fhESDVertex = new TH1F("hESDvertex","ESD vertex",100,-50,50);
-  Add2ESDsList(fhESDVertex, 1) ;
+  Add2ESDsList(fhESDVertex, 1, !expert, image) ;
   
 
 }
index c5bff39..8e830aa 100644 (file)
@@ -110,26 +110,30 @@ void AliT0QADataMakerSim::InitHits()
 {
   // create Hits histograms in Hits subdir
   // create Hits histograms in Hits subdir
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+
   TString timename;
   
   TH2F *fhHitsTimeA = new TH2F("hHitsTimeA", "Hits Efficiency", 25, 0, 25, 100,12,15 );
-  Add2HitsList(fhHitsTimeA,0);
+  Add2HitsList(fhHitsTimeA,0, !expert, image);
   TH2F *fhHitsTimeC = new TH2F("hHitsTimeC", "Hits Efficiency", 25, 0, 25, 100,2,5 );
-  Add2HitsList(fhHitsTimeC,1);
+  Add2HitsList(fhHitsTimeC,1, !expert, image);
 }
 
 //____________________________________________________________________________ 
 void AliT0QADataMakerSim::InitDigits()
 {
   // create Digits histograms in Digits subdir
-
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
   
   TH2F * fhDigCFD = new TH2F("fhDigCFD", " CFD digits",25,-0.5,24.5,100,100,1000);
   Add2DigitsList( fhDigCFD,0);
   TH2F *fhDigLEDamp = new TH2F("fhDigLEDamp", " LED-CFD digits",25,-0.5,24.5,100,100,1000);
-  Add2DigitsList( fhDigLEDamp,1);
+  Add2DigitsList( fhDigLEDamp,1, !expert, image);
   TH2F * fhDigQTC = new TH2F("fhDigQTC", " QTC digits",25,-0.5,24.5,100,100,1000);
-  Add2DigitsList( fhDigQTC,2);
+  Add2DigitsList( fhDigQTC,2, !expert, image);
   
   
    
index cffb576..98ad4d4 100644 (file)
@@ -79,22 +79,24 @@ void AliTOFQADataMakerRec::InitRaws()
   // create Raws histograms in Raws subdir
   //
 
-  Bool_t expert = kFALSE;
-
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t saveCorr = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TH1F * h0 = new TH1F("hTOFRaws",    "Number of TOF Raws ",301, -1.02, 5.) ;   h0->Sumw2() ;
-  Add2RawsList(h0, 0, expert) ;
+  Add2RawsList(h0, 0, !expert, image, !saveCorr) ;
 
   TH1F * h1  = new TH1F("hTOFRawsTime", "Raws Time Spectrum in TOF (ns)", 2000, 0., 200) ; 
   h1->Sumw2() ;
-  Add2RawsList(h1, 1, expert) ;
+  Add2RawsList(h1, 1, !expert, image, !saveCorr) ;
 
   TH1F * h2  = new TH1F("hTOFRawsToT", "Raws ToT Spectrum in TOF (ns)", 500, 0., 50) ; 
   h2->Sumw2() ;
-  Add2RawsList(h2, 2, expert) ;
+  Add2RawsList(h2, 2, !expert, image, !saveCorr) ;
 
   TH2F * h3  = new TH2F("hTOFRawsClusMap","Raws vs TOF eta-phi",183, -0.5, 182.5,865,-0.5,864.5) ; 
   h3->Sumw2() ;
-  Add2RawsList(h3, 3, expert) ;
+  Add2RawsList(h3, 3, !expert, image, !saveCorr) ;
 
 }
 
@@ -105,29 +107,30 @@ void AliTOFQADataMakerRec::InitRecPoints()
   // create RecPoints histograms in RecPoints subdir
   //
 
-  Bool_t expert = kFALSE;
-
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TH1F * h0 = new TH1F("hTOFRecPoints",    "Number of TOF RecPoints ",301, -1.02, 5.) ;   h0->Sumw2() ;
-  Add2RecPointsList(h0, 0, expert) ;
+  Add2RecPointsList(h0, 0, !expert, image) ;
 
   TH1F * h1  = new TH1F("hTOFRecPointsTime", "RecPoints Time Spectrum in TOF (ns)", 2000, 0., 200) ; 
   h1->Sumw2() ;
-  Add2RecPointsList(h1, 1, expert) ;
+  Add2RecPointsList(h1, 1, !expert, image) ;
 
   TH1F * h2  = new TH1F("hTOFRecPointsRawTime", "RecPoints raw Time Spectrum in TOF (ns)", 2000, 0., 200) ; 
   h2->Sumw2() ;
-  Add2RecPointsList(h2, 2, expert) ;
+  Add2RecPointsList(h2, 2, !expert, image) ;
 
   TH1F * h3  = new TH1F("hTOFRecPointsToT", "RecPoints ToT Spectrum in TOF (ns)", 500, 0., 50) ; 
   h3->Sumw2() ;
-  Add2RecPointsList(h3, 3, expert) ;
+  Add2RecPointsList(h3, 3, !expert, image) ;
 
   TH2F * h4  = new TH2F("hTOFRecPointsClusMap","RecPoints vs TOF phi-eta",183, -0.5, 182.5,865,-0.5,864.5) ; 
   h4->Sumw2() ;
   h4->GetXaxis()->SetTitle("2*strip+padz (eta)");
   h4->GetYaxis()->SetTitle("48*sector+padx (phi)");
 
-  Add2RecPointsList(h4, 4, expert) ;
+  Add2RecPointsList(h4, 4, !expert, image) ;
 
 }
 
@@ -138,27 +141,27 @@ void AliTOFQADataMakerRec::InitESDs()
   //create ESDs histograms in ESDs subdir
   //
 
-  Bool_t expert = kFALSE;
-
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
   TH1F * h0 = new TH1F("hTOFESDs",    "Number of matched TOF tracks over ESDs",       250, -1., 4.) ;  
   h0->Sumw2() ; 
-  Add2ESDsList(h0, 0, expert) ;
+  Add2ESDsList(h0, 0, !expert, image) ;
 
   TH1F * h1  = new TH1F("hTOFESDsTime", "Time Spectrum in TOF (ns)", 2000, 0., 200) ; 
   h1->Sumw2() ;
-  Add2ESDsList(h1, 1, expert) ;
+  Add2ESDsList(h1, 1, !expert, image) ;
 
   TH1F * h2  = new TH1F("hTOFESDsRawTime", "raw Time Spectrum in TOF (ns)", 2000, 0., 200) ; 
   h2->Sumw2() ;
-  Add2ESDsList(h2, 2, expert) ;
+  Add2ESDsList(h2, 2, !expert, image) ;
 
   TH1F * h3  = new TH1F("hTOFESDsToT", "ToT Spectrum in TOF (ns)", 500, 0., 50) ; 
   h3->Sumw2() ;
-  Add2ESDsList(h3, 3, expert) ;
+  Add2ESDsList(h3, 3, !expert, image) ;
 
   TH1F * h4 = new TH1F("hTOFESDsPID",    "Fraction of matched TOF tracks with good PID flag (%)", 101, 0., 101.) ;  
   h4->Sumw2() ; 
-  Add2ESDsList(h4, 4, expert) ;
+  Add2ESDsList(h4, 4, !expert, image) ;
 }
 
 //____________________________________________________________________________
index 04b19cc..87b1897 100644 (file)
@@ -79,23 +79,24 @@ void AliTOFQADataMakerSim::InitHits()
   // create Hits histograms in Hits subdir
   //
 
-  Bool_t expert = kFALSE;
-
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TH1F * h0 = new TH1F("hTOFHits",    "Number of TOF Hits ",301, -1.02, 5.) ; 
   h0->Sumw2() ;
-  Add2HitsList(h0, 0, expert) ;
+  Add2HitsList(h0, 0, !expert, image) ;
 
   TH1F * h1  = new TH1F("hTOFHitsTime", "Hits Time Spectrum in TOF (ns)", 2000, 0., 200) ; 
   h1->Sumw2() ;
-  Add2HitsList(h1, 1, expert) ;
+  Add2HitsList(h1, 1, !expert, image) ;
 
   TH1F * h2  = new TH1F("hTOFHitsLength", "Length Spectrum in TOF (cm)", 500, 0., 500) ; 
   h2->Sumw2() ;
-  Add2HitsList(h2, 2, expert) ;
+  Add2HitsList(h2, 2, !expert, image) ;
 
   TH2F * h3  = new TH2F("hTOFHitsClusMap","Hits vs TOF eta-phi",183, -0.5, 182.5,865,-0.5,864.5) ; 
   h3->Sumw2() ;
-  Add2HitsList(h3, 3, expert) ;
+  Add2HitsList(h3, 3, !expert, image) ;
 }
 
 //____________________________________________________________________________ 
@@ -105,22 +106,23 @@ void AliTOFQADataMakerSim::InitDigits()
   // create Digits histograms in Digits subdir
   //
 
-  Bool_t expert = kFALSE;
-
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TH1F * h0 = new TH1F("hTOFDigits",    "Number of TOF Digits ",301, -1.02, 5.) ;   h0->Sumw2() ;
-  Add2DigitsList(h0, 0, expert) ;
+  Add2DigitsList(h0, 0, !expert, image) ;
 
   TH1F * h1  = new TH1F("hTOFDigitsTime", "Digits Time Spectrum in TOF (ns)", 2000, 0., 200) ; 
   h1->Sumw2() ;
-  Add2DigitsList(h1, 1, expert) ;
+  Add2DigitsList(h1, 1, !expert, image) ;
 
   TH1F * h2  = new TH1F("hTOFDigitsToT", "Digits ToT Spectrum in TOF (ns)", 500, 0., 50) ; 
   h2->Sumw2() ;
-  Add2DigitsList(h2, 2, expert) ;
+  Add2DigitsList(h2, 2, !expert, image) ;
 
   TH2F * h3  = new TH2F("hTOFDigitsClusMap","Digits vs TOF eta-phi",183, -0.5, 182.5,865,-0.5,864.5) ; 
   h3->Sumw2() ;
-  Add2DigitsList(h3, 3, expert) ;
+  Add2DigitsList(h3, 3, !expert, image) ;
 
 }
 
@@ -131,18 +133,19 @@ void AliTOFQADataMakerSim::InitSDigits()
   // create SDigits histograms in SDigits subdir
   //
 
-  Bool_t expert = kFALSE;
-
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TH1F * h0 = new TH1F("hTOFSDigits",    "Number of TOF SDigits ",301, -1.02, 5.) ;   h0->Sumw2() ;
-  Add2SDigitsList(h0, 0, expert) ;
+  Add2SDigitsList(h0, 0, !expert, image) ;
 
   TH1F * h1  = new TH1F("hTOFSDigitsTime", "SDigits Time Spectrum in TOF (ns)", 2000, 0., 200) ; 
   h1->Sumw2() ;
-  Add2SDigitsList(h1, 1, expert) ;
+  Add2SDigitsList(h1, 1, !expert, image) ;
 
   TH2F * h2  = new TH2F("hTOFSDigitsClusMap","SDigits vs TOF eta-phi",183, -0.5, 182.5,865,-0.5,864.5) ; 
   h2->Sumw2() ;
-  Add2SDigitsList(h2, 2, expert) ;
+  Add2SDigitsList(h2, 2, !expert, image) ;
 
 }
 
index 8298ea4..2bc3bd8 100644 (file)
@@ -235,23 +235,26 @@ void AliTPCQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArr
 void AliTPCQADataMakerRec::InitESDs()
 {
   //create ESDs histograms in ESDs subdir  
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TH1F * histESDclusters = 
     new TH1F("hESDclusters", "N TPC clusters per track; N clusters; Counts",
             160, 0, 160);
   histESDclusters->Sumw2();
-  Add2ESDsList(histESDclusters, KClusters);
+  Add2ESDsList(histESDclusters, KClusters, !expert, image);
 
   TH1F * histESDratio = 
     new TH1F("hESDratio", "Ratio: TPC clusters / findable; Ratio: cluster/findable; Counts",
             100, 0, 1);
   histESDratio->Sumw2();
-  Add2ESDsList(histESDratio, kRatio);
+  Add2ESDsList(histESDratio, kRatio, !expert, image);
   
   TH1F * histESDpt = 
     new TH1F("hESDpt", "P_{T} distribution; p_{T} [GeV/c]; Counts",
             50, 0, 5);
   histESDpt->Sumw2();
-  Add2ESDsList(histESDpt, kPt);
+  Add2ESDsList(histESDpt, kPt, !expert, image);
 }
 
 //____________________________________________________________________________ 
@@ -265,89 +268,96 @@ void AliTPCQADataMakerRec::InitRaws()
   // Laurent Aphecetche pointed out that the mapping was read from file
   // for each event, so now we read in the map here and set if for 
   // the raw data qa
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t saveCorr = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
     fTPCdataQA[specie] = new AliTPCdataQA(AliRecoParam::Convert(specie));
     LoadMaps(); // Load Altro maps
     fTPCdataQA[specie]->SetAltroMapping(fMapping); // set Altro mapping
     fTPCdataQA[specie]->SetRangeTime(100, 920); // set time bin interval 
-//    Add2RawsList(fTPCdataQA, kTPCdataQA); // This is used by the AMORE monitoring <------- THIS WILL FAIL (YS)
+//    Add2RawsList(fTPCdataQA, kTPCdataQ, !expert, image, !saveCorrA); // This is used by the AMORE monitoring <------- THIS WILL FAIL (YS)
   }
 
   TH1F * histRawsOccupancy = 
     new TH1F("hRawsOccupancy", "Occupancy (all pads); Occupancy; Counts",
             100, 0, 1);
   histRawsOccupancy->Sumw2();
-  Add2RawsList(histRawsOccupancy, kOccupancy);
+  Add2RawsList(histRawsOccupancy, kOccupancy, !expert, image, !saveCorr);
   
   TH1F * histRawsOccupancyVsSector = 
     new TH1F("hRawsOccupancyVsSector", "Occupancy vs sector; Sector; Occupancy",
             72, 0, 72);
   histRawsOccupancyVsSector->Sumw2();
-  Add2RawsList(histRawsOccupancyVsSector, kOccupancyVsSector);
+  Add2RawsList(histRawsOccupancyVsSector, kOccupancyVsSector, !expert, image, !saveCorr);
 
   TH1F * histRawsNClustersPerEventVsSector = 
     new TH1F("hRawsNClustersPerEventVsSector", "Nclusters per event vs sector; Sector; Nclusters per event",
             72, 0, 72);
   histRawsNClustersPerEventVsSector->Sumw2();
-  Add2RawsList(histRawsNClustersPerEventVsSector, kNClustersPerEventVsSector);
+  Add2RawsList(histRawsNClustersPerEventVsSector, kNClustersPerEventVsSector, !expert, image, !saveCorr);
   
   TH1F * histRawsQVsSector = 
     new TH1F("hRawsQVsSector", "<Q> vs sector (OROC med: 36-71, long: 72-107); Sector; <Q>",
             108, 0, 108);
   histRawsQVsSector->Sumw2();
-  Add2RawsList(histRawsQVsSector, kQVsSector);
+  Add2RawsList(histRawsQVsSector, kQVsSector, !expert, image, !saveCorr);
 
   TH1F * histRawsQmaxVsSector = 
     new TH1F("hRawsQmaxVsSector", "<Qmax> vs sector (OROC med: 36-71, long: 72-107); Sector; <Qmax>",
             108, 0, 108);
   histRawsQmaxVsSector->Sumw2();
-  Add2RawsList(histRawsQmaxVsSector, kQmaxVsSector);
+  Add2RawsList(histRawsQmaxVsSector, kQmaxVsSector, !expert, image, !saveCorr);
 }
 
 //____________________________________________________________________________ 
 void AliTPCQADataMakerRec::InitRecPoints()
 {
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TH1F * histRecPointsQmaxShort = 
     new TH1F("hRecPointsQmaxShort", "Qmax distrbution (short pads); Qmax; Counts",
             100, 0, 300);
   histRecPointsQmaxShort->Sumw2();
-  Add2RecPointsList(histRecPointsQmaxShort, kQmaxShort);
+  Add2RecPointsList(histRecPointsQmaxShort, kQmaxShort, !expert, image);
 
   TH1F * histRecPointsQmaxMedium = 
     new TH1F("hRecPointsQmaxMedium", "Qmax distrbution (medium pads); Qmax; Counts",
             100, 0, 300);
   histRecPointsQmaxMedium->Sumw2();
-  Add2RecPointsList(histRecPointsQmaxMedium, kQmaxMedium);
+  Add2RecPointsList(histRecPointsQmaxMedium, kQmaxMedium, !expert, image);
 
   TH1F * histRecPointsQmaxLong = 
     new TH1F("hRecPointsQmaxLong", "Qmax distrbution (long pads); Qmax; Counts",
             100, 0, 300);
   histRecPointsQmaxLong->Sumw2();
-  Add2RecPointsList(histRecPointsQmaxLong, kQmaxLong);
+  Add2RecPointsList(histRecPointsQmaxLong, kQmaxLong, !expert, image);
 
   TH1F * histRecPointsQShort = 
     new TH1F("hRecPointsQShort", "Q distrbution (short pads); Q; Counts",
             100, 0, 2000);
   histRecPointsQShort->Sumw2();
-  Add2RecPointsList(histRecPointsQShort, kQShort);
+  Add2RecPointsList(histRecPointsQShort, kQShort, !expert, image);
 
   TH1F * histRecPointsQMedium = 
     new TH1F("hRecPointsQMedium", "Q distrbution (medium pads); Q; Counts",
             100, 0, 2000);
   histRecPointsQMedium->Sumw2();
-  Add2RecPointsList(histRecPointsQMedium, kQMedium);
+  Add2RecPointsList(histRecPointsQMedium, kQMedium, !expert, image);
 
   TH1F * histRecPointsQLong = 
     new TH1F("hRecPointsQLong", "Q distrbution (long pads); Q; Counts",
             100, 0, 2000);
   histRecPointsQLong->Sumw2();
-  Add2RecPointsList(histRecPointsQLong, kQLong);
+  Add2RecPointsList(histRecPointsQLong, kQLong, !expert, image);
 
   TH1F * histRecPointsRow = 
     new TH1F("hRecPointsRow", "Clusters per row; Row; Counts",
             159, 0, 159);
   histRecPointsRow->Sumw2();
-  Add2RecPointsList(histRecPointsRow, kRow);
+  Add2RecPointsList(histRecPointsRow, kRow, !expert, image);
 }
 
 //____________________________________________________________________________
index b249a48..acded0b 100644 (file)
@@ -88,45 +88,49 @@ void AliTPCQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArr
 //____________________________________________________________________________ 
 void AliTPCQADataMakerSim::InitDigits()
 {
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
   TH1F * histDigitsADC = 
     new TH1F("hDigitsADC", "Digit ADC distribution; ADC; Counts",
             1000, 0, 1000);
   histDigitsADC->Sumw2();
-  Add2DigitsList(histDigitsADC, kDigitsADC);
+  Add2DigitsList(histDigitsADC, kDigitsADC, !expert, image);
 }
 
 //____________________________________________________________________________ 
 void AliTPCQADataMakerSim::InitHits()
 {
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
   TH1F * histHitsNhits = 
     new TH1F("hHitsNhits", "Interactions per primary track in the TPC volume; Number of primary interactions; Counts",
             100, 0, 10000);
   histHitsNhits->Sumw2();
-  Add2HitsList(histHitsNhits, kNhits);
+  Add2HitsList(histHitsNhits, kNhits, !expert, image);
 
   TH1F * histHitsElectrons = 
     new TH1F("hHitsElectrons", "Electrons per interaction (primaries); Electrons; Counts",
             300, 0, 300);
   histHitsElectrons->Sumw2();
-  Add2HitsList(histHitsElectrons, kElectrons);  
+  Add2HitsList(histHitsElectrons, kElectrons, !expert, image);  
 
   TH1F * histHitsRadius = 
     new TH1F("hHitsRadius", "Position of interaction (Primary tracks only); Radius; Counts",
             300, 0., 300.);  
   histHitsRadius->Sumw2();
-  Add2HitsList(histHitsRadius, kRadius);  
+  Add2HitsList(histHitsRadius, kRadius, !expert, image);  
 
   TH1F * histHitsPrimPerCm = 
     new TH1F("hHitsPrimPerCm", "Primaries per cm (Primary tracks only); Primaries; Counts",
             100, 0., 100.);  
   histHitsPrimPerCm->Sumw2();
-  Add2HitsList(histHitsPrimPerCm, kPrimPerCm);  
+  Add2HitsList(histHitsPrimPerCm, kPrimPerCm, !expert, image);  
 
   TH1F * histHitsElectronsPerCm = 
     new TH1F("hHitsElectronsPerCm", "Electrons per cm (Primary tracks only); Electrons; Counts",
             300, 0., 300.);  
   histHitsElectronsPerCm->Sumw2();
-  Add2HitsList(histHitsElectronsPerCm, kElectronsPerCm);  
+  Add2HitsList(histHitsElectronsPerCm, kElectronsPerCm, !expert, image);  
 }
 
 //____________________________________________________________________________
index d2caf5d..d95cfad 100644 (file)
@@ -237,7 +237,9 @@ void AliTRDQADataMakerRec::InitESDs()
   //
   // Create ESDs histograms in ESDs subdir
   //
-
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   const Int_t kNhist = 36+5+4;
 
   TH1 *hist[kNhist];
@@ -321,7 +323,7 @@ void AliTRDQADataMakerRec::InitESDs()
 
   for(Int_t i=0; i<kNhist; i++) {
     //hist[i]->Sumw2();
-    Add2ESDsList(hist[i], i);
+    Add2ESDsList(hist[i], i, !expert, image);
   }
 
 }
@@ -332,7 +334,9 @@ void AliTRDQADataMakerRec::InitRecPoints()
   //
   // Create Reconstructed Points histograms in RecPoints subdir
   //
-
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   const Int_t kNhist = 14 + 4 * 18 + 2;
   TH1 *hist[kNhist];
 
@@ -394,7 +398,7 @@ void AliTRDQADataMakerRec::InitRecPoints()
 
   for(Int_t i=0; i<kNhist; i++) {
     //hist[i]->Sumw2();
-    Add2RecPointsList(hist[i], i);
+    Add2RecPointsList(hist[i], i, !expert, image);
   }
 }
 
@@ -404,7 +408,10 @@ void AliTRDQADataMakerRec::InitRaws()
   //
   // create Raws histograms in Raws subdir
   //
-
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t saveCorr = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   const Int_t kSM = 18;
   //const Int_t kNCh = 540;
   const Int_t kNhist = 4+kSM;
@@ -425,7 +432,7 @@ void AliTRDQADataMakerRec::InitRaws()
   // register
   for(Int_t i=0; i<kNhist; i++) {
     //hist[i]->Sumw2();
-    Add2RawsList(hist[i], i);
+    Add2RawsList(hist[i], i, !expert, image, !saveCorr);
   }
 
 }
index 86dd97c..f3795ea 100644 (file)
@@ -108,7 +108,9 @@ void AliTRDQADataMakerSim::InitHits()
   //
   // Create Hits histograms in Hits subdir
   //
-
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   const Int_t kNhist = 4;
   TH1D *hist[kNhist];
 
@@ -120,7 +122,7 @@ void AliTRDQADataMakerSim::InitHits()
 
   for(Int_t i=0; i<kNhist; i++) {
     //hist[i]->Sumw2();
-    Add2HitsList(hist[i], i);
+    Add2HitsList(hist[i], i, !expert, image);
   }
 
 }
@@ -131,7 +133,9 @@ void AliTRDQADataMakerSim::InitDigits()
   //
   // Create Digits histograms in Digits subdir
   //
-
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   const Int_t kNhist = 3;
   TH1D *hist[kNhist];
 
@@ -141,7 +145,7 @@ void AliTRDQADataMakerSim::InitDigits()
 
   for(Int_t i=0; i<kNhist; i++) {
     hist[i]->Sumw2();
-    Add2DigitsList(hist[i], i);
+    Add2DigitsList(hist[i], i, !expert, image);
   }
 
 }
@@ -152,7 +156,9 @@ void AliTRDQADataMakerSim::InitSDigits()
   //
   // Create SDigits histograms in SDigits subdir
   //
-
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   const Int_t kNhist = 3;
   TH1D *hist[kNhist];
 
@@ -162,7 +168,7 @@ void AliTRDQADataMakerSim::InitSDigits()
 
   for(Int_t i=0; i<kNhist; i++) {
     hist[i]->Sumw2();
-    Add2SDigitsList(hist[i], i);
+    Add2SDigitsList(hist[i], i, !expert, image);
   }
 
 }
index e3d0cbc..adf2055 100644 (file)
@@ -160,7 +160,8 @@ void AliVZEROQADataMakerRec::InitESDs()
 {
   // Creates histograms to control ESDs
   
-  Bool_t expert   = kTRUE ; 
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
        
   TH2D * h2d;
   TH1I * h1i;
@@ -168,54 +169,54 @@ void AliVZEROQADataMakerRec::InitESDs()
                
   h1i = new TH1I("H1I_Cell_Multiplicity_V0A", "Cell Multiplicity in V0A", 35, 0, 35) ;  
   h1i->GetXaxis()->SetTitle("Multiplicity (Nb of Cell)");
-  Add2ESDsList(h1i, kCellMultiV0A, !expert)  ;  
+  Add2ESDsList(h1i, kCellMultiV0A, !expert, image)  ;  
                                                                                                         
   h1i = new TH1I("H1I_Cell_Multiplicity_V0C", "Cell Multiplicity in V0C", 35, 0, 35) ;  
   h1i->GetXaxis()->SetTitle("Multiplicity (Nb of Cell)");
-  Add2ESDsList(h1i, kCellMultiV0C, !expert)  ;  
+  Add2ESDsList(h1i, kCellMultiV0C, !expert, image)  ;  
    
   h1d = new TH1D("H1D_MIP_Multiplicity_V0A", "MIP Multiplicity in V0A", 1000, 0, 1000) ;  
   h1d->GetXaxis()->SetTitle("Multiplicity (Nb of MIP)");
-  Add2ESDsList(h1d, kMIPMultiV0A, !expert)  ;  
+  Add2ESDsList(h1d, kMIPMultiV0A, !expert, image)  ;  
   
   h1d = new TH1D("H1D_MIP_Multiplicity_V0C", "MIP Multiplicity in V0C", 1000, 0, 1000) ;  
   h1d->GetXaxis()->SetTitle("Multiplicity (Nb of MIP)");
-  Add2ESDsList(h1d, kMIPMultiV0C, !expert)  ;  
+  Add2ESDsList(h1d, kMIPMultiV0C, !expert, image)  ;  
 
   h2d = new TH2D("H2D_MIP_Multiplicity_Channel", "MIP Multiplicity per Channel",64, 0, 64, 100, 0, 100) ;  
   h2d->GetXaxis()->SetTitle("Channel");
   h2d->GetYaxis()->SetTitle("Multiplicity (Nb of MIP)");
-  Add2ESDsList(h2d, kMIPMultiChannel, !expert)  ;  
+  Add2ESDsList(h2d, kMIPMultiChannel, !expert, image)  ;  
   
   h1d = new TH1D("H1D_BBFlag_Counters", "BB Flag Counters",64, 0, 64) ;  
   h1d->GetXaxis()->SetTitle("Channel");
-  Add2ESDsList(h1d, kBBFlag, !expert)  ;  
+  Add2ESDsList(h1d, kBBFlag, !expert, image)  ;  
   
   h1d = new TH1D("H1D_BGFlag_Counters", "BG Flag Counters",64, 0, 64) ;  
   h1d->GetXaxis()->SetTitle("Channel");
-  Add2ESDsList(h1d, kBGFlag, !expert)  ;  
+  Add2ESDsList(h1d, kBGFlag, !expert, image)  ;  
   
   h2d = new TH2D("H2D_Charge_Channel", "ADC Charge per channel",64, 0, 64, 1024, 0, 1024) ;  
   h2d->GetXaxis()->SetTitle("Channel");
   h2d->GetYaxis()->SetTitle("Charge (ADC counts)");
-  Add2ESDsList(h2d, kChargeChannel, !expert)  ;  
+  Add2ESDsList(h2d, kChargeChannel, !expert, image)  ;  
   
   h2d = new TH2D("H2D_Time_Channel", "Time per channel",64, 0, 64, 820, 0, 410) ;  
   h2d->GetXaxis()->SetTitle("Channel");
   h2d->GetYaxis()->SetTitle("Time (ns)");
-  Add2ESDsList(h2d, kTimeChannel, !expert)  ;  
+  Add2ESDsList(h2d, kTimeChannel, !expert, image)  ;  
   
   h1d = new TH1D("H1D_V0A_Time", "Mean V0A Time",2048, 0., 409.6);
   h1d->GetXaxis()->SetTitle("Time (ns)");
-  Add2ESDsList(h1d,kESDV0ATime, !expert); 
+  Add2ESDsList(h1d,kESDV0ATime, !expert, image); 
   
   h1d = new TH1D("H1D_V0C_Time", "Mean V0C Time",2048, 0., 409.6);
   h1d->GetXaxis()->SetTitle("Time (ns)");
-  Add2ESDsList(h1d,kESDV0CTime, !expert); 
+  Add2ESDsList(h1d,kESDV0CTime, !expert, image); 
   
   h1d = new TH1D("H1D_Diff_Time", "Diff Time V0A - V0C",2*2048, -409.6, 409.6);
   h1d->GetXaxis()->SetTitle("Diff Time V0A - V0C (ns)");
-  Add2ESDsList(h1d,kESDDiffTime, !expert); 
+  Add2ESDsList(h1d,kESDDiffTime, !expert, image); 
        
 }
 
@@ -224,8 +225,9 @@ void AliVZEROQADataMakerRec::InitESDs()
  {
    // Creates RAW histograms in Raws subdir
    
-  Bool_t expert   = kTRUE ; 
-  Bool_t saveCorr = kTRUE ; 
+   const Bool_t expert   = kTRUE ; 
+   const Bool_t saveCorr = kTRUE ; 
+   const Bool_t image    = kTRUE ; 
 
   char name[50] , title[100];
   const Int_t kNintegrator  =    2;
@@ -260,27 +262,27 @@ void AliVZEROQADataMakerRec::InitESDs()
  
    // Creation of Cell Multiplicity Histograms
   h1i = new TH1I("H1I_Multiplicity_V0A", "Cell Multiplicity in V0A", 35, 0, 35) ;  
-  Add2RawsList(h1i,kMultiV0A, !expert, saveCorr);   iHisto++;
+  Add2RawsList(h1i,kMultiV0A, !expert, image, saveCorr);   iHisto++;
   h1i = new TH1I("H1I_Multiplicity_V0C", "Cell Multiplicity in V0C", 35, 0, 35) ;  
-  Add2RawsList(h1i,kMultiV0C, !expert, saveCorr);   iHisto++;
+  Add2RawsList(h1i,kMultiV0C, !expert, image, saveCorr);   iHisto++;
  
   // Creation of Total Charge Histograms
   h1d = new TH1D("H1D_Charge_V0A", "Total Charge in V0A", 2048, 0, 32768) ;  
-  Add2RawsList(h1d,kChargeV0A, !expert, saveCorr);   iHisto++;
+  Add2RawsList(h1d,kChargeV0A, !expert, image, saveCorr);   iHisto++;
   h1d = new TH1D("H1D_Charge_V0C", "Total Charge in V0C", 2048, 0, 32768) ;  
-  Add2RawsList(h1d,kChargeV0C, !expert, saveCorr);   iHisto++;
+  Add2RawsList(h1d,kChargeV0C, !expert, image, saveCorr);   iHisto++;
   h1d = new TH1D("H1D_Charge_V0", "Total Charge in V0", 2048, 0, 65536) ;  
-  Add2RawsList(h1d,kChargeV0, !expert, saveCorr);   iHisto++;
+  Add2RawsList(h1d,kChargeV0, !expert, image, saveCorr);   iHisto++;
   
   // Creation of MIP Histograms
   h1d = new TH1D("H1D_MIP_V0A", "Total MIP in V0A", 2*kNMIPBins,kMIPMin ,32*kMIPMax) ;  
-  Add2RawsList(h1d,kRawMIPV0A, !expert, saveCorr);   iHisto++;
+  Add2RawsList(h1d,kRawMIPV0A, !expert, image, saveCorr);   iHisto++;
   h1d = new TH1D("H1D_MIP_V0C", "Total MIP in V0C", 2*kNMIPBins,kMIPMin ,32*kMIPMax) ;  
-  Add2RawsList(h1d,kRawMIPV0C, !expert, saveCorr);   iHisto++;
+  Add2RawsList(h1d,kRawMIPV0C, !expert, image, saveCorr);   iHisto++;
   h1d = new TH1D("H1D_MIP_V0", "Total MIP in V0", 2*kNMIPBins,kMIPMin ,32*kMIPMax) ;  
-  Add2RawsList(h1d,kRawMIPV0, !expert, saveCorr);   iHisto++;
+  Add2RawsList(h1d,kRawMIPV0, !expert, image, saveCorr);   iHisto++;
   h2d = new TH2D("H2D_MIP_Channel", "Nb of MIP per channel", kNChannelBins, kChannelMin, kChannelMax,kNMIPBins,kMIPMin ,kMIPMax) ;  
-  Add2RawsList(h2d,kRawMIPChannel, expert, !saveCorr);   iHisto++;
+  Add2RawsList(h2d,kRawMIPChannel, expert, !image, !saveCorr);   iHisto++;
   
  
  for(Int_t iInt=0;iInt<kNintegrator;iInt++){
@@ -288,53 +290,53 @@ void AliVZEROQADataMakerRec::InitESDs()
     sprintf(name,"H2I_Pedestal_Int%d",iInt);
     sprintf(title,"Pedestal (Int%d)",iInt);
     h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax,kNPedestalBins,kPedestalMin ,kPedestalMax );
-    Add2RawsList(h2i,(iInt == 0 ? kPedestalInt0 : kPedestalInt1), expert, !saveCorr); iHisto++;
+    Add2RawsList(h2i,(iInt == 0 ? kPedestalInt0 : kPedestalInt1), expert, !image, !saveCorr); iHisto++;
        
     // Creation of temporary Pedestal histo used for the mean versus time histogram. This histogram will be reset at the end of each cycle
     sprintf(name,"H2I_Pedestal_CycleInt%d",iInt);
     sprintf(title,"One Cycle Pedestal (Int%d)",iInt);
     h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax,kNPedestalBins,kPedestalMin ,kPedestalMax );
-    Add2RawsList(h2i,(iInt == 0 ? kPedestalCycleInt0 : kPedestalCycleInt1), expert, !saveCorr); iHisto++;
+    Add2RawsList(h2i,(iInt == 0 ? kPedestalCycleInt0 : kPedestalCycleInt1), expert, !image, !saveCorr); iHisto++;
                
     // Creation of Pedestal versus time graph.
     sprintf(name,"H2D_Pedestal_Time_Int%d",iInt);
     sprintf(title,"Pedestal Versus Time (Int%d)",iInt);
     h2d = new TH2D(name, title,kNChannelBins, kChannelMin, kChannelMax,kTimeMax,kTimeMin ,kTimeMax );
-    Add2RawsList(h2d,(iInt == 0 ? kPedestalTimeInt0 : kPedestalTimeInt1), expert, !saveCorr); iHisto++;
+    Add2RawsList(h2d,(iInt == 0 ? kPedestalTimeInt0 : kPedestalTimeInt1), expert, !image, !saveCorr); iHisto++;
 
    // Creation of Charge EoI histograms 
     sprintf(name,"H2I_ChargeEoI_Int%d",iInt);
     sprintf(title,"Charge EoI (Int%d)",iInt);
     h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, kChargeMax);
-    Add2RawsList(h2i,(iInt == 0 ? kChargeEoIInt0 : kChargeEoIInt1), !expert, !saveCorr); iHisto++;
+    Add2RawsList(h2i,(iInt == 0 ? kChargeEoIInt0 : kChargeEoIInt1), !expert, image, !saveCorr); iHisto++;
 
    // Creation of temporary Charge EoI histograms used for the mean versus time histogram. This histogram will be reset at the end of each cycle
     sprintf(name,"H2I_ChargeEoI_CycleInt%d",iInt);
     sprintf(title,"One Cycle Charge EoI (Int%d)",iInt);
     h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, kChargeMax);
-    Add2RawsList(h2i,(iInt == 0 ? kChargeEoICycleInt0 : kChargeEoICycleInt1), expert, !saveCorr); iHisto++;
+    Add2RawsList(h2i,(iInt == 0 ? kChargeEoICycleInt0 : kChargeEoICycleInt1), expert, !image, !saveCorr); iHisto++;
                
     // Creation of Charge EoI versus time graphs
     sprintf(name,"H2D_ChargeEoI_Time_Int%d",iInt);
     sprintf(title,"Charge EoI Versus Time (Int%d)",iInt);
     h2d = new TH2D(name, title,kNChannelBins, kChannelMin, kChannelMax,kTimeMax,kTimeMin ,kTimeMax );
-    Add2RawsList(h2d,(iInt == 0 ? kChargeEoITimeInt0 : kChargeEoITimeInt1), expert, !saveCorr); iHisto++;
+    Add2RawsList(h2d,(iInt == 0 ? kChargeEoITimeInt0 : kChargeEoITimeInt1), expert, !image, !saveCorr); iHisto++;
     
     sprintf(name,"H2I_ChargeEoI_BB_Int%d",iInt);
     sprintf(title,"Charge EoI w/ BB Flag (Int%d)",iInt);
     h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, kChargeMax);
-    Add2RawsList(h2i,(iInt == 0 ? kChargeEoIBBInt0 : kChargeEoIBBInt1), expert, !saveCorr); iHisto++;
+    Add2RawsList(h2i,(iInt == 0 ? kChargeEoIBBInt0 : kChargeEoIBBInt1), expert, !image, !saveCorr); iHisto++;
     
     sprintf(name,"H2I_ChargeEoI_BG_Int%d",iInt);
     sprintf(title,"Charge EoI w/ BG Flag (Int%d)",iInt);
     h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, kChargeMax);
-    Add2RawsList(h2i,(iInt == 0 ?  kChargeEoIBGInt0: kChargeEoIBGInt1), expert, !saveCorr); iHisto++;
+    Add2RawsList(h2i,(iInt == 0 ?  kChargeEoIBGInt0: kChargeEoIBGInt1), expert, !image, !saveCorr); iHisto++;
 
     // Creation of Charge versus LHC Clock histograms 
     sprintf(name,"H2D_ChargeVsClock_Int%d",iInt);
     sprintf(title,"Charge Versus LHC-Clock (Int%d)",iInt);
     h2d = new TH2D(name, title,kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 );
-    Add2RawsList(h2d,(iInt == 0 ? kChargeVsClockInt0 : kChargeVsClockInt1 ), expert, !saveCorr); iHisto++;
+    Add2RawsList(h2d,(iInt == 0 ? kChargeVsClockInt0 : kChargeVsClockInt1 ), expert, !image, !saveCorr); iHisto++;
        
     // Creation of Minimum Bias Charge histograms 
     for(Int_t iBB=0;iBB<2;iBB++){
@@ -360,7 +362,7 @@ void AliVZEROQADataMakerRec::InitESDs()
                                        else idx = kChargeMBBB1BG1Int1;
                                }
                        }
-                       Add2RawsList(h2i,idx, expert, !saveCorr); iHisto++;
+                       Add2RawsList(h2i,idx, expert, !image, !saveCorr); iHisto++;
                }
     }
        
@@ -370,58 +372,58 @@ void AliVZEROQADataMakerRec::InitESDs()
        sprintf(name,"H2I_Width");
        sprintf(title,"HPTDC Width");
        h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax, kNTdcWidthBins, kTdcWidthMin, kTdcWidthMax);
-       Add2RawsList(h2i,kWidth, expert, !saveCorr); iHisto++;
+       Add2RawsList(h2i,kWidth, expert, !image, !saveCorr); iHisto++;
 
        sprintf(name,"H2I_Width_BB");
        sprintf(title,"HPTDC Width w/ BB Flag condition");
        h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax, kNTdcWidthBins, kTdcWidthMin, kTdcWidthMax);
-       Add2RawsList(h2i,kWidthBB, expert, !saveCorr); iHisto++;
+       Add2RawsList(h2i,kWidthBB, expert, !image, !saveCorr); iHisto++;
 
        sprintf(name,"H2I_Width_BG");
        sprintf(title,"HPTDC Width w/ BG Flag condition");
        h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax, kNTdcWidthBins, kTdcWidthMin, kTdcWidthMax);
-       Add2RawsList(h2i,kWidthBG, expert, !saveCorr); iHisto++;
+       Add2RawsList(h2i,kWidthBG, expert, !image, !saveCorr); iHisto++;
 
        sprintf(name,"H2I_HPTDCTime");
        sprintf(title,"HPTDC Time");
        h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax, kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
-       Add2RawsList(h2i,kHPTDCTime, !expert, !saveCorr); iHisto++;
+       Add2RawsList(h2i,kHPTDCTime, !expert, image, !saveCorr); iHisto++;
 
        sprintf(name,"H2I_HPTDCTime_BB");
        sprintf(title,"HPTDC Time w/ BB Flag condition");
        h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax, kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
-       Add2RawsList(h2i,kHPTDCTimeBB, expert, !saveCorr); iHisto++;
+       Add2RawsList(h2i,kHPTDCTimeBB, expert, !image, !saveCorr); iHisto++;
 
        sprintf(name,"H2I_HPTDCTime_BG");
        sprintf(title,"HPTDC Time w/ BG Flag condition");
        h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax, kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
-       Add2RawsList(h2i,kHPTDCTimeBG, expert, !saveCorr); iHisto++;
+       Add2RawsList(h2i,kHPTDCTimeBG, expert, !image, !saveCorr); iHisto++;
        
        sprintf(name,"H1D_V0A_Time");
        sprintf(title,"V0A Time");
        h1d = new TH1D(name, title,kNTdcTimeBins, kTdcTimeMin/10, kTdcTimeMax/10);
-       Add2RawsList(h1d,kV0ATime, !expert, saveCorr); iHisto++;
+       Add2RawsList(h1d,kV0ATime, !expert, !image, saveCorr); iHisto++;
        
        sprintf(name,"H1D_V0C_Time");
        sprintf(title,"V0C Time");
        h1d = new TH1D(name, title,kNTdcTimeBins, kTdcTimeMin/10, kTdcTimeMax/10);
-       Add2RawsList(h1d,kV0CTime, !expert, saveCorr); iHisto++;
+       Add2RawsList(h1d,kV0CTime, !expert, !image, saveCorr); iHisto++;
        
        sprintf(name,"H1D_Diff_Time");
        sprintf(title,"Diff V0A-V0C Time");
        h1d = new TH1D(name, title,2*kNTdcTimeBins, -kTdcTimeMax/10, kTdcTimeMax/10);
-       Add2RawsList(h1d,kDiffTime, !expert, saveCorr); iHisto++;
+       Add2RawsList(h1d,kDiffTime, !expert, !image, saveCorr); iHisto++;
        
        // Creation of Flag versus LHC Clock histograms 
        sprintf(name,"H2D_BBFlagVsClock");
        sprintf(title,"BB-Flags Versus LHC-Clock");
        h2d = new TH2D(name, title,kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 );
-       Add2RawsList(h2d,kBBFlagVsClock, expert, !saveCorr); iHisto++;
+       Add2RawsList(h2d,kBBFlagVsClock, expert, !image, !saveCorr); iHisto++;
        
        sprintf(name,"H2D_BGFlagVsClock");
        sprintf(title,"BG-Flags Versus LHC-Clock");
        h2d = new TH2D(name, title,kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 );
-       Add2RawsList(h2d,kBGFlagVsClock, expert, !saveCorr); iHisto++;
+       Add2RawsList(h2d,kBGFlagVsClock, expert, !image, !saveCorr); iHisto++;
         
        AliInfo(Form("%d Histograms has been added to the Raws List",iHisto));
  }
index d10d635..bfc0c23 100644 (file)
@@ -81,14 +81,16 @@ void AliVZEROQADataMakerSim::InitHits()
 {
  
   // create Hits histograms in Hits subdir
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
   
   TH1I * h0 = new TH1I("hHitMultiplicity", "Hit multiplicity distribution in VZERO", 300, 0, 299) ; 
   h0->Sumw2() ;
-  Add2HitsList(h0, 0) ;  
+  Add2HitsList(h0, 0, !expert, image) ;  
   
   TH1I * h1 = new TH1I("hHitCellNumber", "Hit cell distribution in VZERO", 80, 0, 79) ; 
   h1->Sumw2() ;
-  Add2HitsList(h1, 1) ;  
+  Add2HitsList(h1, 1, !expert, image) ;  
     
 }
 
@@ -96,7 +98,8 @@ void AliVZEROQADataMakerSim::InitHits()
 void AliVZEROQADataMakerSim::InitDigits()
 {
   // create Digits histograms in Digits subdir
-
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
   
   char TDCname[100];
   char ADCname[100];
@@ -107,7 +110,7 @@ void AliVZEROQADataMakerSim::InitDigits()
   // create Digits histograms in Digits subdir
   TH1I * h0 = new TH1I("hDigitMultiplicity", "Digits multiplicity distribution in VZERO", 100, 0, 99) ; 
   h0->Sumw2() ;
-  Add2DigitsList(h0, 0) ;
+  Add2DigitsList(h0, 0, !expert, image) ;
   
   for (Int_t i=0; i<64; i++)
     {
@@ -119,8 +122,8 @@ void AliVZEROQADataMakerSim::InitDigits()
        sprintf(texte,"Digit ADC in cell %d",i);
        fhDigADC[i]= new TH1I(ADCname,texte,1024,0.,1023.);
        
-       Add2DigitsList(fhDigTDC[i],i+1);
-       Add2DigitsList(fhDigADC[i],i+1+64);  
+       Add2DigitsList(fhDigTDC[i],i+1, !expert, image);
+       Add2DigitsList(fhDigADC[i],i+1+64, !expert, image);  
      }  
 }
 
index 8d6c577..48e5d31 100644 (file)
@@ -134,66 +134,69 @@ void AliZDCQADataMakerRec::InitESDs()
 {
   //Booking ESDs histograms
   //
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
   TH2F * hZNC  = new TH2F("hZNC", "Centroid in ZNC", 100, -5.,5.,100,-5.,5.);
   TH2F * hZNA  = new TH2F("hZNA", "Centroid in ZNA", 100, -5.,5.,100,-5.,5.);
-  Add2ESDsList(hZNC, 0);
-  Add2ESDsList(hZNA, 1);
+  Add2ESDsList(hZNC, 0, !expert, image);
+  Add2ESDsList(hZNA, 1, !expert, image);
   //
   // ------------------- HIGH GAIN CHAIN ---------------------------
   TH1F * hESDZNCTot = new TH1F("hESDZNCTot", "Energy in ZNC", 100, 0., 6000.);
   TH1F * hESDZNATot = new TH1F("hESDZNATot", "Energy in ZNA", 100, 0., 6000.);
   TH1F * hESDZPCTot = new TH1F("hESDZPCTot", "Energy in ZPC", 100, 0., 10000.);
   TH1F * hESDZPATot = new TH1F("hESDZPATot", "Energy in ZPA", 100, 0., 10000.);
-  Add2ESDsList(hESDZNCTot, 2);
-  Add2ESDsList(hESDZNATot, 3);
-  Add2ESDsList(hESDZPCTot, 4);
-  Add2ESDsList(hESDZPATot, 5);
+  Add2ESDsList(hESDZNCTot, 2, !expert, image);
+  Add2ESDsList(hESDZNATot, 3, !expert, image);
+  Add2ESDsList(hESDZPCTot, 4, !expert, image);
+  Add2ESDsList(hESDZPATot, 5, !expert, image);
   //
   TH1F * hESDSumQZNC = new TH1F("hESDSumQZNC", "Sum of 4 ZNC energy",100, 0., 4000.);
   TH1F * hESDSumQZNA = new TH1F("hESDSumQZNA", "Sum of 4 ZNA energy",100, 0., 4000.);
   TH1F * hESDSumQZPC = new TH1F("hESDSumQZPC", "Sum of 4 ZPC energy",100, 0., 4000.);
   TH1F * hESDSumQZPA = new TH1F("hESDSumQZPA", "Sum of 4 ZPA energy",100, 0., 4000.);
-  Add2ESDsList(hESDSumQZNC, 6, kTRUE);
-  Add2ESDsList(hESDSumQZNA, 7, kTRUE);
-  Add2ESDsList(hESDSumQZPC, 8, kTRUE);
-  Add2ESDsList(hESDSumQZPA, 9, kTRUE);
+  Add2ESDsList(hESDSumQZNC, 6, expert, !image);
+  Add2ESDsList(hESDSumQZNA, 7, expert, !image);
+  Add2ESDsList(hESDSumQZPC, 8, expert, !image);
+  Add2ESDsList(hESDSumQZPA, 9, expert, !image);
   //
   TH1F * hESDPMCZNC = new TH1F("hESDPMCZNC", "Energy in common ZNC PMT",100, 0., 4000.);
   TH1F * hESDPMCZNA = new TH1F("hESDPMCZNA", "Energy in common ZNA PMT",100, 0., 4000.);
   TH1F * hESDPMCZPC = new TH1F("hESDPMCZPC", "Energy in common ZPC PMT",100, 0., 4000.);
   TH1F * hESDPMCZPA = new TH1F("hESDPMCZPA", "Energy in common ZPA PMT",100, 0., 4000.);
-  Add2ESDsList(hESDPMCZNC, 10, kTRUE);
-  Add2ESDsList(hESDPMCZNA, 11, kTRUE);
-  Add2ESDsList(hESDPMCZPC, 12, kTRUE);
-  Add2ESDsList(hESDPMCZPA, 13, kTRUE);
+  Add2ESDsList(hESDPMCZNC, 10, expert, !image);
+  Add2ESDsList(hESDPMCZNA, 11, expert, !image);
+  Add2ESDsList(hESDPMCZPC, 12, expert, !image);
+  Add2ESDsList(hESDPMCZPA, 13, expert, !image);
   // 
 /*  // ------------------- LOW GAIN CHAIN ---------------------------
   TH1F * hESDZNCTotlg = new TH1F("hESDZNCTotlg", "ESD lg signal in ZNC", 100, 0., 6000.);
   TH1F * hESDZNATotlg = new TH1F("hESDZNATotlg", "ESD lg signal in ZNA", 100, 0., 6000.);
   TH1F * hESDZPCTotlg = new TH1F("hESDZPCTotlg", "ESD lg signal in ZPC", 100, 0., 10000.);
   TH1F * hESDZPATotlg = new TH1F("hESDZPATotlg", "ESD lg signal in ZPA", 100, 0., 10000.);
-  Add2ESDsList(hESDZNCTotlg, 14);
-  Add2ESDsList(hESDZNATotlg, 15);
-  Add2ESDsList(hESDZPCTotlg, 16);
-  Add2ESDsList(hESDZPATotlg, 17);
+  Add2ESDsList(hESDZNCTotlg, !expert, image);
+  Add2ESDsList(hESDZNATotlg, !expert, image);
+  Add2ESDsList(hESDZPCTotlg, !expert, image);
+  Add2ESDsList(hESDZPATotlg, !expert, image);
   //
   TH1F * hESDSumQZNClg = new TH1F("hESDSumQZNClg", "Sum of 4 lg ZNC sectors",100, 0., 4000.);
   TH1F * hESDSumQZNAlg = new TH1F("hESDSumQZNAlg", "Sum of 4 lg ZNA sectors",100, 0., 4000.);
   TH1F * hESDSumQZPClg = new TH1F("hESDSumQZPClg", "Sum of 4 lg ZPC sectors",100, 0., 4000.);
   TH1F * hESDSumQZPAlg = new TH1F("hESDSumQZPAlg", "Sum of 4 lg ZPA sectors",100, 0., 4000.);
-  Add2ESDsList(hESDSumQZNClg, 18, kTRUE);
-  Add2ESDsList(hESDSumQZNAlg, 19, kTRUE);
-  Add2ESDsList(hESDSumQZPClg, 20, kTRUE);
-  Add2ESDsList(hESDSumQZPAlg, 21, kTRUE);
+  Add2ESDsList(hESDSumQZNClg, 18, expert, !image);
+  Add2ESDsList(hESDSumQZNAlg, 19, expert, !image);
+  Add2ESDsList(hESDSumQZPClg, 20, expert, !image);
+  Add2ESDsList(hESDSumQZPAlg, 21, expert, !image);
   //
   TH1F * hESDPMCZNClg = new TH1F("hESDPMCZNClg", "Signal in common ZNC lg PMT",100, 0., 4000.);
   TH1F * hESDPMCZNAlg = new TH1F("hESDPMCZNAlg", "Signal in common ZNA lg PMT",100, 0., 4000.);
   TH1F * hESDPMCZPClg = new TH1F("hESDPMCZPClg", "Signal in common ZPC lg PMT",100, 0., 4000.);
   TH1F * hESDPMCZPAlg = new TH1F("hESDPMCZPAlg", "Signal in common ZPA lg PMT",100, 0., 4000.);
-  Add2ESDsList(hESDPMCZNClg, 22, kTRUE);
-  Add2ESDsList(hESDPMCZNAlg, 23, kTRUE);
-  Add2ESDsList(hESDPMCZPClg, 24, kTRUE);
-  Add2ESDsList(hESDPMCZPAlg, 25, kTRUE);*/
+  Add2ESDsList(hESDPMCZNClg, 22, expert, !image);
+  Add2ESDsList(hESDPMCZNAlg, 23, expert, !image);
+  Add2ESDsList(hESDPMCZPClg, 24, expert, !image);
+  Add2ESDsList(hESDPMCZPAlg, 25, expert, !image);*/
 }
   
 //____________________________________________________________________________
index 604b1da..ee95a40 100644 (file)
@@ -17,7 +17,7 @@
 #include <Riostream.h>\r
 // --- ROOT system ---\r
 #include <TClonesArray.h>\r
-#include <TFile.h> \r
+#include <TFile.h>     \r
 #include <TH1F.h> \r
 #include <TH2F.h>\r
 #include <TBranch.h>\r
@@ -66,15 +66,18 @@ void AliZDCQADataMakerSim::InitHits()
 {\r
   // create Hits histograms in Hits subdir\r
   //\r
+  const Bool_t expert   = kTRUE ; \r
+  const Bool_t image    = kTRUE ; \r
+  \r
   TH2F * hZNCh  = new TH2F("hZNCh", "Hits centroid in ZNC", 100, -5.,5.,100,-5.,5.);\r
   TH2F * hZNAh  = new TH2F("hZNAh", "Hits centroid in ZNA", 100, -5.,5.,100,-5.,5.);\r
   // NB -> For the moment no check is performesd on ZP centroids\r
 //  TH2F * hZPCh  = new TH2F("hZPCh", "Hits centroid in ZPC", 100,-12.,12.,100,-12.,12.); \r
 //  TH2F * hZPAh  = new TH2F("hZPAh", "Hits centroid in ZPA", 100,-12.,12.,100,-12.,12.); \r
-  Add2HitsList(hZNCh, 0);\r
-  Add2HitsList(hZNAh, 1);\r
-//  Add2HitsList(hZPCh, 2);\r
-//  Add2HitsList(hZPAh, 3);\r
+  Add2HitsList(hZNCh, 0, !expert, image);\r
+  Add2HitsList(hZNAh, 1, !expert, image);\r
+//  Add2HitsList(hZPCh, 2, !expert, image);\r
+//  Add2HitsList(hZPAh, 3, !expert, image);\r
 }\r
 \r
 \r
@@ -83,61 +86,64 @@ void AliZDCQADataMakerSim::InitDigits()
 {\r
   // create Digits histograms in Digits subdir\r
   //\r
+  const Bool_t expert   = kTRUE ; \r
+  const Bool_t image    = kTRUE ; \r
+  \r
   // ------------------- HIGH GAIN CHAIN ---------------------------\r
   TH1F * hDigZNCTot = new TH1F("hDigZNCTot", "Signal in ZNC", 100, 0., 6000.);\r
   TH1F * hDigZNATot = new TH1F("hDigZNATot", "Signal in ZNA", 100, 0., 6000.);\r
   TH1F * hDigZPCTot = new TH1F("hDigZPCTot", "Signal in ZPC", 100, 0., 6000.);\r
   TH1F * hDigZPATot = new TH1F("hDigZPATot", "Signal in ZPA", 100, 0., 6000.);\r
-  Add2DigitsList(hDigZNCTot, 0);\r
-  Add2DigitsList(hDigZNATot, 1);\r
-  Add2DigitsList(hDigZPCTot, 2);\r
-  Add2DigitsList(hDigZPATot, 3);\r
+  Add2DigitsList(hDigZNCTot, 0, !expert, image);\r
+  Add2DigitsList(hDigZNATot, 1, !expert, image);\r
+  Add2DigitsList(hDigZPCTot, 2, !expert, image);\r
+  Add2DigitsList(hDigZPATot, 3, !expert, image);\r
   //\r
   TH1F * hDigSumQZNC = new TH1F("hDigSumQZNC", "Signal in 4 ZNC PMQ",100, 0., 4000.);\r
   TH1F * hDigSumQZNA = new TH1F("hDigSumQZNA", "Signal in 4 ZNA PMQ",100, 0., 4000.);\r
   TH1F * hDigSumQZPC = new TH1F("hDigSumQZPC", "Signal in 4 ZPC PMQ",100, 0., 4000.);\r
   TH1F * hDigSumQZPA = new TH1F("hDigSumQZPA", "Signal in 4 ZPA PMQ",100, 0., 4000.);\r
-  Add2DigitsList(hDigSumQZNC, 4, kTRUE);\r
-  Add2DigitsList(hDigSumQZNA, 5, kTRUE);\r
-  Add2DigitsList(hDigSumQZPC, 6, kTRUE);\r
-  Add2DigitsList(hDigSumQZPA, 7, kTRUE);\r
+  Add2DigitsList(hDigSumQZNC, 4, expert, !image);\r
+  Add2DigitsList(hDigSumQZNA, 5, expert, !image);\r
+  Add2DigitsList(hDigSumQZPC, 6, expert, !image);\r
+  Add2DigitsList(hDigSumQZPA, 7, expert, !image);\r
   //\r
   TH1F * hDigPMCZNC = new TH1F("hDigPMCZNC", "Signal in ZNC PMC",100, 0., 4000.);\r
   TH1F * hDigPMCZNA = new TH1F("hDigPMCZNA", "Signal in ZNA PMC",100, 0., 4000.);\r
   TH1F * hDigPMCZPC = new TH1F("hDigPMCZPC", "Signal in ZPC PMC",100, 0., 4000.);\r
   TH1F * hDigPMCZPA = new TH1F("hDigPMCZPA", "Signal in ZPA PMC",100, 0., 4000.);\r
-  Add2DigitsList(hDigPMCZNC, 8, kTRUE);\r
-  Add2DigitsList(hDigPMCZNA, 9, kTRUE);\r
-  Add2DigitsList(hDigPMCZPC, 10, kTRUE);\r
-  Add2DigitsList(hDigPMCZPA, 11, kTRUE);\r
+  Add2DigitsList(hDigPMCZNC, 8, expert, !image);\r
+  Add2DigitsList(hDigPMCZNA, 9, expert, !image);\r
+  Add2DigitsList(hDigPMCZPC, 10, expert, !image);\r
+  Add2DigitsList(hDigPMCZPA, 11, expert, !image);\r
   // \r
   // ------------------- LOW GAIN CHAIN ---------------------------\r
 /*  TH1F * hDigZNCTotlg = new TH1F("hDigZNCTotlg", "Digit lg signal in ZNC", 100, 0., 6000.);\r
   TH1F * hDigZNATotlg = new TH1F("hDigZNATotlg", "Digit lg signal in ZNA", 100, 0., 6000.);\r
   TH1F * hDigZPCTotlg = new TH1F("hDigZPCTotlg", "Digit lg signal in ZPC", 100, 0., 6000.);\r
   TH1F * hDigZPATotlg = new TH1F("hDigZPATotlg", "Digit lg signal in ZPA", 100, 0., 6000.);\r
-  Add2DigitsList(hDigZNCTotlg, 12);\r
-  Add2DigitsList(hDigZNATotlg, 13);\r
-  Add2DigitsList(hDigZPCTotlg, 14);\r
-  Add2DigitsList(hDigZPATotlg, 15);\r
+  Add2DigitsList(hDigZNCTotlg, 12, !expert, image);\r
+  Add2DigitsList(hDigZNATotlg, 13, !expert, image);\r
+  Add2DigitsList(hDigZPCTotlg, 14, !expert, image);\r
+  Add2DigitsList(hDigZPATotlg, 15, !expert, image);\r
   //\r
   TH1F * hDigSumQZNClg = new TH1F("hDigSumQZNClg", "Signal in 4 ZNC PMQlg",100, 0., 4000.);\r
   TH1F * hDigSumQZNAlg = new TH1F("hDigSumQZNAlg", "Signal in 4 ZNA PMQlg",100, 0., 4000.);\r
   TH1F * hDigSumQZPClg = new TH1F("hDigSumQZPClg", "Signal in 4 ZPC PMQlg",100, 0., 4000.);\r
   TH1F * hDigSumQZPAlg = new TH1F("hDigSumQZPAlg", "Signal in 4 ZPA PMQlg",100, 0., 4000.);\r
-  Add2DigitsList(hDigSumQZNClg, 16, kTRUE);\r
-  Add2DigitsList(hDigSumQZNAlg, 17, kTRUE);\r
-  Add2DigitsList(hDigSumQZPClg, 18, kTRUE);\r
-  Add2DigitsList(hDigSumQZPAlg, 19, kTRUE);\r
+  Add2DigitsList(hDigSumQZNClg, 16, expert, !image);\r
+  Add2DigitsList(hDigSumQZNAlg, 17, expert, !image);\r
+  Add2DigitsList(hDigSumQZPClg, 18, expert, !image);\r
+  Add2DigitsList(hDigSumQZPAlg, 19, expert, !image);\r
   //\r
   TH1F * hDigPMCZNClg = new TH1F("hDigPMCZNClg", "Signal in ZNC PMClg",100, 0., 4000.);\r
   TH1F * hDigPMCZNAlg = new TH1F("hDigPMCZNAlg", "Signal in ZNA PMClg",100, 0., 4000.);\r
   TH1F * hDigPMCZPClg = new TH1F("hDigPMCZPClg", "Signal in ZPC PMClg",100, 0., 4000.);\r
   TH1F * hDigPMCZPAlg = new TH1F("hDigPMCZPAlg", "Signal in ZPA PMClg",100, 0., 4000.);\r
-  Add2DigitsList(hDigPMCZNClg, 20, kTRUE);\r
-  Add2DigitsList(hDigPMCZNAlg, 21, kTRUE);\r
-  Add2DigitsList(hDigPMCZPClg, 22, kTRUE);\r
-  Add2DigitsList(hDigPMCZPAlg, 23, kTRUE);\r
+  Add2DigitsList(hDigPMCZNClg, 20, expert, !image);\r
+  Add2DigitsList(hDigPMCZNAlg, 21, expert, !image);\r
+  Add2DigitsList(hDigPMCZPClg, 22, expert, !image);\r
+  Add2DigitsList(hDigPMCZPAlg, 23, expert, !image);\r
 */\r
 }\r
 \r