{
// 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);
}
//____________________________________________________________________________
{
//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)
{
// 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);
}
//____________________________________________________________________________
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) ;
}
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);
}
// 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) ;
*/
}
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) ;
}
//____________________________________________________________________________
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);
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++) {
hADCCounts->SetXTitle("ADC counts");
hADCCounts->SetYTitle("");
Int_t index2 = GetHalfringIndex(det, ring, board/16,0);
- Add2RawsList(hADCCounts, index2);
+ Add2RawsList(hADCCounts, index2, !expert, image, !saveCorr);
}
}
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);
}
//_____________________________________________________________________
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);
}
}
}
// 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];
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)
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);
}
//____________________________________________________________________________
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();
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++;
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++;
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;
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++;
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++;
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;
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++;
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++;
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++;
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++;
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++;
}
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++;
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
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
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
{ \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
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 ");
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];
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++) {
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++;
}
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++;
}
= 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));
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];
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);
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);
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);
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);
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);
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);
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);
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);
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);
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++;
}
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++) {
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++;
}
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));
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
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];
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];
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++;
}
= 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));
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
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];
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++;
}
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
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];
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));
//____________________________________________________________________________
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) {
";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++) {
";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++) {
";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;
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;
}
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;
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
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}",
fHistSSDOccupancyLayer6->GetXaxis()->SetBinLabel(iBin,fLabel);
}
fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLayer6,
- fGenRawsOffset+fSSDRawsOffset, kTRUE);
+ fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
//occupancy per module - threshold @ 3%
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}",
fHistSSDOccupancyThresholdLayer6->GetXaxis()->SetBinLabel(iBin,fLabel);
}
fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyThresholdLayer6,
- fGenRawsOffset+fSSDRawsOffset, kTRUE);
+ fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
//Average occupancy per module
fHistSSDAverageOccupancyLayer6->GetXaxis()->SetBinLabel(iBin,fLabel);
}
fAliITSQADataMakerRec->Add2RawsList(fHistSSDAverageOccupancyLayer6,
- fGenRawsOffset+fSSDRawsOffset);
+ fGenRawsOffset+fSSDRawsOffset, !expert, image, !saveCorr);
fSSDRawsOffset += 1;
//Output of the DA
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",
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",
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",
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
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;
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",
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}",
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}",
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}",
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}",
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));
//____________________________________________________________________________
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
";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));
//____________________________________________________________________________
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
";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));
//____________________________________________________________________________
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
";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));
AliCodeTimerAuto("");
- Bool_t forExpert(kTRUE);
+ const Bool_t expert = kTRUE ;
+ const Bool_t saveCorr = kTRUE ;
+ const Bool_t image = kTRUE ;
if ( ! AliCDBManager::Instance()->GetDefaultStorage() )
{
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,
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;
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);
}
}
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++){
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());
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);
{
/// 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;
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);
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();
// 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;
}
/// 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,
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,
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;
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;
}
{
///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;
}
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;
}
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);
}
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);
}
{
//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
}
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) ;
*/
}
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) ;
}
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) ;
}
//____________________________________________________________________________
{
// 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
}
// 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);
{
//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) ;
*/
}
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);
+
}
//____________________________________________________________________________
}
//____________________________________________________________________________
-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
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) ;
return NULL ;
}
}
+
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 ;
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 ; }
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 ;
//
// --- ROOT system ---
+#include <TCanvas.h>
#include <TFile.h>
#include <TTree.h>
#include <TNtupleD.h>
}
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)
{
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) ;
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) ;
//
// --- ROOT system ---
+#include <TCanvas.h>
#include <TFile.h>
#include <TTree.h>
#include <TClonesArray.h>
}
fOutput->Save() ;
}
- ResetCycle() ;
+ MakeImage(task) ;
}
//____________________________________________________________________________
}
}
+//____________________________________________________________________________
+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)
{
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) ;
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) ;
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
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 ;
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() :
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 ; }
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
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];
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++)
{
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);
}
//____________________________________________________________________________
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) ;
}
{
// 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);
// 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) ;
}
// 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) ;
}
//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) ;
}
//____________________________________________________________________________
// 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) ;
}
//____________________________________________________________________________
// 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) ;
}
// 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) ;
}
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);
}
//____________________________________________________________________________
// 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);
}
//____________________________________________________________________________
//____________________________________________________________________________
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);
}
//____________________________________________________________________________
//
// 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];
for(Int_t i=0; i<kNhist; i++) {
//hist[i]->Sumw2();
- Add2ESDsList(hist[i], i);
+ Add2ESDsList(hist[i], i, !expert, image);
}
}
//
// 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];
for(Int_t i=0; i<kNhist; i++) {
//hist[i]->Sumw2();
- Add2RecPointsList(hist[i], i);
+ Add2RecPointsList(hist[i], i, !expert, image);
}
}
//
// 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;
// register
for(Int_t i=0; i<kNhist; i++) {
//hist[i]->Sumw2();
- Add2RawsList(hist[i], i);
+ Add2RawsList(hist[i], i, !expert, image, !saveCorr);
}
}
//
// Create Hits histograms in Hits subdir
//
-
+ const Bool_t expert = kTRUE ;
+ const Bool_t image = kTRUE ;
+
const Int_t kNhist = 4;
TH1D *hist[kNhist];
for(Int_t i=0; i<kNhist; i++) {
//hist[i]->Sumw2();
- Add2HitsList(hist[i], i);
+ Add2HitsList(hist[i], i, !expert, image);
}
}
//
// Create Digits histograms in Digits subdir
//
-
+ const Bool_t expert = kTRUE ;
+ const Bool_t image = kTRUE ;
+
const Int_t kNhist = 3;
TH1D *hist[kNhist];
for(Int_t i=0; i<kNhist; i++) {
hist[i]->Sumw2();
- Add2DigitsList(hist[i], i);
+ Add2DigitsList(hist[i], i, !expert, image);
}
}
//
// Create SDigits histograms in SDigits subdir
//
-
+ const Bool_t expert = kTRUE ;
+ const Bool_t image = kTRUE ;
+
const Int_t kNhist = 3;
TH1D *hist[kNhist];
for(Int_t i=0; i<kNhist; i++) {
hist[i]->Sumw2();
- Add2SDigitsList(hist[i], i);
+ Add2SDigitsList(hist[i], i, !expert, image);
}
}
{
// Creates histograms to control ESDs
- Bool_t expert = kTRUE ;
+ const Bool_t expert = kTRUE ;
+ const Bool_t image = kTRUE ;
TH2D * h2d;
TH1I * h1i;
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);
}
{
// 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;
// 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++){
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++){
else idx = kChargeMBBB1BG1Int1;
}
}
- Add2RawsList(h2i,idx, expert, !saveCorr); iHisto++;
+ Add2RawsList(h2i,idx, expert, !image, !saveCorr); iHisto++;
}
}
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));
}
{
// 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) ;
}
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];
// 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++)
{
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);
}
}
{
//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);*/
}
//____________________________________________________________________________
#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
{\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
{\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
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff