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
+ fhACORDEBitPattern[0] = new TH1D("ACORDERawDataSM","ACORDE-SingleMuon;Bit Pattern;Counts",60,1,60);//AcordeSingleMuon BitPattern
+ fhACORDEBitPattern[1] = new TH1D("ACORDERawDataMM","ACORDE-MultiMuon;Bit Pattern;Counts",60,1,60);//AcordeMultiMuon BitPattern
+ fhACORDEBitPattern[2] = new TH1D("ACORDERawDataSMM","ACORDE-SingleMuonMultiplicity;Multiplicity;Counts",60,1,60);//AcordeSingleMuon Multiplicity
+ fhACORDEBitPattern[3] = new TH1D("ACORDERawDataMMM","ACORDE-MultiMuonMultiplicity;Multiplicity;Counts",60,1,60);//AcordeMultiMuon Multiplicity
for(Int_t i=0;i<4;i++)
Add2RawsList(fhACORDEBitPattern[i],i,!expert, image, !saveCorr);
}
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);
+ fhDigitsModule = new TH1F(modulename.Data(),"hDigitsModuleSingle;# of modules;Counts",60,0,60);
Add2DigitsList(fhDigitsModule,0,!expert,image);
-
+
}
//____________________________________________________________________________
// create cluster histograms in RecPoint subdir
// Not needed for ACORDE by now !!!
}
+
//____________________________________________________________________________
void AliACORDEQADataMakerRec::InitESDs()
{
TString name;
name = "hESDsSingle";
- fhESDsSingle = new TH1F(name.Data(),"hESDsSingle",60,0,60);
+ fhESDsSingle = new TH1F(name.Data(),"hESDsSingle;??;??",60,0,60);
Add2ESDsList(fhESDsSingle,0,!expert,image);
name = "hESDsMulti";
- fhESDsMulti = new TH1F(name.Data(),"hESDsMulti",60,0,60);
+ fhESDsMulti = new TH1F(name.Data(),"hESDsMulti;??;??",60,0,60);
Add2ESDsList(fhESDsMulti,1,!expert,image);
}
//____________________________________________________________________________
const Bool_t image = kTRUE ;
TH1F * fHitsACORDE;
- fHitsACORDE = new TH1F("hACORDEBitPattern","Distribution of fired modules",60,0,60);
+ fHitsACORDE = new TH1F("hACORDEBitPattern","Distribution of fired modules;# of modules;Counts",60,0,60);
Add2HitsList(fHitsACORDE,0,!expert,image);
}
//____________________________________________________________________________
TH1F * fhDigitsModule;
TString modulename;
modulename = "hDigitsModule";
- fhDigitsModule = new TH1F(modulename.Data(),"hDigitsModuleSingle",60,0,60);
+ fhDigitsModule = new TH1F(modulename.Data(),"hDigitsModuleSingle;# of modules;Counts",60,0,60);
Add2DigitsList(fhDigitsModule,0,!expert,image);
}
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F * h1 = new TH1F("hESDCaloClusterE", "ESDs CaloCluster energy in EMCAL", 200, 0., 20.) ;
+ TH1F * h1 = new TH1F("hESDCaloClusterE", "ESDs CaloCluster energy in EMCAL;Energy [MeV];Counts", 200, 0., 20.) ;
h1->Sumw2() ;
Add2ESDsList(h1, kESDCaloClusE, !expert, image) ;
- TH1I * h2 = new TH1I("hESDCaloClusterM", "ESDs CaloCluster multiplicity in EMCAL", 100, 0, 100) ;
+ TH1I * h2 = new TH1I("hESDCaloClusterM", "ESDs CaloCluster multiplicity in EMCAL;# of Clusters;Entries", 100, 0, 100) ;
h2->Sumw2() ;
Add2ESDsList(h2, kESDCaloClusM, !expert, image) ;
- TH1F * h3 = new TH1F("hESDCaloCellA", "ESDs CaloCell amplitude in EMCAL", 500, 0., 250.) ;
+ TH1F * h3 = new TH1F("hESDCaloCellA", "ESDs CaloCell amplitude in EMCAL;Energy [MeV];Counts", 500, 0., 250.) ;
h3->Sumw2() ;
Add2ESDsList(h3, kESDCaloCellA, !expert, image) ;
- TH1I * h4 = new TH1I("hESDCaloCellM", "ESDs CaloCell multiplicity in EMCAL", 200, 0, 1000) ;
+ TH1I * h4 = new TH1I("hESDCaloCellM", "ESDs CaloCell multiplicity in EMCAL;# of Clusters;Entries", 200, 0, 1000) ;
h4->Sumw2() ;
Add2ESDsList(h4, kESDCaloCellM, !expert, image) ;
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1I * h0 = new TH1I("hEmcalDigits", "Digits amplitude distribution in EMCAL", 500, 0, 500) ;
+ TH1I * h0 = new TH1I("hEmcalDigits", "Digits amplitude distribution in EMCAL;Amplitude [ADC counts];Counts", 500, 0, 500) ;
h0->Sumw2() ;
Add2DigitsList(h0, 0, !expert, image) ;
- TH1I * h1 = new TH1I("hEmcalDigitsMul", "Digits multiplicity distribution in EMCAL", 200, 0, 2000) ;
+ TH1I * h1 = new TH1I("hEmcalDigitsMul", "Digits multiplicity distribution in EMCAL;# of Digits;Entries", 200, 0, 2000) ;
h1->Sumw2() ;
Add2DigitsList(h1, 1, !expert, image) ;
}
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F* h0 = new TH1F("hEMCALRpE","EMCAL RecPoint energies",200, 0.,20.); //GeV
+ TH1F* h0 = new TH1F("hEMCALRpE","EMCAL RecPoint energies;Energy [MeV];Counts",200, 0.,20.); //GeV
h0->Sumw2();
Add2RecPointsList(h0,kRecPE, !expert, image);
- TH1I* h1 = new TH1I("hEMCALRpM","EMCAL RecPoint multiplicities",100,0,100);
+ TH1I* h1 = new TH1I("hEMCALRpM","EMCAL RecPoint multiplicities;# of Clusters;Entries",100,0,100);
h1->Sumw2();
Add2RecPointsList(h1,kRecPM, !expert, image);
- TH1I* h2 = new TH1I("hEMCALRpDigM","EMCAL RecPoint Digit Multiplicities",20,0,20);
+ TH1I* h2 = new TH1I("hEMCALRpDigM","EMCAL RecPoint Digit Multiplicities;# of Digits;Entries",20,0,20);
h2->Sumw2();
Add2RecPointsList(h2,kRecPDigM, !expert, image);
int nTot = fSuperModules * nTowersPerSM; // max number of towers in all SuperModules
// counter info: number of channels per event (bins are SM index)
- TProfile * h0 = new TProfile("hLowEmcalSupermodules", "Low Gain EMC: # of towers vs SuperMod",
+ TProfile * h0 = new TProfile("hLowEmcalSupermodules", "Low Gain EMC: # of towers vs SuperMod;SM Id;# of towers",
fSuperModules, -0.5, fSuperModules-0.5) ;
Add2RawsList(h0, kNsmodLG, !expert, image, !saveCorr) ;
- TProfile * h1 = new TProfile("hHighEmcalSupermodules", "High Gain EMC: # of towers vs SuperMod",
+ TProfile * h1 = new TProfile("hHighEmcalSupermodules", "High Gain EMC: # of towers vs SuperMod;SM Id;# of towers",
fSuperModules, -0.5, fSuperModules-0.5) ;
Add2RawsList(h1, kNsmodHG, !expert, image, !saveCorr) ;
// where did max sample occur? (bins are towers)
- TProfile * h2 = new TProfile("hLowEmcalRawtime", "Low Gain EMC: Time at Max vs towerId",
+ TProfile * h2 = new TProfile("hLowEmcalRawtime", "Low Gain EMC: Time at Max vs towerId;Tower Id;Time [ns]",
nTot, -0.5, nTot-0.5) ;
Add2RawsList(h2, kTimeLG, !expert, image, !saveCorr) ;
- TProfile * h3 = new TProfile("hHighEmcalRawtime", "High Gain EMC: Time at Max vs towerId",
+ TProfile * h3 = new TProfile("hHighEmcalRawtime", "High Gain EMC: Time at Max vs towerId;Tower Id;Time [ns]",
nTot, -0.5, nTot-0.5) ;
Add2RawsList(h3, kTimeHG, !expert, image, !saveCorr) ;
// how much above pedestal was the max sample? (bins are towers)
- TProfile * h4 = new TProfile("hLowEmcalRawMaxMinusMin", "Low Gain EMC: Max - Min vs towerId",
+ TProfile * h4 = new TProfile("hLowEmcalRawMaxMinusMin", "Low Gain EMC: Max - Min vs towerId;Tower Id;??",
nTot, -0.5, nTot-0.5) ;
Add2RawsList(h4, kSigLG, !expert, image, !saveCorr) ;
- TProfile * h5 = new TProfile("hHighEmcalRawMaxMinusMin", "High Gain EMC: Max - Min vs towerId",
+ TProfile * h5 = new TProfile("hHighEmcalRawMaxMinusMin", "High Gain EMC: Max - Min vs towerId;Tower Id;??",
nTot, -0.5, nTot-0.5) ;
Add2RawsList(h5, kSigHG, !expert, image, !saveCorr) ;
// total counter: channels per event
- TH1I * h6 = new TH1I("hLowNtot", "Low Gain EMC: Total Number of found towers", 200, 0, nTot) ;
+ TH1I * h6 = new TH1I("hLowNtot", "Low Gain EMC: Total Number of found towers;# of Towers;Counts", 200, 0, nTot) ;
h6->Sumw2() ;
Add2RawsList(h6, kNtotLG, !expert, image, !saveCorr) ;
- TH1I * h7 = new TH1I("hHighNtot", "High Gain EMC: Total Number of found towers", 200,0, nTot) ;
+ TH1I * h7 = new TH1I("hHighNtot", "High Gain EMC: Total Number of found towers;# of Towers;Counts", 200,0, nTot) ;
h7->Sumw2() ;
Add2RawsList(h7, kNtotHG, !expert, image, !saveCorr) ;
// pedestal (bins are towers)
- TProfile * h8 = new TProfile("hLowEmcalRawPed", "Low Gain EMC: Pedestal vs towerId",
+ TProfile * h8 = new TProfile("hLowEmcalRawPed", "Low Gain EMC: Pedestal vs towerId;Tower Id;Pedestal [ADC counts]",
nTot, -0.5, nTot-0.5) ;
Add2RawsList(h8, kPedLG, !expert, image, !saveCorr) ;
- TProfile * h9 = new TProfile("hHighEmcalRawPed", "High Gain EMC: Pedestal vs towerId",
+ TProfile * h9 = new TProfile("hHighEmcalRawPed", "High Gain EMC: Pedestal vs towerId;Tower Id;Pedestal [ADC counts]",
nTot, -0.5, nTot-0.5) ;
Add2RawsList(h9, kPedHG, !expert, image, !saveCorr) ;
// pedestal rms (standard dev = sqrt of variance estimator for pedestal) (bins are towers)
- TProfile * h10 = new TProfile("hLowEmcalRawPedRMS", "Low Gain EMC: Pedestal RMS vs towerId",
+ TProfile * h10 = new TProfile("hLowEmcalRawPedRMS", "Low Gain EMC: Pedestal RMS vs towerId;Tower Id;Width [ADC counts]",
nTot, -0.5, nTot-0.5) ;
Add2RawsList(h10, kPedRMSLG, !expert, image, !saveCorr) ;
- TProfile * h11 = new TProfile("hHighEmcalRawPedRMS", "High Gain EMC: Pedestal RMS vs towerId",
+ TProfile * h11 = new TProfile("hHighEmcalRawPedRMS", "High Gain EMC: Pedestal RMS vs towerId;Tower Id;Width [ADC counts]",
nTot, -0.5, nTot-0.5) ;
Add2RawsList(h11, kPedRMSHG, !expert, image, !saveCorr) ;
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F * h0 = new TH1F("hEmcalHits", "Hits energy distribution in EMCAL", 200, 0., 2.) ; //GeV
+ TH1F * h0 = new TH1F("hEmcalHits", "Hits energy distribution in EMCAL;Energy [MeV];Counts", 200, 0., 2.) ; //GeV
h0->Sumw2() ;
Add2HitsList(h0, 0, !expert, image) ;
- TH1I * h1 = new TH1I("hEmcalHitsMul", "Hits multiplicity distribution in EMCAL", 1000, 0, 10000) ;
+ TH1I * h1 = new TH1I("hEmcalHitsMul", "Hits multiplicity distribution in EMCAL;# of Hits;Entries", 1000, 0, 10000) ;
h1->Sumw2() ;
Add2HitsList(h1, 1, !expert, image) ;
}
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1I * h0 = new TH1I("hEmcalDigits", "Digits amplitude distribution in EMCAL", 500, 0, 500) ;
+ TH1I * h0 = new TH1I("hEmcalDigits", "Digits amplitude distribution in EMCAL;Amplitude [ADC counts];Counts", 500, 0, 500) ;
h0->Sumw2() ;
Add2DigitsList(h0, 0, !expert, image) ;
- TH1I * h1 = new TH1I("hEmcalDigitsMul", "Digits multiplicity distribution in EMCAL", 200, 0, 2000) ;
+ TH1I * h1 = new TH1I("hEmcalDigitsMul", "Digits multiplicity distribution in EMCAL;# of Digits;Entries", 200, 0, 2000) ;
h1->Sumw2() ;
Add2DigitsList(h1, 1, !expert, image) ;
}
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F * h0 = new TH1F("hEmcalSDigits", "SDigits energy distribution in EMCAL", 200, 0., 20.) ;
+ TH1F * h0 = new TH1F("hEmcalSDigits", "SDigits energy distribution in EMCAL;Energy [MeV];Counts", 200, 0., 20.) ;
h0->Sumw2() ;
Add2SDigitsList(h0, 0, !expert, image) ;
- TH1I * h1 = new TH1I("hEmcalSDigitsMul", "SDigits multiplicity distribution in EMCAL", 500, 0, 5000) ;
+ TH1I * h1 = new TH1I("hEmcalSDigitsMul", "SDigits multiplicity distribution in EMCAL;# of SDigits;Entries", 500, 0, 5000) ;
h1->Sumw2() ;
Add2SDigitsList(h1, 1, !expert, image) ;
}
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");
+ TH1I* hADCCounts = new TH1I("hADCCounts","Dist of ADC counts;ADC counts;Counts",1024,0,1024);
Add2DigitsList(hADCCounts, 0, !expert, image);
}
TH1F* hEnergyOfRecpoints = new TH1F("hEnergyOfRecpoints",
"Energy Distribution",100,0,3);
hEnergyOfRecpoints->SetXTitle("Edep/Emip");
- hEnergyOfRecpoints->SetYTitle("");
+ hEnergyOfRecpoints->SetYTitle("Counts");
Add2RecPointsList(hEnergyOfRecpoints,0, !expert, image);
}
for(Int_t iring = firstring;iring<=1;iring++) {
Char_t ring = (iring == 1 ? 'I' : 'O');
hADCCounts = new TH1I(Form("hADCCounts_FMD%d%c",
- det, ring), "ADC counts",
+ det, ring), "ADC counts;Amplitude [ADC counts];Counts",
1024,0,1023);
Int_t index1 = GetHalfringIndex(det, ring, 0,1);
hADCCounts = new TH1I(Form("hADCCounts_FMD%d%c_board%d",
- det, ring, board), "ADC counts",
+ det, ring, board), "ADC counts;Amplitude [ADC counts];Counts",
1024,0,1023);
hADCCounts->SetXTitle("ADC counts");
hADCCounts->SetYTitle("");
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1I* hADCCounts = new TH1I("hADCCounts","Dist of ADC counts",1024,0,1024);
+ TH1I* hADCCounts = new TH1I("hADCCounts","Dist of ADC counts;ADC counts;Entries",1024,0,1024);
hADCCounts->SetXTitle("ADC counts");
Add2SDigitsList(hADCCounts, 0, !expert, image);
}
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F* hEnergyOfHits = new TH1F("hEnergyOfHits","Energy distribution",100,0,3);
+ TH1F* hEnergyOfHits = new TH1F("hEnergyOfHits","Energy distribution;Energy [MeV];Counts",100,0,3);
hEnergyOfHits->SetXTitle("Edep");
hEnergyOfHits->SetYTitle("Counts");
Add2HitsList(hEnergyOfHits, 0, !expert, image);
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1I* hADCCounts = new TH1I("hADCCounts","Dist of ADC counts",1024,0,1024);
+ TH1I* hADCCounts = new TH1I("hADCCounts","Dist of ADC counts; ADC counts;Entries",1024,0,1024);
hADCCounts->SetXTitle("ADC counts");
Add2DigitsList(hADCCounts, 0, !expert, image);
}
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 *hDigChEvt = new TH1F("hDigChEvt","Chamber occupancy per event;Occupancy [%];Counts",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);
+ hDigQ[iCh*6+iPc] = new TH1F(Form("QCh%iPc%i ",iCh,iPc),Form("Charge of digits (ADC) in Chamber %i and PC %i;Charge [ADC counts];Counts",iCh,iPc),4100,0,4100);
}
}
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TProfile *hCluMult = new TProfile("CluMult" ,"Cluster multiplicity per chamber" , 16, -1 , 7 , 0, 500);
+ TProfile *hCluMult = new TProfile("CluMult" ,"Cluster multiplicity per chamber;Chamber Id;# of clusters" , 16, -1 , 7 , 0, 500);
Add2RecPointsList(hCluMult , 0,expert, !image);
- TH2F *hCluFlg = new TH2F("CluFlg" ,"Cluster flag " , 56 ,-1.5, 12.5, 70, -0.5, 6.5);
+ TH2F *hCluFlg = new TH2F("CluFlg" ,"Cluster flag;??;??" , 56 ,-1.5, 12.5, 70, -0.5, 6.5);
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 );
+ hCluSizeMip[iCh] = new TH1F(Form("CluSizeMipCh%i",iCh),Form("Cluster size MIP (cluster Q > 100 ADC) in Chamber %i;Size [MIP];Counts",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 );
+ hCluSizePho[iCh] = new TH1F(Form("CluSizePho%i",iCh ),Form("Cluster size Phots(cluster Q < 100 ADC) in Chamber %i;Size [MIP];Counts",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);
+ hCluQSectZoom[iCh*6+iSect] = new TH1F(Form("QClusCh%iSect%iZoom",iCh,iSect) ,Form("Zoom on Cluster charge (ADC) in Chamber %i and sector %i;Charge [ADC counts];Counts",iCh,iSect),100,0,100);
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);
+ hCluQSect[iCh*6+iSect] = new TH1F(Form("QClusCh%iSect%i",iCh,iSect) ,Form("Cluster charge (ADC) in Chamber %i and sector %i;Charge [ADC counts];Counts",iCh,iSect),250,0,5000);
Add2RecPointsList(hCluQSect[iCh*6+iSect],2+14+42+iCh*6+iSect, !expert, image);
}
}
TH1I *hPadQ[42]; //AMORE monitoring
for(Int_t iddl =0; iddl<AliHMPIDRawStream::kNDDL; iddl++) {
- hSumErr[iddl] = new TH1F(Form("hSumErrDDL%i",iddl), Form("Error summary for DDL %i",iddl), 2*kNerr,0,2*kNerr);
+ hSumErr[iddl] = new TH1F(Form("hSumErrDDL%i",iddl), Form("Error summary for DDL %i;??;??",iddl), 2*kNerr,0,2*kNerr);
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)));
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F *hHitQdc=new TH1F("HitQdc","HMPID Hit Qdc all chamber;QDC",500,0,4000);
+ TH1F *hHitQdc=new TH1F("HitQdc","HMPID Hit Qdc all chamber;QDC;Entries",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);
+ hHitMap[iCh]=new TH2F(Form("HMPID HitMap%i",iCh),Form("Ch%i;x_{Hit};y_{Hit};Entries",iCh),162,-1,161,146,-1,145);
Add2HitsList(hHitMap[iCh],iCh+1,expert,!image);
}
}
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 *hDigChEvt = new TH1F("hDigChEvt","Chamber occupancy per event;Occupanc [%];Entries",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);
+ hDigMap[iCh] = new TH2F(Form("MapCh%i",iCh),Form("Digit Map in Chamber %i;Digit #;Entries",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);
+ hDigQ[iCh*6+iPc] = new TH1F(Form("QCh%iPc%i ",iCh,iPc),Form("Charge of digits (ADC) in Chamber %i and PC %i;Charge;Entries",iCh,iPc),4100,0,4100);
}
}
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F *hSDigits = new TH1F("hHmpidSDigits", "SDigits Q distribution in HMPID", 500, 0., 5000.) ;
+ TH1F *hSDigits = new TH1F("hHmpidSDigits", "SDigits Q distribution in HMPID;QDC;Entries", 500, 0., 5000.) ;
Add2SDigitsList(hSDigits,0, !expert, image);
}
h0->GetYaxis()->SetTitle("# DIGITS");\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
+ TH1F* h1=new TH1F("SDD Anode Distribution","SDD 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, !expert, image);\r
fSDDhDTask ++;\r
- TH1F* h2=new TH1F("SDD Tbin Distribution","DIGITS Tbin Distribution",256,-0.5,255.5); //htbocc\r
+ TH1F* h2=new TH1F("SDD Tbin Distribution","SDD 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, !expert, image);\r
fSDDhDTask ++;\r
- TH1F* h3=new TH1F("SDD ADC Counts Distribution","DIGITS ADC Counts Distribution",200,0.,1024.); //hsig\r
+ TH1F* h3=new TH1F("SDD ADC Counts Distribution","SDD 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, !expert, image);\r
h0->GetYaxis()->SetTitle("# SDIGITS");\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
+ TH1F* h1=new TH1F("SDD Anode Distribution","SDIGITS SDD 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, !expert, image);\r
fSDDhSTask ++;\r
- TH1F* h2=new TH1F("SDD Tbin Distribution","SDIGITS Tbin Distribution",256,-0.5,255.5); //htbocc\r
+ TH1F* h2=new TH1F("SDD Tbin Distribution","SDIGITS SDD Tbin Distribution",256,-0.5,255.5); //htbocc\r
h2->GetXaxis()->SetTitle("Tbin Number");\r
h2->GetYaxis()->SetTitle("# SDIGITS");\r
fAliITSQADataMakerSim->Add2SDigitsList(h2,2+fGenOffsetS);\r
fSDDhSTask ++;\r
- TH1F* h3=new TH1F("SDD ADC Counts Distribution","SDIGITS ADC Counts Distribution",200,0.,1024.); //hsig\r
+ TH1F* h3=new TH1F("SDD ADC Counts Distribution","SDIGITS SDD ADC Counts Distribution",200,0.,1024.); //hsig\r
h3->GetXaxis()->SetTitle("ADC Value");\r
h3->GetYaxis()->SetTitle("# SDIGITS");\r
fAliITSQADataMakerSim->Add2SDigitsList(h3,3+fGenOffsetS, !expert, image);\r
h0->GetYaxis()->SetTitle("# HITS");\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
+ TH1F *h1=new TH1F("SDD HIT lenght along local Y Coord","SDD 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, !expert, image);\r
fSPDhHTask++;
}
- TH1F *hhitlenght = new TH1F("SPDLenght_SPD","Hit lenght along y_{loc} coord",210,0.,210.);
+ TH1F *hhitlenght = new TH1F("SPDLenght_SPD","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, !expert, image);
fSPDhHTask++;
- TH1F *hEdepos = new TH1F("SPDEnergyDeposit_SPD","Deposited energy distribution (y_{loc}>180 #mum)",150,0.,300.);
+ TH1F *hEdepos = new TH1F("SPDEnergyDeposit_SPD","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, !expert, image);
}
AliDebug(AliQAv1::GetQADebugLevel(), Form("Number of histograms (SPD+SDD): %d\n",fGenRawsOffset));
TString gTitle = 0;
+ TString gName = 0;
//book online-offline QA histos
TH1D *fHistSSDEventType = new TH1D("fHistSSDEventType",
- ";Event type;Events",
+ "SSD Event Type;Event type;Events",
31,-1,30);
fAliITSQADataMakerRec->Add2RawsList(fHistSSDEventType,
fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
TH1D *fHistSSDDataSize = new TH1D("fHistSSDDataSize",
- ";(SSD data size) [KB];Events",
+ "SSD Data Size;(SSD data size) [KB];Events",
1000,0,500);
fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSize,
fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
TH1D *fHistSSDDataSizePercentage = new TH1D("fHistSSDDataSizePercentage",
- ";SSD data size [%];Events",
+ "SSD Data Size Percentage;SSD data size [%];Events",
1000,0,100);
fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizePercentage,
fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
TH1D *fHistSSDDDLId = new TH1D("fHistSSDDDLId",
- ";DDL id;Events",20,510.5,530.5);
+ "SSD DDL Id;DDL id;Events",20,510.5,530.5);
fAliITSQADataMakerRec->Add2RawsList(fHistSSDDDLId,
fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
TH1D *fHistSSDDataSizePerDDL = new TH1D("fHistSSDDataSizePerDDL",
- ";DDL id;<SSD data size> [KB]",
+ "SSD Data Size Per DDL;DDL id;<SSD data size> [KB]",
20,510.5,530.5);
fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizePerDDL,
fGenRawsOffset+fSSDRawsOffset, !expert, image, !saveCorr);
fSSDRawsOffset += 1;
TH1D *fHistSSDDataSizeDDL[fgkNumOfDDLs];
for(Int_t i = 1; i < fgkNumOfDDLs+1; i++) {
- gTitle = "fHistSSDDataSizeDDL"; gTitle += i+511;
- fHistSSDDataSizeDDL[i-1] = new TH1D(gTitle.Data(),
- ";(SSD data size) [KB];Events",
- 1000,0,50);
+ gName = Form("fHistSSDDataSizeDDL%d", i+511) ;
+ gTitle = Form("SSD Data Size DDL %d", i+511) ;
+ fHistSSDDataSizeDDL[i-1] = new TH1D(gName.Data(),
+ Form("%s;(SSD data size) [KB];Events", gTitle.Data()),
+ 1000,0,50);
+ fHistSSDDataSizeDDL[i-1] = new TH1D(gName.Data(),
+ Form("%s;(SSD data size) [KB];Events", gTitle.Data()),
+ 1000,0,50);
fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizeDDL[i-1],
fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
}
- TH1D *fHistSSDLDCId = new TH1D("fHistSSDLDCId",";LDC id;Events",10,0.5,10.5);
+ TH1D *fHistSSDLDCId = new TH1D("fHistSSDLDCId","SSD LDC Id;LDC id;Events",10,0.5,10.5);
fAliITSQADataMakerRec->Add2RawsList(fHistSSDLDCId,
fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
TH1D *fHistSSDDataSizePerLDC = new TH1D("fHistSSDDataSizePerLDC",
- ";LDC id;<SSD data size> [KB]",
+ "SSD Data Size Per LDC;LDC id;<SSD data size> [KB]",
20,0.5,20.5);
fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizePerLDC,
fGenRawsOffset+fSSDRawsOffset, !expert, image, !saveCorr);
fSSDRawsOffset += 1;
TH1D *fHistSSDDataSizeLDC[fgkNumOfLDCs];
for(Int_t i = 1; i < fgkNumOfLDCs+1; i++) {
- gTitle = "fHistSSDDataSizeLDC";
+ gName = "fHistSSDDataSizeLDC";
+ if(i == 1) gName += "082";
+ if(i == 2) gName += "086";
+ if(i == 3) gName += "085";
+
+ gTitle = "SSD Data Size LDC ";
if(i == 1) gTitle += "082";
if(i == 2) gTitle += "086";
if(i == 3) gTitle += "085";
- fHistSSDDataSizeLDC[i-1] = new TH1D(gTitle.Data(),
- ";SSD data size [KB];Events",
+ fHistSSDDataSizeLDC[i-1] = new TH1D(gName.Data(),
+ Form("%s;SSD data size [KB];Events", gTitle.Data()),
1000,0,100);
fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizeLDC[i-1],
fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
TH1D *fHistSSDOccupancyModule[fgkSSDMODULES];
for(Int_t i = 500; i < fgkSSDMODULES + 500; i++) {
AliITSgeomTGeo::GetModuleId(i,gLayer,gLadder,gModule);
- gTitle = "fHistSSD_Occupancy_Layer";
+ gName = "fHistSSD_Occupancy_Layer";
+ gTitle = "SSD Occupancy Layer";
if(gLayer == 5) {
- gTitle += gLayer; gTitle += "_Ladder";
- gTitle += 499+gLadder;
+ gName += gLayer; gName += "_Ladder";
+ gName += 499+gLadder;
+ gTitle += gLayer; gTitle += "_Ladder";
+ gTitle += 499+gLadder;
}
if(gLayer == 6) {
- gTitle += gLayer; gTitle += "_Ladder";
- gTitle += 599+gLadder;
+ gName += gLayer; gName += "_Ladder";
+ gName += 599+gLadder;
+ gTitle += gLayer; gTitle += "_Ladder";
+ gTitle += 599+gLadder;
}
+ gName += "_Module"; gName += gModule;
gTitle += "_Module"; gTitle += gModule;
- fHistSSDOccupancyModule[i-500] = new TH1D(gTitle.Data(),gTitle.Data(),
- 2*fgkNumberOfPSideStrips,0,2*fgkNumberOfPSideStrips);
+
+ fHistSSDOccupancyModule[i-500] = new TH1D(gName.Data(),Form("%s;N_{strip};Occupancy [%]", gTitle.Data()),
+ 2*fgkNumberOfPSideStrips,0,2*fgkNumberOfPSideStrips);
fHistSSDOccupancyModule[i-500]->GetXaxis()->SetTitleColor(1);
- fHistSSDOccupancyModule[i-500]->GetXaxis()->SetTitle("N_{strip}");
- fHistSSDOccupancyModule[i-500]->GetYaxis()->SetTitle("Occupancy [%]");
fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyModule[i-500],
fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
TH1D *fHistSSDOccupancyLadder[2*(fgkSSDLADDERSLAYER5 + fgkSSDLADDERSLAYER6)];
for(Int_t iLayer = 5; iLayer < 7; iLayer++) {
for(Int_t iLadder = 1; iLadder < AliITSgeomTGeo::GetNLadders(iLayer) + 1; iLadder++) {
- //P-side occupancy plots
- gTitle = "fHistSSD_Occupancy_Layer";
- if(iLayer == 5) {
- gTitle += iLayer; gTitle += "_Ladder";
- gTitle += 499+iLadder;
- }
- if(iLayer == 6) {
- gTitle += iLayer; gTitle += "_Ladder";
- gTitle += 599+iLadder;
- }
- gTitle += "_PSide";
- fHistSSDOccupancyLadder[occupancyCounter] = new TH1D(gTitle.Data(),
- gTitle.Data(),
- AliITSgeomTGeo::GetNDetectors(iLayer),
- 0.5,AliITSgeomTGeo::GetNDetectors(iLayer)+0.5);
- fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitleColor(1);
- fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitle("Module number");
- fHistSSDOccupancyLadder[occupancyCounter]->GetYaxis()->SetTitle("Occupancy [%]");
- fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLadder[occupancyCounter],
- fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
- occupancyCounter += 1; fSSDRawsOffset += 1;
- //N-side occupancy plots
- gTitle = "fHistSSD_Occupancy_Layer";
- if(iLayer == 5) {
- gTitle += iLayer; gTitle += "_Ladder";
- gTitle += 499+iLadder;
- }
- if(iLayer == 6) {
- gTitle += iLayer; gTitle += "_Ladder";
- gTitle += 599+iLadder;
- }
- gTitle += "_NSide";
- fHistSSDOccupancyLadder[occupancyCounter] = new TH1D(gTitle.Data(),
- gTitle.Data(),
- AliITSgeomTGeo::GetNDetectors(iLayer),
- 0.5,AliITSgeomTGeo::GetNDetectors(iLayer)+0.5);
- fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitleColor(1);
- fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitle("Module number");
- fHistSSDOccupancyLadder[occupancyCounter]->GetYaxis()->SetTitle("Occupancy [%]");
- fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLadder[occupancyCounter],
- fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
- occupancyCounter += 1; fSSDRawsOffset += 1;
+ //P-side occupancy plots
+ gName = "fHistSSD_Occupancy_Layer";
+ gTitle = "SSD Occupancy Layer";
+ if(iLayer == 5) {
+ gName += iLayer; gName += "_Ladder";
+ gName += 499+iLadder;
+ gTitle += iLayer; gTitle += "_Ladder";
+ gTitle += 499+iLadder;
+ }
+ if(iLayer == 6) {
+ gName += iLayer; gName += "_Ladder";
+ gName += 599+iLadder;
+ gTitle += iLayer; gTitle += "_Ladder";
+ gTitle += 599+iLadder;
+ }
+ gName += "_PSide";
+ gTitle += "_PSide";
+ fHistSSDOccupancyLadder[occupancyCounter] = new TH1D(gName.Data(),
+ Form("%s;Module number;Occupancy [%]", gTitle.Data()),
+ AliITSgeomTGeo::GetNDetectors(iLayer),
+ 0.5,AliITSgeomTGeo::GetNDetectors(iLayer)+0.5);
+ fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitleColor(1);
+ fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLadder[occupancyCounter],
+ fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
+ occupancyCounter += 1; fSSDRawsOffset += 1;
+ //N-side occupancy plots
+ gName = "fHistSSD_Occupancy_Layer";
+ gTitle = "SSD Occupancy Layer";
+ if(iLayer == 5) {
+ gName += iLayer; gName += "_Ladder";
+ gName += 499+iLadder;
+ gTitle += iLayer; gTitle += "_Ladder";
+ gTitle += 499+iLadder;
+ }
+ if(iLayer == 6) {
+ gName += iLayer; gName += "_Ladder";
+ gName += 599+iLadder;
+ gTitle += iLayer; gTitle += "_Ladder";
+ gTitle += 599+iLadder;
+ }
+ gName += "_NSide";
+ gTitle += "_NSide";
+ fHistSSDOccupancyLadder[occupancyCounter] = new TH1D(gName.Data(),
+ Form("%s;Module number;Occupancy [%]", gTitle.Data()),
+ AliITSgeomTGeo::GetNDetectors(iLayer),
+ 0.5,AliITSgeomTGeo::GetNDetectors(iLayer)+0.5);
+ fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitleColor(1);
+ fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLadder[occupancyCounter],
+ fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
+ occupancyCounter += 1; fSSDRawsOffset += 1;
}//ladder loop
}//layer loop
//top level occupancy plots
//occupancy per module - no threshold
TH2D *fHistSSDOccupancyLayer5 = new TH2D("fHistSSDOccupancyLayer5",
- ";N_{modules};N_{Ladders}",
+ "SSD Occupancy (Layer 5) - No threshold;N_{modules};N_{Ladders}",
fgkSSDMODULESPERLADDERLAYER5,
0,fgkSSDMODULESPERLADDERLAYER5,
3*fgkSSDLADDERSLAYER5,
5000,500+fgkSSDLADDERSLAYER5);
- fHistSSDOccupancyLayer5->SetTitle("Occupancy per module (Layer 5) - No threshold");
fHistSSDOccupancyLayer5->GetZaxis()->SetRangeUser(0.0,100.0);
Char_t fLabel[3];
for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER5 + 1; iBin++){
fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
TH2D *fHistSSDOccupancyLayer6 = new TH2D("fHistSSDOccupancyLayer6",
- ";N_{modules};N_{Ladders}",
+ "Occupancy per module (Layer 6) - No threshold;N_{modules};N_{Ladders}",
fgkSSDMODULESPERLADDERLAYER6,
0,fgkSSDMODULESPERLADDERLAYER6,
3*fgkSSDLADDERSLAYER6,
600,600+fgkSSDLADDERSLAYER6);
- fHistSSDOccupancyLayer6->SetTitle("Occupancy per module (Layer 6) - No threshold");
fHistSSDOccupancyLayer6->GetZaxis()->SetRangeUser(0.0,100.0);
for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER6 + 1; iBin++){
sprintf(fLabel,"%d",iBin);
fHistSSDOccupancyLayer6->GetXaxis()->SetBinLabel(iBin,fLabel);
}
fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLayer6,
- fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
+ fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
//occupancy per module - threshold @ 3%
TH2D *fHistSSDOccupancyThresholdLayer5 = new TH2D("fHistSSDOccupancyThresholdLayer5",
- ";N_{modules};N_{Ladders}",
+ "Occupancy per module (Layer 5) - Threshold 3%;N_{modules};N_{Ladders};Entries",
fgkSSDMODULESPERLADDERLAYER5,
0,fgkSSDMODULESPERLADDERLAYER5,
3*fgkSSDLADDERSLAYER5,
500,500+fgkSSDLADDERSLAYER5);
- fHistSSDOccupancyThresholdLayer5->SetTitle("Occupancy per module (Layer 5) - Threshold 3%");
fHistSSDOccupancyThresholdLayer5->GetZaxis()->SetRangeUser(3.0,10.0);
for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER5 + 1; iBin++){
sprintf(fLabel,"%d",iBin);
fHistSSDOccupancyThresholdLayer5->GetXaxis()->SetBinLabel(iBin,fLabel);
- }
- fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyThresholdLayer5,
- fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
+ }
+ fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyThresholdLayer5,
+ fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
TH2D *fHistSSDOccupancyThresholdLayer6 = new TH2D("fHistSSDOccupancyThresholdLayer6",
- ";N_{modules};N_{Ladders}",
+ "Occupancy per module (Layer 6) - Threshold 3%;N_{modules};N_{Ladders}",
fgkSSDMODULESPERLADDERLAYER6,
0,fgkSSDMODULESPERLADDERLAYER6,
3*fgkSSDLADDERSLAYER6,
600,600+fgkSSDLADDERSLAYER6);
- fHistSSDOccupancyThresholdLayer6->SetTitle("Occupancy per module (Layer 6) - Threshold 3%");
fHistSSDOccupancyThresholdLayer6->GetZaxis()->SetRangeUser(3.0,10.0);
for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER6 + 1; iBin++){
sprintf(fLabel,"%d",iBin);
//Average occupancy per module
TH2D *fHistSSDAverageOccupancyLayer5 = new TH2D("fHistSSDAverageOccupancyLayer5",
- ";N_{modules};N_{Ladders}",
+ "Average occupancy per module (Layer 5);N_{modules};N_{Ladders}",
fgkSSDMODULESPERLADDERLAYER5,
0,fgkSSDMODULESPERLADDERLAYER5,
3*fgkSSDLADDERSLAYER5,
500,500+fgkSSDLADDERSLAYER5);
- fHistSSDAverageOccupancyLayer5->SetTitle("Average occupancy per module (Layer 5)");
fHistSSDAverageOccupancyLayer5->GetZaxis()->SetRangeUser(0.0,5.0);
for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER5 + 1; iBin++){
sprintf(fLabel,"%d",iBin);
fHistSSDAverageOccupancyLayer5->GetXaxis()->SetBinLabel(iBin,fLabel);
}
fAliITSQADataMakerRec->Add2RawsList(fHistSSDAverageOccupancyLayer5,
- fGenRawsOffset+fSSDRawsOffset);
+ fGenRawsOffset+fSSDRawsOffset);
fSSDRawsOffset += 1;
TH2D *fHistSSDAverageOccupancyLayer6 = new TH2D("fHistSSDAverageOccupancyLayer6",
- ";N_{modules};N_{Ladders}",
+ "Average occupancy per module (Layer 6);N_{modules};N_{Ladders}",
fgkSSDMODULESPERLADDERLAYER6,
0,fgkSSDMODULESPERLADDERLAYER6,
3*fgkSSDLADDERSLAYER6,
600,600+fgkSSDLADDERSLAYER6);
- fHistSSDAverageOccupancyLayer6->SetTitle("Average occupancy per module (Layer 6)");
fHistSSDAverageOccupancyLayer6->GetZaxis()->SetRangeUser(0.0,5.0);
for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER6 + 1; iBin++){
sprintf(fLabel,"%d",iBin);
fHistSSDAverageOccupancyLayer6->GetXaxis()->SetBinLabel(iBin,fLabel);
}
fAliITSQADataMakerRec->Add2RawsList(fHistSSDAverageOccupancyLayer6,
- fGenRawsOffset+fSSDRawsOffset, !expert, image, !saveCorr);
+ fGenRawsOffset+fSSDRawsOffset, !expert, image, !saveCorr);
fSSDRawsOffset += 1;
//Output of the DA
TH2D *fHistPSideBadChannelMapLayer5 = new TH2D("fHistPSideBadChannelMapLayer5",
- "Layer 5;N_{module};N_{ladder}",
- 22,1,23,
- 34,500,534);
+ "Layer 5;N_{module};N_{ladder}",
+ 22,1,23,
+ 34,500,534);
fHistPSideBadChannelMapLayer5->GetXaxis()->SetTitleColor(1);
fHistPSideBadChannelMapLayer5->SetStats(kFALSE);
fHistPSideBadChannelMapLayer5->GetYaxis()->SetTitleOffset(1.8);
fHistPSideBadChannelMapLayer5->GetZaxis()->SetTitleOffset(1.6);
fHistPSideBadChannelMapLayer5->GetZaxis()->SetTitle("Bad channels (p-side)[%]");
fAliITSQADataMakerRec->Add2RawsList(fHistPSideBadChannelMapLayer5,
- fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
+ fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
TH2D *fHistNSideBadChannelMapLayer5 = new TH2D("fHistNSideBadChannelMapLayer5",
- "Layer 5;N_{module};N_{ladder}",
- 22,1,23,
- 34,500,534);
+ "Layer 5;N_{module};N_{ladder}",
+ 22,1,23,
+ 34,500,534);
fHistNSideBadChannelMapLayer5->GetXaxis()->SetTitleColor(1);
fHistNSideBadChannelMapLayer5->SetStats(kFALSE);
fHistNSideBadChannelMapLayer5->GetYaxis()->SetTitleOffset(1.8);
fHistNSideBadChannelMapLayer5->GetZaxis()->SetTitleOffset(1.6);
fHistNSideBadChannelMapLayer5->GetZaxis()->SetTitle("Bad channels (n-side)[%]");
fAliITSQADataMakerRec->Add2RawsList(fHistNSideBadChannelMapLayer5,
- fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
+ fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
-
+
TH2D *fHistPSideBadChannelMapLayer6 = new TH2D("fHistPSideBadChannelMapLayer6",
- "Layer 6;N_{module};N_{ladder}",
- 25,1,26,
- 38,600,638);
+ "Layer 6;N_{module};N_{ladder}",
+ 25,1,26,
+ 38,600,638);
fHistPSideBadChannelMapLayer6->GetXaxis()->SetTitleColor(1);
fHistPSideBadChannelMapLayer6->SetStats(kFALSE);
fHistPSideBadChannelMapLayer6->GetYaxis()->SetTitleOffset(1.8);
fHistPSideBadChannelMapLayer6->GetZaxis()->SetTitleOffset(1.6);
fHistPSideBadChannelMapLayer6->GetZaxis()->SetTitle("Bad channels (p-side)[%]");
fAliITSQADataMakerRec->Add2RawsList(fHistPSideBadChannelMapLayer6,
- fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
+ fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
-
+
TH2D *fHistNSideBadChannelMapLayer6 = new TH2D("fHistNSideBadChannelMapLayer6",
- "Layer 6;N_{module};N_{ladder}",
- 25,1,26,
- 38,600,638);
+ "Layer 6;N_{module};N_{ladder}",
+ 25,1,26,
+ 38,600,638);
fHistNSideBadChannelMapLayer6->GetXaxis()->SetTitleColor(1);
fHistNSideBadChannelMapLayer6->SetStats(kFALSE);
fHistNSideBadChannelMapLayer6->GetYaxis()->SetTitleOffset(1.8);
fHistNSideBadChannelMapLayer6->GetZaxis()->SetTitleOffset(1.6);
fHistNSideBadChannelMapLayer6->GetZaxis()->SetTitle("Bad channels (n-side)[%]");
fAliITSQADataMakerRec->Add2RawsList(fHistNSideBadChannelMapLayer6,
- fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
+ fGenRawsOffset+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
}//online flag
-
+
fSSDhRawsTask = fSSDRawsOffset;
AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SSD Raws histograms booked\n",fSSDhRawsTask));
AliDebug(AliQAv1::GetQADebugLevel(), Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenRawsOffset+fSSDhRawsTask));
AliDebug(AliQAv1::GetQADebugLevel(),Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenRawsOffset+fSSDRawsOffset));
/*
- fSSDhTask = fSSDRawsOffset;
- AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SSD Raws histograms booked\n",fSSDhTask));
- AliDebug(AliQAv1::GetQADebugLevel(), Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenRawsOffset+fSSDhTask));
- AliDebug(AliQAv1::GetQADebugLevel(),Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenRawsOffset+fSSDRawsOffset));
- */
+ fSSDhTask = fSSDRawsOffset;
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SSD Raws histograms booked\n",fSSDhTask));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenRawsOffset+fSSDhTask));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenRawsOffset+fSSDRawsOffset));
+ */
}
//____________________________________________________________________________
// custom code here
TH1F *fHistSSDModule = new TH1F("fHistSSDDigitsModule",
- ";SSD Module Number;N_{DIGITS}",
+ "SSD Digits Module;SSD Module Number;N_{DIGITS}",
1698,499.5,2197.5);
fAliITSQADataMakerSim->Add2DigitsList(fHistSSDModule,
fGenOffsetD + 0, !expert, image);
fSSDhDTask += 1;
TH2F *fHistSSDModuleStrip = new TH2F("fHistSSDDigitsModuleStrip",
- ";N_{Strip};N_{Module}",
+ "SSD Digits Module Strip;N_{Strip};N_{Module}",
1540,0,1540,1698,499.5,2197.5);
fAliITSQADataMakerSim->Add2DigitsList(fHistSSDModuleStrip,
fGenOffsetD + 1, !expert, image);
// custom code here
TH1F *fHistSSDModule = new TH1F("fHistSSDSDigitsModule",
- ";SSD Module Number;N_{SDIGITS}",
+ "SSD SDigits Module;SSD Module Number;N_{SDIGITS}",
1698,499.5,2197.5);
fAliITSQADataMakerSim->Add2SDigitsList(fHistSSDModule,
fGenOffsetS + 0, !expert, image);
// custom code here
TH1F *fHistSSDModule = new TH1F("fHistSSDHitsModule",
- ";SDD Module Number;N_{HITS}",
+ "SSD Hits Module;SDD Module Number;N_{HITS}",
1698,499.5,2197.5);
fAliITSQADataMakerSim->Add2HitsList(fHistSSDModule,
fGenOffsetH + 0, !expert, image);
fSSDhHTask += 1;
TH1F *fHistSSDGlobalX = new TH1F("fHistSSDHitsGlobalX",
- ";x [cm];Entries",
+ "SSD Hits Global X;x [cm];Entries",
1000,-50.,50.);
fAliITSQADataMakerSim->Add2HitsList(fHistSSDGlobalX,
fGenOffsetH + 1, !expert, image);
fSSDhHTask += 1;
TH1F *fHistSSDGlobalY = new TH1F("fHistSSDHitsGlobalY",
- ";y [cm];Entries",
+ "SSD Hits Global Y;y [cm];Entries",
1000,-50.,50.);
fAliITSQADataMakerSim->Add2HitsList(fHistSSDGlobalY,
fGenOffsetH + 2, !expert, image);
fSSDhHTask += 1;
TH1F *fHistSSDGlobalZ = new TH1F("fHistSSDHitsGlobalZ",
- ";z [cm];Entries",
+ "SSD Hits Global Z ;z [cm];Entries",
1000,-60.,60.);
fAliITSQADataMakerSim->Add2HitsList(fHistSSDGlobalZ,
fGenOffsetH + 3, !expert, image);
fSSDhHTask += 1;
TH1F *fHistSSDLocalX = new TH1F("fHistSSDHitsLocalX",
- ";x [cm];Entries",
+ "SSD Hits Local X;x [cm];Entries",
1000,-4.,4.);
fAliITSQADataMakerSim->Add2HitsList(fHistSSDLocalX,
fGenOffsetH + 4, !expert, image);
fSSDhHTask += 1;
TH1F *fHistSSDLocalY = new TH1F("fHistSSDHitsLocalY",
- ";y [cm];Entries",
+ "SSD Hits Local Y;y [cm];Entries",
1000,-0.1,0.1);
fAliITSQADataMakerSim->Add2HitsList(fHistSSDLocalY,
fGenOffsetH + 5, !expert, image);
fSSDhHTask += 1;
TH1F *fHistSSDLocalZ = new TH1F("fHistSSDHitsLocalZ",
- ";z [cm];Entries",
+ "SSD Hits Local Z;z [cm];Entries",
1000,-4.,4.);
fAliITSQADataMakerSim->Add2HitsList(fHistSSDLocalZ,
fGenOffsetH + 6, !expert, image);
fSSDhHTask += 1;
TH1F *fHistSSDIonization = new TH1F("fHistSSDHitsIonization",
- ";log(dE/dx) [KeV];N_{Hits}",
+ "SSD Hits Ionization;log(dE/dx) [KeV];N_{Hits}",
100,-7,-2);
fAliITSQADataMakerSim->Add2HitsList(fHistSSDIonization,
fGenOffsetH + 7, !expert, image);
fSSDhHTask += 1;
TH2F *fHistSSDGlobalXY = new TH2F("fHistSSDHitsGlobalXY",
- ";x [cm];y [cm]",
+ "SSD Hits Global XY;x [cm];y [cm]",
1000,-50.,50.,
1000,-50.,50.);
fAliITSQADataMakerSim->Add2HitsList(fHistSSDGlobalXY,
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1I* h0 = new TH1I("hDigitsDetElem", "Detection element distribution in Digits", 1400, 100, 1500);
+ TH1I* h0 = new TH1I("hDigitsDetElem", "Detection element distribution in Digits;Detection element Id;Counts", 1400, 100, 1500);
Add2DigitsList(h0, 0, !expert, image);
- TH1I* h1 = new TH1I("hDigitsADC", "ADC distribution in Digits", 4096, 0, 4095);
- Add2DigitsList(h1, 1, !expert, image);
-
+ TH1I* h1 = new TH1I("hDigitsADC", "ADC distribution in Digits;ACD value;Counts", 4096, 0, 4095);
+ Add2DigitsList(h1, 1, !expert, image);
}
//____________________________________________________________________________
Int_t nCh = AliMpConstants::NofTrackingChambers();
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);
+ h1I = new TH1I(Form("hTrackerClusterMultiplicityForChamber%d",i+1), Form("cluster size distribution in chamber %d;size (n_{pads};Counts)",i+1), 100,0,100);
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);
+ h1I = new TH1I(Form("hTrackerClusterChargeForChamber%d",i+1), Form("cluster charge distribution in chamber %d;charge (ADC counts);Counts",i+1), 500,0,5000);
Add2RecPointsList(h1I,kTrackerClusterChargePerChamber+i, expert, !image);
Float_t rMax = AliMUONConstants::Rmax(i/2);
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F* h0 = new TH1F("hHitDetElem", "DetElemId distribution in Hits", 1400, 100., 1500.);
+ TH1F* h0 = new TH1F("hHitDetElem", "DetElemId distribution in Hits;Detection element Id;Counts", 1400, 100., 1500.);
Add2HitsList(h0, 0, !expert, image);
- TH1F* h1 = new TH1F("hHitPtot", "P distribution in Hits ", 300, 0., 300.);
+ TH1F* h1 = new TH1F("hHitPtot", "P distribution in Hits;P [erg];Counts ", 300, 0., 300.);
Add2HitsList(h1, 1, !expert, image);
return;
}
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1I* h0 = new TH1I("hSDigitsDetElem", "Detection element distribution in SDigits", 1400, 100, 1500);
+ TH1I* h0 = new TH1I("hSDigitsDetElem", "Detection element distribution in SDigits;Detection element Id;Counts", 1400, 100, 1500);
Add2SDigitsList(h0, 0, !expert, image);
- TH1F* h1 = new TH1F("hSDigitsCharge", "Charge distribution in SDigits", 4096, 0, 4095);
+ TH1F* h1 = new TH1F("hSDigitsCharge", "Charge distribution in SDigits;Charge [??];Counts", 4096, 0, 4095);
Add2SDigitsList(h1, 1, !expert, image);
}
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1I* h0 = new TH1I("hDigitsDetElem", "Detection element distribution in Digits", 1400, 100, 1500);
+ TH1I* h0 = new TH1I("hDigitsDetElem", "Detection element distribution in Digits;Detection element Id;Counts", 1400, 100, 1500);
Add2DigitsList(h0, 0, !expert, image);
- TH1I* h1 = new TH1I("hDigitsADC", "ADC distribution in Digits", 4096, 0, 4095);
+ TH1I* h1 = new TH1I("hDigitsADC", "ADC distribution in Digits;ACD value;Counts", 4096, 0, 4095);
Add2DigitsList(h1, 1, !expert, image);
}
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F * h1 = new TH1F("hESDPhosSpectrum", "ESDs spectrum in PHOS" , 200, 0., 20.) ;
+ TH1F * h1 = new TH1F("hESDPhosSpectrum", "ESDs spectrum in PHOS; Energy [MeV];Counts" , 200, 0., 20.) ;
h1->Sumw2() ;
Add2ESDsList(h1, kESDSpec, !expert, image) ;
- TH1I * h2 = new TH1I("hESDPhosMul", "ESDs multiplicity distribution in PHOS", 100, 0, 100 ) ;
+ TH1I * h2 = new TH1I("hESDPhosMul", "ESDs multiplicity distribution in PHOS; # of clusters;Counts", 100, 0, 100 ) ;
h2->Sumw2() ;
Add2ESDsList(h2, kESDNtot, !expert, image) ;
- TH1F * h3 = new TH1F("hESDPhosEtot", "ESDs total energy" , 2000, 0, 200.) ;
+ TH1F * h3 = new TH1F("hESDPhosEtot", "ESDs total energy;Energy [MeV];Counts" , 2000, 0, 200.) ;
h3->Sumw2() ;
Add2ESDsList(h3, kESDEtot, !expert, image) ; //Expert histo
- TH1F * h4 = new TH1F("hESDpid", "ESDs PID distribution in PHOS" , 100, 0., 1.) ;
+ TH1F * h4 = new TH1F("hESDpid", "ESDs PID distribution in PHOS;Particle Id;Counts" , 100, 0., 1.) ;
h4->Sumw2() ;
Add2ESDsList(h4, kESDpid, !expert, image) ; //Expert histo
// create Digits histograms in Digits subdir
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1I * h0 = new TH1I("hPhosDigits", "Digits amplitude distribution in PHOS", 500, 0, 1000) ;
+ TH1I * h0 = new TH1I("hPhosDigits", "Digits amplitude distribution in PHOS;Amplitude [ADC counts];Counts", 500, 0, 1000) ;
h0->Sumw2() ;
Add2DigitsList(h0, kDigits, !expert, image) ;
- TH1I * h1 = new TH1I("hPhosDigitsMul", "Digits multiplicity distribution in PHOS", 2000, 0, 10000) ;
+ TH1I * h1 = new TH1I("hPhosDigitsMul", "Digits multiplicity distribution in PHOS;# of Digits;Entries", 2000, 0, 10000) ;
h1->Sumw2() ;
Add2DigitsList(h1, kDigitsMul, !expert, image) ;
}
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.) ;
+ TH2I * h0 = new TH2I("hRpPHOSxyMod1","RecPoints Rows x Columns for PHOS module 1;Row #;Column #", 64, -72., 72., 56, -63., 63.) ;
Add2RecPointsList(h0,kRPmod1, expert, !image) ;
- TH2I * h1 = new TH2I("hRpPHOSxyMod2","RecPoints Rows x Columns for PHOS module 2", 64, -72., 72., 56, -63., 63.) ;
+ TH2I * h1 = new TH2I("hRpPHOSxyMod2","RecPoints Rows x Columns for PHOS module 2;Row #;Column #", 64, -72., 72., 56, -63., 63.) ;
Add2RecPointsList(h1,kRPmod2, expert, !image) ;
- TH2I * h2 = new TH2I("hRpPHOSxyMod3","RecPoints Rows x Columns for PHOS module 3", 64, -72., 72., 56, -63., 63.) ;
+ TH2I * h2 = new TH2I("hRpPHOSxyMod3","RecPoints Rows x Columns for PHOS module 3;Row #;Column #", 64, -72., 72., 56, -63., 63.) ;
Add2RecPointsList(h2,kRPmod3, expert, !image) ;
- TH2I * h3 = new TH2I("hRpPHOSxyMod4","RecPoints Rows x Columns for PHOS module 4", 64, -72., 72., 56, -63., 63.) ;
+ TH2I * h3 = new TH2I("hRpPHOSxyMod4","RecPoints Rows x Columns for PHOS module 4;Row #;Column #", 64, -72., 72., 56, -63., 63.) ;
Add2RecPointsList(h3,kRPmod4, expert, !image) ;
- TH2I * h4 = new TH2I("hRpPHOSxyMod5","RecPoints Rows x Columns for PHOS module 5", 64, -72., 72., 56, -63., 63.) ;
+ TH2I * h4 = new TH2I("hRpPHOSxyMod5","RecPoints Rows x Columns for PHOS module 5;Row #;Column #", 64, -72., 72., 56, -63., 63.) ;
Add2RecPointsList(h4,kRPmod5, expert, !image) ;
- TH1F * h5 = new TH1F("hEmcPhosRecPointsSpectrum", "EMC RecPoints spectrum in PHOS", 2000, 0., 20.) ;
+ TH1F * h5 = new TH1F("hEmcPhosRecPointsSpectrum", "EMC RecPoints spectrum in PHOS;Energy [MeV];Counts", 2000, 0., 20.) ;
h5->Sumw2() ;
Add2RecPointsList(h5, kRPSpec, !expert, image) ;
- TH1I * h6 = new TH1I("hEmcPhosRecPointsMul", "EMCA RecPoints multiplicity distribution in PHOS", 100, 0, 100) ;
+ TH1I * h6 = new TH1I("hEmcPhosRecPointsMul", "EMC RecPoints multiplicity distribution in PHOS;# of EMC Clusters;Entries", 100, 0, 100) ;
h6->Sumw2() ;
Add2RecPointsList(h6, kRPNtot, !expert, image) ;
- TH1I * h7 = new TH1I("hEmcPhosRecPointsEtot", "EMC RecPoints Etot", 200, 0, 200.) ;
+ TH1I * h7 = new TH1I("hEmcPhosRecPointsEtot", "EMC RecPoints Etot;Energy [MeV];Counts", 200, 0, 200.) ;
h7->Sumw2() ;
Add2RecPointsList(h7, kRPEtot, !expert, image) ;
- TH1I * h8 = new TH1I("hCpvPhosRecPointsMul", "CPV RecPoints multiplicity distribution in PHOS", 100, 0, 100) ;
+ TH1I * h8 = new TH1I("hCpvPhosRecPointsMul", "CPV RecPoints multiplicity distribution in PHOS;# of CPV clusters;Counts", 100, 0, 100) ;
h8->Sumw2() ;
Add2RecPointsList(h8, kRPNcpv, !expert, image) ;
}
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) ;
+ TH2I * h0 = new TH2I("hHighPHOSxyMod1","High Gain Rows x Columns for PHOS module 1;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
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) ;
+ TH2I * h1 = new TH2I("hHighPHOSxyMod2","High Gain Rows x Columns for PHOS module 2;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
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) ;
+ TH2I * h2 = new TH2I("hHighPHOSxyMod3","High Gain Rows x Columns for PHOS module 3;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
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) ;
+ TH2I * h3 = new TH2I("hHighPHOSxyMod4","High Gain Rows x Columns for PHOS module 4;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
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) ;
+ TH2I * h4 = new TH2I("hHighPHOSxyMod5","High Gain Rows x Columns for PHOS module 5;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
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) ;
+ TH2I * h5 = new TH2I("hLowPHOSxyMod1","Low Gain Rows x Columns for PHOS module 1;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
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) ;
+ TH2I * h6 = new TH2I("hLowPHOSxyMod2","Low Gain Rows x Columns for PHOS module 2;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
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) ;
+ TH2I * h7 = new TH2I("hLowPHOSxyMod3","Low Gain Rows x Columns for PHOS module 3;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
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) ;
+ TH2I * h8 = new TH2I("hLowPHOSxyMod4","Low Gain Rows x Columns for PHOS module 4;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
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) ;
+ TH2I * h9 = new TH2I("hLowPHOSxyMod5","Low Gain Rows x Columns for PHOS module 5;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
Add2RawsList(h9,kLGmod5, expert, !image, !saveCorr) ;
- TH1I * h10 = new TH1I("hLowPhosModules", "Low Gain Hits in EMCA PHOS modules", 6, 0, 6) ;
+ TH1I * h10 = new TH1I("hLowPhosModules", "Low Gain Hits in EMCA PHOS modules;# of hit modules;Counts", 6, 0, 6) ;
h10->Sumw2() ;
Add2RawsList(h10, kNmodLG, !expert, image, !saveCorr) ;
- TH1I * h11 = new TH1I("hHighPhosModules", "High Gain Hits in EMCA PHOS modules", 6, 0, 6) ;
+ TH1I * h11 = new TH1I("hHighPhosModules", "High Gain Hits in EMCA PHOS modules;# of hit modules;Counts", 6, 0, 6) ;
h11->Sumw2() ;
Add2RawsList(h11, kNmodHG, !expert, image, !saveCorr) ;
- TH1F * h12 = new TH1F("hLowPhosRawtime", "Low Gain Time of raw hits in PHOS", 500, -50., 200.) ;
+ TH1F * h12 = new TH1F("hLowPhosRawtime", "Low Gain Time of raw hits in PHOS;Time [ns];Counts", 500, -50., 200.) ;
h12->Sumw2() ;
Add2RawsList(h12, kLGtime, !expert, image, !saveCorr) ;
- TH1F * h13 = new TH1F("hHighPhosRawtime", "High Gain Time of raw hits in PHOS", 500, -50., 200.) ;
+ TH1F * h13 = new TH1F("hHighPhosRawtime", "High Gain Time of raw hits in PHOS;Time [ns];Counts", 500, -50., 200.) ;
h13->Sumw2() ;
Add2RawsList(h13, kHGtime, !expert, image, !saveCorr) ;
- TH1F * h14 = new TH1F("hLowPhosRawEnergy", "Low Gain Energy of raw hits in PHOS", 500, 0., 1000.) ;
+ TH1F * h14 = new TH1F("hLowPhosRawEnergy", "Low Gain Energy of raw hits in PHOS;Energy [MeV];Counts", 500, 0., 1000.) ;
h14->Sumw2() ;
Add2RawsList(h14, kSpecLG, !expert, image, !saveCorr) ;
- TH1F * h15 = new TH1F("hHighPhosRawEnergy", "High Gain Energy of raw hits in PHOS",500,0., 1000.) ;
+ TH1F * h15 = new TH1F("hHighPhosRawEnergy", "High Gain Energy of raw hits in PHOS;Energy [MeV];Counts",500,0., 1000.) ;
h15->Sumw2() ;
Add2RawsList(h15, kSpecHG, !expert, image, !saveCorr) ;
- TH1F * h16 = new TH1F("hLowNtot", "Low Gain Total Number of raw hits in PHOS", 500, 0., 5000.) ;
+ TH1F * h16 = new TH1F("hLowNtot", "Low Gain Total Number of raw hits in PHOS;# of hits;Counts", 500, 0., 5000.) ;
h16->Sumw2() ;
Add2RawsList(h16, kNtotLG, !expert, saveCorr, image) ;
- TH1F * h17 = new TH1F("hHighNtot", "High Gain Total Number of raw hits in PHOS",500,0., 5000.) ;
+ TH1F * h17 = new TH1F("hHighNtot", "High Gain Total Number of raw hits in PHOS;# of hits;Counts",500,0., 5000.) ;
h17->Sumw2() ;
Add2RawsList(h17, kNtotHG, !expert, saveCorr, image) ;
- TH1F * h18 = new TH1F("hLowEtot", "Low Gain Total Energy of raw hits in PHOS", 500, 0., 5000.) ;
+ TH1F * h18 = new TH1F("hLowEtot", "Low Gain Total Energy of raw hits in PHOS;Energy [MeV];Counts", 500, 0., 5000.) ;
h18->Sumw2() ;
Add2RawsList(h18, kEtotLG, !expert, saveCorr, image) ;
- TH1F * h19 = new TH1F("hHighEtot", "High Gain Total Energy of raw hits in PHOS",500,0., 100000.) ;
+ TH1F * h19 = new TH1F("hHighEtot", "High Gain Total Energy of raw hits in PHOS;Energy [MeV];Counts",500,0., 100000.) ;
h19->Sumw2() ;
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) ;
+ TH2F * h20 = new TH2F("hQualHGxyMod1","High Gain signal quality Rows x Columns module 1;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
h20->SetOption("colz");
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) ;
+ TH2F * h21 = new TH2F("hQualHGxyMod2","High Gain signal quality Rows x Columns module 2;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
h21->SetOption("colz");
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) ;
+ TH2F * h22 = new TH2F("hQualHGxyMod3","High Gain signal quality Rows x Columns module 3;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
h22->SetOption("colz");
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) ;
+ TH2F * h23 = new TH2F("hQualHGxyMod4","High Gain signal quality Rows x Columns module 4;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
h23->SetOption("colz");
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) ;
+ TH2F * h24 = new TH2F("hQualHGxyMod5","High Gain signal quality Rows x Columns module 5;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
h24->SetOption("colz");
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) ;
+ TH2F * h25 = new TH2F("hQualLGxyMod1","Low Gain signal quality Rows x Columns module 1;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
h25->SetOption("colz");
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) ;
+ TH2F * h26 = new TH2F("hQualLGxyMod2","Low Gain signal quality Rows x Columns module 2;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
h26->SetOption("colz");
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) ;
+ TH2F * h27 = new TH2F("hQualLGxyMod3","Low Gain signal quality Rows x Columns module 3;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
h27->SetOption("colz");
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) ;
+ TH2F * h28 = new TH2F("hQualLGxyMod4","Low Gain signal quality Rows x Columns module 4;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
h28->SetOption("colz");
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) ;
+ TH2F * h29 = new TH2F("hQualLGxyMod5","Low Gain signal quality Rows x Columns module 5;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
h29->SetOption("colz");
Add2RawsList(h29,kLGqualMod5, expert, !image, !saveCorr) ;
- TH1F * h30 = new TH1F("hLGpedRMS","Low Gain pedestal RMS",200,0.,20.) ;
+ TH1F * h30 = new TH1F("hLGpedRMS","Low Gain pedestal RMS;Width [ADC counts];Counts",200,0.,20.) ;
h30->Sumw2() ;
Add2RawsList(h30,kLGpedRMS, !expert, image, !saveCorr) ;
- TH1F * h31 = new TH1F("hHGpedRMS","High Gain pedestal RMS",200,0.,20.) ;
+ TH1F * h31 = new TH1F("hHGpedRMS","High Gain pedestal RMS;Width [ADC counts];Counts",200,0.,20.) ;
h31->Sumw2() ;
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) ;
+ TH2F * h32 = new TH2F("hpedRMSHGxyMod1","High Gain pedestal RMS Rows x Columns module 1;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
h32->SetOption("colz");
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) ;
+ TH2F * h33 = new TH2F("hpedRMSHGxyMod2","High Gain pedestal RMS Rows x Columns module 2;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
h33->SetOption("colz");
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) ;
+ TH2F * h34 = new TH2F("hpedRMSHGxyMod3","High Gain pedestal RMS Rows x Columns module 3;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
h34->SetOption("colz");
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) ;
+ TH2F * h35 = new TH2F("hpedRMSHGxyMod4","High Gain pedestal RMS Rows x Columns module 4;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
h35->SetOption("colz");
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) ;
+ TH2F * h36 = new TH2F("hpedRMSHGxyMod5","High Gain pedestal RMS Rows x Columns module 5;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
h36->SetOption("colz");
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) ;
+ TH2F * h37 = new TH2F("hpedRMSLGxyMod1","Low Gain pedestal RMS Rows x Columns module 1;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
h37->SetOption("colz");
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) ;
+ TH2F * h38 = new TH2F("hpedRMSLGxyMod2","Low Gain pedestal RMS Rows x Columns module 2;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
h38->SetOption("colz");
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) ;
+ TH2F * h39 = new TH2F("hpedRMSLGxyMod3","Low Gain pedestal RMS Rows x Columns module 3;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
h39->SetOption("colz");
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) ;
+ TH2F * h40 = new TH2F("hpedRMSLGxyMod4","Low Gain pedestal RMS Rows x Columns module 4;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
h40->SetOption("colz");
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) ;
+ TH2F * h41 = new TH2F("hpedRMSLGxyMod5","Low Gain pedestal RMS Rows x Columns module 5;Row #;Column #", 64, 0, 64, 56, 0, 56) ;
h41->SetOption("colz");
Add2RawsList(h41,kLGpedRMSMod5, expert, !image, !saveCorr) ;
// create Hits histograms in Hits subdir
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F * h0 = new TH1F("hPhosHits", "Hits energy distribution in PHOS", 100, 0., 100.) ;
+ TH1F * h0 = new TH1F("hPhosHits", "Hits energy distribution in PHOS;Energy [MeV];Counts", 100, 0., 100.) ;
h0->Sumw2() ;
Add2HitsList(h0, kHits, !expert, image) ;
- TH1I * h1 = new TH1I("hPhosHitsMul", "Hits multiplicity distribution in PHOS", 500, 0., 10000) ;
+ TH1I * h1 = new TH1I("hPhosHitsMul", "Hits multiplicity distribution in PHOS;# of Hits;Entries", 500, 0., 10000) ;
h1->Sumw2() ;
Add2HitsList(h1, kHitsMul, !expert, image) ;
// create Digits histograms in Digits subdir
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1I * h0 = new TH1I("hPhosDigits", "Digits amplitude distribution in PHOS", 500, 0, 1000) ;
+ TH1I * h0 = new TH1I("hPhosDigits", "Digits amplitude distribution in PHOS;Amplitude [ADC counts];Counts", 500, 0, 1000) ;
h0->Sumw2() ;
Add2DigitsList(h0, kDigits, !expert, image) ;
- TH1I * h1 = new TH1I("hPhosDigitsMul", "Digits multiplicity distribution in PHOS", 2000, 0, 10000) ;
+ TH1I * h1 = new TH1I("hPhosDigitsMul", "Digits multiplicity distribution in PHOS;# of Digits;Entries", 2000, 0, 10000) ;
h1->Sumw2() ;
Add2DigitsList(h1, kDigitsMul, !expert, image) ;
}
// create SDigits histograms in SDigits subdir
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F * h0 = new TH1F("hPhosSDigits", "SDigits energy distribution in PHOS", 500, 0., 1000.) ;
+ TH1F * h0 = new TH1F("hPhosSDigits", "SDigits energy distribution in PHOS; Energy [MeV];Counts", 500, 0., 1000.) ;
h0->Sumw2() ;
Add2SDigitsList(h0, kSDigits, !expert, image) ;
- TH1I * h1 = new TH1I("hPhosSDigitsMul", "SDigits multiplicity distribution in PHOS", 500, 0, 1000) ;
+ TH1I * h1 = new TH1I("hPhosSDigitsMul", "SDigits multiplicity distribution in PHOS;# of SDigits;Entries", 500, 0, 1000) ;
h1->Sumw2() ;
Add2SDigitsList(h1, kSDigitsMul, !expert, image) ;
}
const Bool_t image = kTRUE ;
// Preshower plane
- TH1I * h0 = new TH1I("hPreEdepM0","ADC Distribution PRE - Module 0", 100, 0, 2000);
+ TH1I * h0 = new TH1I("hPreEdepM0","ADC Distribution PRE - Module 0;Amplitude [ADC counts];Counts", 100, 0, 2000);
h0->Sumw2();
Add2RawsList(h0, 0, !expert, image, !saveCorr);
- TH1I * h1 = new TH1I("hPreEdepM1","ADC Distribution PRE - Module 1", 100, 0, 2000);
+ TH1I * h1 = new TH1I("hPreEdepM1","ADC Distribution PRE - Module 1;Amplitude [ADC counts];Counts", 100, 0, 2000);
h1->Sumw2();
Add2RawsList(h1, 1, !expert, image, !saveCorr);
- TH1I * h2 = new TH1I("hPreEdepM2","ADC Distribution PRE - Module 2", 100, 0, 2000);
+ TH1I * h2 = new TH1I("hPreEdepM2","ADC Distribution PRE - Module 2;Amplitude [ADC counts];Counts", 100, 0, 2000);
h2->Sumw2();
Add2RawsList(h2, 2, !expert, image, !saveCorr);
- TH1I * h3 = new TH1I("hPreEdepM3","ADC Distribution PRE - Module 3", 100, 0, 2000);
+ TH1I * h3 = new TH1I("hPreEdepM3","ADC Distribution PRE - Module 3;Amplitude [ADC counts];Counts", 100, 0, 2000);
h3->Sumw2();
Add2RawsList(h3, 3, !expert, image, !saveCorr);
- TH1I * h4 = new TH1I("hPreEdepM4","ADC Distribution PRE - Module 4", 100, 0, 2000);
+ TH1I * h4 = new TH1I("hPreEdepM4","ADC Distribution PRE - Module 4;Amplitude [ADC counts];Counts", 100, 0, 2000);
h4->Sumw2();
Add2RawsList(h4, 4, !expert, image, !saveCorr);
- TH1I * h5 = new TH1I("hPreEdepM5","ADC Distribution PRE - Module 5", 100, 0, 2000);
+ TH1I * h5 = new TH1I("hPreEdepM5","ADC Distribution PRE - Module 5;Amplitude [ADC counts];Counts", 100, 0, 2000);
h5->Sumw2();
Add2RawsList(h5, 5, !expert, image, !saveCorr);
- TH1I * h6 = new TH1I("hPreEdepM6","ADC Distribution PRE - Module 6", 100, 0, 2000);
+ TH1I * h6 = new TH1I("hPreEdepM6","ADC Distribution PRE - Module 6;Amplitude [ADC counts];Counts", 100, 0, 2000);
h6->Sumw2();
Add2RawsList(h6, 6, !expert, image, !saveCorr);
- TH1I * h7 = new TH1I("hPreEdepM7","ADC Distribution PRE - Module 7", 100, 0, 2000);
+ TH1I * h7 = new TH1I("hPreEdepM7","ADC Distribution PRE - Module 7;Amplitude [ADC counts];Counts", 100, 0, 2000);
h7->Sumw2();
Add2RawsList(h7, 7, !expert, image, !saveCorr);
- TH1I * h8 = new TH1I("hPreEdepM8","ADC Distribution PRE - Module 8", 100, 0, 2000);
+ TH1I * h8 = new TH1I("hPreEdepM8","ADC Distribution PRE - Module 8;Amplitude [ADC counts];Counts", 100, 0, 2000);
h8->Sumw2();
Add2RawsList(h8, 8, !expert, image, !saveCorr);
- TH1I * h9 = new TH1I("hPreEdepM9","ADC Distribution PRE - Module 9", 100, 0, 2000);
+ TH1I * h9 = new TH1I("hPreEdepM9","ADC Distribution PRE - Module 9;Amplitude [ADC counts];Counts", 100, 0, 2000);
h9->Sumw2();
Add2RawsList(h9, 9, !expert, image, !saveCorr);
- TH1I * h10 = new TH1I("hPreEdepM10","ADC Distribution PRE - Module 10", 100, 0, 2000);
+ TH1I * h10 = new TH1I("hPreEdepM10","ADC Distribution PRE - Module 10;Amplitude [ADC counts];Counts", 100, 0, 2000);
h10->Sumw2();
Add2RawsList(h10, 10, !expert, image, !saveCorr);
- TH1I * h11 = new TH1I("hPreEdepM11","ADC Distribution PRE - Module 11", 100, 0, 2000);
+ TH1I * h11 = new TH1I("hPreEdepM11","ADC Distribution PRE - Module 11;Amplitude [ADC counts];Counts", 100, 0, 2000);
h11->Sumw2();
Add2RawsList(h11, 11, !expert, image, !saveCorr);
- TH1I * h12 = new TH1I("hPreEdepM12","ADC Distribution PRE - Module 12", 100, 0, 2000);
+ TH1I * h12 = new TH1I("hPreEdepM12","ADC Distribution PRE - Module 12;Amplitude [ADC counts];Counts", 100, 0, 2000);
h12->Sumw2();
Add2RawsList(h12, 12, !expert, image, !saveCorr);
- TH1I * h13 = new TH1I("hPreEdepM13","ADC Distribution PRE - Module 13", 100, 0, 2000);
+ TH1I * h13 = new TH1I("hPreEdepM13","ADC Distribution PRE - Module 13;Amplitude [ADC counts];Counts", 100, 0, 2000);
h13->Sumw2();
Add2RawsList(h13, 13, !expert, image, !saveCorr);
- TH1I * h14 = new TH1I("hPreEdepM14","ADC Distribution PRE - Module 14", 100, 0, 2000);
+ TH1I * h14 = new TH1I("hPreEdepM14","ADC Distribution PRE - Module 14;Amplitude [ADC counts];Counts", 100, 0, 2000);
h14->Sumw2();
Add2RawsList(h14, 14, !expert, image, !saveCorr);
- TH1I * h15 = new TH1I("hPreEdepM15","ADC Distribution PRE - Module 15", 100, 0, 2000);
+ TH1I * h15 = new TH1I("hPreEdepM15","ADC Distribution PRE - Module 15;Amplitude [ADC counts];Counts", 100, 0, 2000);
h15->Sumw2();
Add2RawsList(h15, 15, !expert, image, !saveCorr);
- TH1I * h16 = new TH1I("hPreEdepM16","ADC Distribution PRE - Module 16", 100, 0, 2000);
+ TH1I * h16 = new TH1I("hPreEdepM16","ADC Distribution PRE - Module 16;Amplitude [ADC counts];Counts", 100, 0, 2000);
h16->Sumw2();
Add2RawsList(h16, 16, !expert, image, !saveCorr);
- TH1I * h17 = new TH1I("hPreEdepM17","ADC Distribution PRE - Module 17", 100, 0, 2000);
+ TH1I * h17 = new TH1I("hPreEdepM17","ADC Distribution PRE - Module 17;Amplitude [ADC counts];Counts", 100, 0, 2000);
h17->Sumw2();
Add2RawsList(h17, 17, !expert, image, !saveCorr);
- TH1I * h18 = new TH1I("hPreEdepM18","ADC Distribution PRE - Module 18", 100, 0, 2000);
+ TH1I * h18 = new TH1I("hPreEdepM18","ADC Distribution PRE - Module 18;Amplitude [ADC counts];Counts", 100, 0, 2000);
h18->Sumw2();
Add2RawsList(h18, 18, !expert, image, !saveCorr);
- TH1I * h19 = new TH1I("hPreEdepM19","ADC Distribution PRE - Module 19", 100, 0, 2000);
+ TH1I * h19 = new TH1I("hPreEdepM19","ADC Distribution PRE - Module 19;Amplitude [ADC counts];Counts", 100, 0, 2000);
h19->Sumw2();
Add2RawsList(h19, 19, !expert, image, !saveCorr);
- TH1I * h20 = new TH1I("hPreEdepM20","ADC Distribution PRE - Module 20", 100, 0, 2000);
+ TH1I * h20 = new TH1I("hPreEdepM20","ADC Distribution PRE - Module 20;Amplitude [ADC counts];Counts", 100, 0, 2000);
h20->Sumw2();
Add2RawsList(h20, 20, !expert, image, !saveCorr);
- TH1I * h21 = new TH1I("hPreEdepM21","ADC Distribution PRE - Module 21", 100, 0, 2000);
+ TH1I * h21 = new TH1I("hPreEdepM21","ADC Distribution PRE - Module 21;Amplitude [ADC counts];Counts", 100, 0, 2000);
h21->Sumw2();
Add2RawsList(h21, 21, !expert, image, !saveCorr);
- TH1I * h22 = new TH1I("hPreEdepM22","ADC Distribution PRE - Module 22", 100, 0, 2000);
+ TH1I * h22 = new TH1I("hPreEdepM22","ADC Distribution PRE - Module 22;Amplitude [ADC counts];Counts", 100, 0, 2000);
h22->Sumw2();
Add2RawsList(h22, 22, !expert, image, !saveCorr);
- TH1I * h23 = new TH1I("hPreEdepM23","ADC Distribution PRE - Module 23", 100, 0, 2000);
+ TH1I * h23 = new TH1I("hPreEdepM23","ADC Distribution PRE - Module 23;Amplitude [ADC counts];Counts", 100, 0, 2000);
h23->Sumw2();
Add2RawsList(h23, 23, !expert, image, !saveCorr);
// CPV histos
- TH1I * h24 = new TH1I("hCpvEdepM24","ADC Distribution CPV - Module 24", 100, 0, 2000);
+ TH1I * h24 = new TH1I("hCpvEdepM24","ADC Distribution CPV - Module 24;Amplitude [ADC counts];Counts", 100, 0, 2000);
h24->Sumw2();
Add2RawsList(h24, 24, !expert, image, !saveCorr);
- TH1I * h25 = new TH1I("hCpvEdepM25","ADC Distribution CPV - Module 25", 100, 0, 2000);
+ TH1I * h25 = new TH1I("hCpvEdepM25","ADC Distribution CPV - Module 25;Amplitude [ADC counts];Counts", 100, 0, 2000);
h25->Sumw2();
Add2RawsList(h25, 25, !expert, image, !saveCorr);
- TH1I * h26 = new TH1I("hCpvEdepM26","ADC Distribution CPV - Module 26", 100, 0, 2000);
+ TH1I * h26 = new TH1I("hCpvEdepM26","ADC Distribution CPV - Module 26;Amplitude [ADC counts];Counts", 100, 0, 2000);
h26->Sumw2();
Add2RawsList(h26, 26, !expert, image, !saveCorr);
- TH1I * h27 = new TH1I("hCpvEdepM27","ADC Distribution CPV - Module 27", 100, 0, 2000);
+ TH1I * h27 = new TH1I("hCpvEdepM27","ADC Distribution CPV - Module 27;Amplitude [ADC counts];Counts", 100, 0, 2000);
h27->Sumw2();
Add2RawsList(h27, 27, !expert, image, !saveCorr);
- TH1I * h28 = new TH1I("hCpvEdepM28","ADC Distribution CPV - Module 28", 100, 0, 2000);
+ TH1I * h28 = new TH1I("hCpvEdepM28","ADC Distribution CPV - Module 28;Amplitude [ADC counts];Counts", 100, 0, 2000);
h28->Sumw2();
Add2RawsList(h28, 28, !expert, image, !saveCorr);
- TH1I * h29 = new TH1I("hCpvEdepM29","ADC Distribution CPV - Module 29", 100, 0, 2000);
+ TH1I * h29 = new TH1I("hCpvEdepM29","ADC Distribution CPV - Module 29;Amplitude [ADC counts];Counts", 100, 0, 2000);
h29->Sumw2();
Add2RawsList(h29, 29, !expert, image, !saveCorr);
- TH1I * h30 = new TH1I("hCpvEdepM30","ADC Distribution CPV - Module 30", 100, 0, 2000);
+ TH1I * h30 = new TH1I("hCpvEdepM30","ADC Distribution CPV - Module 30;Amplitude [ADC counts];Counts", 100, 0, 2000);
h30->Sumw2();
Add2RawsList(h30, 30, !expert, image, !saveCorr);
- TH1I * h31 = new TH1I("hCpvEdepM31","ADC Distribution CPV - Module 31", 100, 0, 2000);
+ TH1I * h31 = new TH1I("hCpvEdepM31","ADC Distribution CPV - Module 31;Amplitude [ADC counts];Counts", 100, 0, 2000);
h31->Sumw2();
Add2RawsList(h31, 31, !expert, image, !saveCorr);
- TH1I * h32 = new TH1I("hCpvEdepM32","ADC Distribution CPV - Module 32", 100, 0, 2000);
+ TH1I * h32 = new TH1I("hCpvEdepM32","ADC Distribution CPV - Module 32;Amplitude [ADC counts];Counts", 100, 0, 2000);
h32->Sumw2();
Add2RawsList(h32, 32, !expert, image, !saveCorr);
- TH1I * h33 = new TH1I("hCpvEdepM33","ADC Distribution CPV - Module 33", 100, 0, 2000);
+ TH1I * h33 = new TH1I("hCpvEdepM33","ADC Distribution CPV - Module 33;Amplitude [ADC counts];Counts", 100, 0, 2000);
h33->Sumw2();
Add2RawsList(h33, 33, !expert, image, !saveCorr);
- TH1I * h34 = new TH1I("hCpvEdepM34","ADC Distribution CPV - Module 34", 100, 0, 2000);
+ TH1I * h34 = new TH1I("hCpvEdepM34","ADC Distribution CPV - Module 34;Amplitude [ADC counts];Counts", 100, 0, 2000);
h34->Sumw2();
Add2RawsList(h34, 34, !expert, image, !saveCorr);
- TH1I * h35 = new TH1I("hCpvEdepM35","ADC Distribution CPV - Module 35", 100, 0, 2000);
+ TH1I * h35 = new TH1I("hCpvEdepM35","ADC Distribution CPV - Module 35;Amplitude [ADC counts];Counts", 100, 0, 2000);
h35->Sumw2();
Add2RawsList(h35, 35, !expert, image, !saveCorr);
- TH1I * h36 = new TH1I("hCpvEdepM36","ADC Distribution CPV - Module 36", 100, 0, 2000);
+ TH1I * h36 = new TH1I("hCpvEdepM36","ADC Distribution CPV - Module 36;Amplitude [ADC counts];Counts", 100, 0, 2000);
h36->Sumw2();
Add2RawsList(h36, 36, !expert, image, !saveCorr);
- TH1I * h37 = new TH1I("hCpvEdepM37","ADC Distribution CPV - Module 37", 100, 0, 2000);
+ TH1I * h37 = new TH1I("hCpvEdepM37","ADC Distribution CPV - Module 37;Amplitude [ADC counts];Counts", 100, 0, 2000);
h37->Sumw2();
Add2RawsList(h37, 37, !expert, image, !saveCorr);
- TH1I * h38 = new TH1I("hCpvEdepM38","ADC Distribution CPV - Module 38", 100, 0, 2000);
+ TH1I * h38 = new TH1I("hCpvEdepM38","ADC Distribution CPV - Module 38;Amplitude [ADC counts];Counts", 100, 0, 2000);
h38->Sumw2();
Add2RawsList(h38, 38, !expert, image, !saveCorr);
- TH1I * h39 = new TH1I("hCpvEdepM39","ADC Distribution CPV - Module 39", 100, 0, 2000);
+ TH1I * h39 = new TH1I("hCpvEdepM39","ADC Distribution CPV - Module 39;Amplitude [ADC counts];Counts", 100, 0, 2000);
h39->Sumw2();
Add2RawsList(h39, 39, !expert, image, !saveCorr);
- TH1I * h40 = new TH1I("hCpvEdepM40","ADC Distribution CPV - Module 40", 100, 0, 2000);
+ TH1I * h40 = new TH1I("hCpvEdepM40","ADC Distribution CPV - Module 40;Amplitude [ADC counts];Counts", 100, 0, 2000);
h40->Sumw2();
Add2RawsList(h40, 40, !expert, image, !saveCorr);
- TH1I * h41 = new TH1I("hCpvEdepM41","ADC Distribution CPV - Module 41", 100, 0, 2000);
+ TH1I * h41 = new TH1I("hCpvEdepM41","ADC Distribution CPV - Module 41;Amplitude [ADC counts];Counts", 100, 0, 2000);
h41->Sumw2();
Add2RawsList(h41, 41, !expert, image, !saveCorr);
- TH1I * h42 = new TH1I("hCpvEdepM42","ADC Distribution CPV - Module 42", 100, 0, 2000);
+ TH1I * h42 = new TH1I("hCpvEdepM42","ADC Distribution CPV - Module 42;Amplitude [ADC counts];Counts", 100, 0, 2000);
h42->Sumw2();
Add2RawsList(h42, 42, !expert, image, !saveCorr);
- TH1I * h43 = new TH1I("hCpvEdepM43","ADC Distribution CPV - Module 43", 100, 0, 2000);
+ TH1I * h43 = new TH1I("hCpvEdepM43","ADC Distribution CPV - Module 43;Amplitude [ADC counts];Counts", 100, 0, 2000);
h43->Sumw2();
Add2RawsList(h43, 43, !expert, image, !saveCorr);
- TH1I * h44 = new TH1I("hCpvEdepM44","ADC Distribution CPV - Module 44", 100, 0, 2000);
+ TH1I * h44 = new TH1I("hCpvEdepM44","ADC Distribution CPV - Module 44;Amplitude [ADC counts];Counts", 100, 0, 2000);
h44->Sumw2();
Add2RawsList(h44, 44, !expert, image, !saveCorr);
- TH1I * h45 = new TH1I("hCpvEdepM45","ADC Distribution CPV - Module 45", 100, 0, 2000);
+ TH1I * h45 = new TH1I("hCpvEdepM45","ADC Distribution CPV - Module 45;Amplitude [ADC counts];Counts", 100, 0, 2000);
h45->Sumw2();
Add2RawsList(h45, 45, !expert, image, !saveCorr);
- TH1I * h46 = new TH1I("hCpvEdepM46","ADC Distribution CPV - Module 46", 100, 0, 2000);
+ TH1I * h46 = new TH1I("hCpvEdepM46","ADC Distribution CPV - Module 46;Amplitude [ADC counts];Counts", 100, 0, 2000);
h46->Sumw2();
Add2RawsList(h46, 46, !expert, image, !saveCorr);
- TH1I * h47 = new TH1I("hCpvEdepM47","ADC Distribution CPV - Module 47", 100, 0, 2000);
+ TH1I * h47 = new TH1I("hCpvEdepM47","ADC Distribution CPV - Module 47;Amplitude [ADC counts];Counts", 100, 0, 2000);
h47->Sumw2();
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.);
+ TH2F * h48 = new TH2F("hPreXY","PRE plane;X [cm];Y [cm]",200,-100.,100.,200,-100.,100.);
Add2RawsList(h48, 48, !expert, !image, saveCorr);//Ajay
//Add2RawsList(h48, 48);//Ajay
- TH2F * h49 = new TH2F("hCpvXY","CPV plane",200,-100.,100.,200,-100.,100.);
+ TH2F * h49 = new TH2F("hCpvXY","CPV plane;X [cm];Y [cm]",200,-100.,100.,200,-100.,100.);
Add2RawsList(h49, 49, !expert, !image, saveCorr);//Ajay
//Add2RawsList(h49, 49);//Ajay
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F *h0 = new TH1F("hPreDigitsEdep","Digits energy distribution in PRE(PMD)", 100, 0., 2000.);
+ TH1F *h0 = new TH1F("hPreDigitsEdep","Digits energy distribution in PRE(PMD);Amplitude [ADC counts];Counts", 100, 0., 2000.);
h0->Sumw2();
Add2DigitsList(h0, 0, !expert, image);
- TH1F *h1 = new TH1F("hCpvDigitsEdep","Digits energy distribution in CPV(PMD)", 100, 0., 2000.);
+ TH1F *h1 = new TH1F("hCpvDigitsEdep","Digits energy distribution in CPV(PMD);Amplitude [ADC counts];Counts", 100, 0., 2000.);
h1->Sumw2();
Add2DigitsList(h1, 1, !expert, image);
- TH1I *h2 = new TH1I("hPreDigitsMult","Digits multiplicity distribution in PRE(PMD)", 500, 0, 1000) ;
+ TH1I *h2 = new TH1I("hPreDigitsMult","Digits multiplicity distribution in PRE(PMD);# of Digits;Entries", 500, 0, 1000) ;
h2->Sumw2();
Add2DigitsList(h2, 2, !expert, image);
- TH1I *h3 = new TH1I("hCpvDigitsMult","Digits multiplicity distribution in CPV(PMD)", 500, 0, 1000);
+ TH1I *h3 = new TH1I("hCpvDigitsMult","Digits multiplicity distribution in CPV(PMD);# of Digits;Entries", 500, 0, 1000);
h3->Sumw2();
- Add2DigitsList(h3, 3, !expert, image);
-
+ Add2DigitsList(h3, 3, !expert, image);
}
//____________________________________________________________________________
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F * h0 = new TH1F("hPreDdl0Ncell","PRE: Ddl0 Ncell in a cluster",50,0.,50.);
+ TH1F * h0 = new TH1F("hPreDdl0Ncell","PRE: Ddl0 Ncell in a cluster;# of cells;Counts",50,0.,50.);
h0->Sumw2();
Add2RecPointsList(h0, 0, !expert, image);
- TH1F * h1 = new TH1F("hPreDdl1Ncell","PRE: Ddl1 Ncell in a cluster",50,0.,50.);
+ TH1F * h1 = new TH1F("hPreDdl1Ncell","PRE: Ddl1 Ncell in a cluste;# of cells;Countsr",50,0.,50.);
h1->Sumw2();
Add2RecPointsList(h1, 1, !expert, image);
- TH1F * h2 = new TH1F("hPreDdl2Ncell","PRE: Ddl2 Ncell in a cluster",50,0.,50.);
+ TH1F * h2 = new TH1F("hPreDdl2Ncell","PRE: Ddl2 Ncell in a cluster;# of cells;Counts",50,0.,50.);
h2->Sumw2();
Add2RecPointsList(h2, 2, !expert, image);
- TH1F * h3 = new TH1F("hPreDdl3Ncell","PRE: Ddl3 Ncell in a cluster",50,0.,50.);
+ TH1F * h3 = new TH1F("hPreDdl3Ncell","PRE: Ddl3 Ncell in a cluster;# of cells;Counts",50,0.,50.);
h3->Sumw2();
Add2RecPointsList(h3, 3, !expert, image);
// CPV plane
- TH1F * h4 = new TH1F("hCpvDdl4Ncell","CPV: Ddl4 Ncell in a cluster",50,0.,50.);
+ TH1F * h4 = new TH1F("hCpvDdl4Ncell","CPV: Ddl4 Ncell in a cluster;# of cells;Counts",50,0.,50.);
h4->Sumw2();
Add2RecPointsList(h4, 4, !expert, image);
- TH1F * h5 = new TH1F("hCpvDdl5Ncell","CPV: Ddl5 Ncell in a cluster",50,0.,50.);
+ TH1F * h5 = new TH1F("hCpvDdl5Ncell","CPV: Ddl5 Ncell in a cluster;# of cells;Counts",50,0.,50.);
h5->Sumw2();
Add2RecPointsList(h5, 5, !expert, image);
// Correlation plot
- TH2I *h6 = new TH2I("hPre10","Cluster - DDL1 vs DDL0", 100,0,200,100,0,200);
+ TH2I *h6 = new TH2I("hPre10","Cluster - DDL1 vs DDL0;DDL0;DDL1", 100,0,200,100,0,200);
Add2RecPointsList(h6,6, !expert, image);
- TH2I *h7 = new TH2I("hPre32","Cluster - DDL3 vs DDL2", 100,0,200,100,0,200);
+ TH2I *h7 = new TH2I("hPre32","Cluster - DDL3 vs DDL2;DDL2;DDL3", 100,0,200,100,0,200);
Add2RecPointsList(h7,7, !expert, image);
- TH2I *h8 = new TH2I("hCpv54","Cluster - DDL5 vs DDL4", 100,0,200,100,0,200);
+ TH2I *h8 = new TH2I("hCpv54","Cluster - DDL5 vs DDL4;DDL4;DDL5", 100,0,200,100,0,200);
Add2RecPointsList(h8,8, !expert, image);
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F *h0 = new TH1F("hPreClADC","Cluster ADC of PRE plane",500,0.,10000.);
+ TH1F *h0 = new TH1F("hPreClADC","Cluster ADC of PRE plane;# of clusters;Counts",500,0.,10000.);
h0->Sumw2();
Add2ESDsList(h0, 0, !expert, image) ;
- TH1F *h1 = new TH1F("hCpvClADC","Cluster ADC of CPV plane",500,0.,10000.);
+ TH1F *h1 = new TH1F("hCpvClADC","Cluster ADC of CPV plane;# of clusters;Counts",500,0.,10000.);
h1->Sumw2();
Add2ESDsList(h1, 1, !expert, image) ;
- TH2I *h2 = new TH2I("hPmdClMult","Cluster Multiplicity: PRE vs. CPVplane",100,0,1000,100,0,1000);
+ TH2I *h2 = new TH2I("hPmdClMult","Cluster Multiplicity: PRE vs. CPVplane;CPV multiplicity;PRE Multiplicity",100,0,1000,100,0,1000);
h2->Sumw2();
Add2ESDsList(h2, 2, !expert, image) ;
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.);
+ TH1F *h0 = new TH1F("hPreHitsEdep","Hits energy distribution PRE(PMD);Energy [keV];Counts", 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.);
+ TH1F *h1 = new TH1F("hCpvHitsEdep","Hits energy distribution CPV(PMD);Energy [keV];Counts", 500, 0., 500.);
h1->Sumw2() ;
Add2HitsList(h1, 1, !expert, image) ;
- TH1I *h2 = new TH1I("hPreHitsMult","Hits multiplicity distribution in PRE(PMD)", 500, 0, 3000) ;
+ TH1I *h2 = new TH1I("hPreHitsMult","Hits multiplicity distribution in PRE(PMD);# of Hits;Entries", 500, 0, 3000) ;
h2->Sumw2() ;
Add2HitsList(h2, 2, !expert, image) ;
- TH1I *h3 = new TH1I("hCpvHitsMult","Hits multiplicity distribution in PRE(PMD)", 500, 0, 3000) ;
+ TH1I *h3 = new TH1I("hCpvHitsMult","Hits multiplicity distribution in PRE(PMD);# of Hits;Entries", 500, 0, 3000) ;
h2->Sumw2() ;
Add2HitsList(h3, 3, !expert, image) ;
}
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.);
+ TH1F *h0 = new TH1F("hPreSDigitsEdep","SDigits energy distribution in(keV) PRE(PMD);Energy [keV];Counts", 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.);
+ TH1F *h1 = new TH1F("hCpvSDigitsEdep","SDigits energy distribution in (keV)CPV(PMD);Energy [keV];Counts", 500, 0., 500.);
h1->Sumw2();
Add2SDigitsList(h1, 1, !expert, image);
- TH1I *h2 = new TH1I("hPreSDigitsMult","SDigits multiplicity distribution in PRE(PMD)", 500, 0., 1000.);
+ TH1I *h2 = new TH1I("hPreSDigitsMult","SDigits multiplicity distribution in PRE(PMD);# of SDigits;Entries", 500, 0., 1000.);
h2->Sumw2();
Add2SDigitsList(h2, 2, !expert, image);
- TH1I *h3 = new TH1I("hCpvSDigitsMult","SDigits multiplicity distribution in CPV(PMD)", 500, 0., 1000.);
+ TH1I *h3 = new TH1I("hCpvSDigitsMult","SDigits multiplicity distribution in CPV(PMD);# of SDigits;Entries", 500, 0., 1000.);
h3->Sumw2();
Add2SDigitsList(h3, 3, !expert, image);
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F *h0 = new TH1F("hPreDigitsEdep","Digits energy distribution in PRE(PMD)", 100, 0., 2000.);
+ TH1F *h0 = new TH1F("hPreDigitsEdep","Digits energy distribution in PRE(PMD);Amplitude [ADC counts];Counts", 100, 0., 2000.);
h0->Sumw2();
Add2DigitsList(h0, 0, !expert, image);
- TH1F *h1 = new TH1F("hCpvDigitsEdep","Digits energy distribution in CPV(PMD)", 100, 0., 2000.);
+ TH1F *h1 = new TH1F("hCpvDigitsEdep","Digits energy distribution in CPV(PMD);Amplitude [ADC counts];Counts", 100, 0., 2000.);
h1->Sumw2();
Add2DigitsList(h1, 1, !expert, image);
- TH1I *h2 = new TH1I("hPreDigitsMult","Digits multiplicity distribution in PRE(PMD)", 500, 0, 1000) ;
+ TH1I *h2 = new TH1I("hPreDigitsMult","Digits multiplicity distribution in PRE(PMD);# of Digits;Entries", 500, 0, 1000) ;
h2->Sumw2();
Add2DigitsList(h2, 2, !expert, image);
- TH1I *h3 = new TH1I("hCpvDigitsMult","Digits multiplicity distribution in CPV(PMD)", 500, 0, 1000);
+ TH1I *h3 = new TH1I("hCpvDigitsMult","Digits multiplicity distribution in CPV(PMD);# of Digits;Entries", 500, 0, 1000);
h3->Sumw2();
Add2DigitsList(h3, 3, !expert, image);
ampname += i;
qtcname += i;
ledname += i;
- fhRawCFD[i] = new TH1F(timename.Data(), timename.Data(),500,-250,250);
+ fhRawCFD[i] = new TH1F(timename.Data(), Form("%s;Time [ns];Counts", timename.Data()),500,-250,250);
Add2RawsList( fhRawCFD[i],i+1, !expert, image, !saveCorr);
- fhRawLED[i] = new TH1F(ledname.Data(), ledname.Data(),2000,-1000,1000);
+ fhRawLED[i] = new TH1F(ledname.Data(), Form("%s;Time [ns];Counts", ledname.Data()),2000,-1000,1000);
Add2RawsList( fhRawLED[i],i+24+1, !expert, image, !saveCorr);
- fhRawLEDamp[i] = new TH1F(ampname.Data(), ampname.Data(),100,300,600);
+ fhRawLEDamp[i] = new TH1F(ampname.Data(), Form("%s;Amplitude [ADC counts];Counts", ampname.Data()),100,300,600);
Add2RawsList( fhRawLEDamp[i],i+48+1, !expert, image, !saveCorr);
- fhRawQTC[i] = new TH1F(qtcname.Data(), qtcname.Data(),1500,1000,7000);
+ fhRawQTC[i] = new TH1F(qtcname.Data(), Form("%s;Charge [??];Counts", qtcname.Data()),1500,1000,7000);
Add2RawsList( fhRawQTC[i],i+72+1, !expert, image, !saveCorr);
}
- TH1F* fhRawTrigger = new TH1F("hRawTrigger"," phys triggers",5,0,5);
+ TH1F* fhRawTrigger = new TH1F("hRawTrigger"," phys triggers;Trigger #;Counts",5,0,5);
Add2RawsList(fhRawTrigger ,97, !expert, image, !saveCorr);
- TH1F* fhRawMean = new TH1F("hRawMean","online mean signal", 100,2400,2500);
+ TH1F* fhRawMean = new TH1F("hRawMean","online mean signal;??;??", 100,2400,2500);
Add2RawsList( fhRawMean,98, !expert, image, !saveCorr);
- TH1F* fhRawVertex = new TH1F("hRawVertex","online vertex signal", 100,0,600);
+ TH1F* fhRawVertex = new TH1F("hRawVertex","online vertex signal;??;??", 100,0,600);
Add2RawsList( fhRawVertex,99, !expert, image, !saveCorr);
- TH1F* fhRawORA = new TH1F("hRawORA","online OR A", 100,2500,2800);
+ TH1F* fhRawORA = new TH1F("hRawORA","online OR A;??;??", 100,2500,2800);
Add2RawsList( fhRawORA,100, !expert, image, !saveCorr);
- TH1F* fhRawORC = new TH1F("hRawORC","online OR C", 100,2000,2300);
+ TH1F* fhRawORC = new TH1F("hRawORC","online OR C;??;??", 100,2000,2300);
Add2RawsList( fhRawORC,101, !expert, image, !saveCorr);
for (Int_t i=0; i<24; i++)
ledCalname += i;
ampCalname += i;
qtcCalname += i;
- fhRawCFDcal[i] = new TH1F(timeCalname.Data(), timeCalname.Data(),2000,-1000,1000);
+ fhRawCFDcal[i] = new TH1F(timeCalname.Data(), Form("%s;Time [ns];Counts", timeCalname.Data()),2000,-1000,1000);
Add2RawsList( fhRawCFDcal[i],101+i+1, !expert, image, !saveCorr);
- fhRawLEDcal[i] = new TH1F(ledCalname.Data(), ledCalname.Data(),2000,-1000,1000);
+ fhRawLEDcal[i] = new TH1F(ledCalname.Data(), Form("%s;Time [ns];Counts", ledCalname.Data()),2000,-1000,1000);
Add2RawsList( fhRawLEDcal[i],101+i+24+1, !expert, image, !saveCorr);
- fhRawLEDampcal[i] = new TH1F(ampCalname.Data(), ampCalname.Data(),300,300,600);
+ fhRawLEDampcal[i] = new TH1F(ampCalname.Data(), Form("%s;Amplitude [ADC counts];Counts", ampCalname.Data()),300,300,600);
Add2RawsList( fhRawLEDampcal[i],101+i+48+1, !expert, image, !saveCorr);
- fhRawQTCcal[i] = new TH1F(qtcCalname.Data(), qtcCalname.Data(),1000,0,7000);
+ fhRawQTCcal[i] = new TH1F(qtcCalname.Data(), Form("%s;Charge [??];Counts",qtcCalname.Data()),1000,0,7000);
Add2RawsList( fhRawQTCcal[i],101+i+72+1, !expert, image, !saveCorr);
}
TH1F* fhRawTriggerCal = new TH1F("hRawTriggerCal"," laser triggers",6,0,6);
Add2RawsList(fhRawTriggerCal ,197 , !expert, !image, saveCorr);
- TH1F* fhRawMeanCal = new TH1F("hRawMeanCal","online mean signal, calibration event",
+ 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, !expert, image, !saveCorr);
- TH1F* fhRawORAcal = new TH1F("hRawORAcal","online OR A", 10000,0,10000);
+ TH1F* fhRawORAcal = new TH1F("hRawORAcal","online OR A;??;??", 10000,0,10000);
Add2RawsList( fhRawORAcal,200, !expert, image, !saveCorr );
- TH1F* fhRawORCcal = new TH1F("hRawORCcal","online OR C", 10000,0,10000);
+ TH1F* fhRawORCcal = new TH1F("hRawORCcal","online OR C;??;??", 10000,0,10000);
Add2RawsList( fhRawORCcal,201, !expert, image, !saveCorr);
- TH1F* fhMultcal = new TH1F("hMultcal","full mulltiplicity", 10000,0,10000);
+ TH1F* fhMultcal = new TH1F("hMultcal","full mulltiplicity;Multiplicity;Entries", 10000,0,10000);
Add2RawsList( fhMultcal,202, !expert, image, !saveCorr );
- TH1F* fhMultScal = new TH1F("hMultScal","full multiplicity with semi-central trigger",
+ TH1F* fhMultScal = new TH1F("hMultScal","full multiplicity with semi-central trigger;Multiplicity;Entries",
10000,0,10000);
Add2RawsList( fhMultScal,203, !expert, image, !saveCorr);
- TH1F* fhMultCcal = new TH1F("hMultCcal","full multiplicity with central trigger",
+ TH1F* fhMultCcal = new TH1F("hMultCcal","full multiplicity with central trigger;Multiplicity;Entries",
1000,0,10000);
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);
+ TH2F* fhEffCFD = new TH2F("hEffCFD"," CFD time;Time [ns];Counts",24, 0 ,24, 50, 0,5);
Add2RawsList( fhEffCFD,205, !expert, !image, saveCorr);
- TH2F* fhEffLED = new TH2F("hEffLED","LED time",24, 0 ,24,
+ TH2F* fhEffLED = new TH2F("hEffLED","LED time;Time [ns];Counts",24, 0 ,24,
100, 0, 5);
//100,-500,500);
Add2RawsList( fhEffLED,206, !expert, !image, saveCorr);
- TH2F* fhEffQTC = new TH2F("hEffQTC","QTC amplitude",24, 0 ,24,
+ TH2F* fhEffQTC = new TH2F("hEffQTC","QTC amplitude%s;Amplitude [ADC counts];Counts",24, 0 ,24,
100,0,7000);
Add2RawsList( fhEffQTC,207, !expert, !image, saveCorr);
//yeys guide line
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);
+ TH2F * fhDigCFD = new TH2F("fhDigCFD", " CFD digits;something;something else",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);
+ TH2F *fhDigLEDamp = new TH2F("fhDigLEDamp", " LED-CFD digits;something;something else",25,-0.5,24.5,100,100,1000);
Add2DigitsList( fhDigLEDamp,1, !expert, image);
- TH2F * fhDigQTC = new TH2F("fhDigQTC", " QTC digits",25,-0.5,24.5,100,100,1000);
- Add2DigitsList( fhDigQTC,2, !expert, image);
-
-
-
-}
+ TH2F * fhDigQTC = new TH2F("fhDigQTC", " QTC digits;something;something else",25,-0.5,24.5,100,100,1000);
+ Add2DigitsList( fhDigQTC,2, !expert, image);}
//____________________________________________________________________________
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH2F* fhRecCFD = new TH2F("hRecCFD"," CFD time",24, 0 ,24,
+ TH2F* fhRecCFD = new TH2F("hRecCFD"," CFD time;Time [ns];Counts",24, 0 ,24,
100,-50,50);
Add2RecPointsList ( fhRecCFD,0, !expert, image);
- TH2F* fhRecAmpDiff = new TH2F("hRecAmpDiff"," LED-CFD min QTC amplitude",
+ TH2F* fhRecAmpDiff = new TH2F("hRecAmpDiff"," LED-CFD min QTC amplitude;Amplitude [ADC counts];Counts",
24, 0 ,24, 200,-10,10);
Add2RecPointsList (fhRecAmpDiff, 1, !expert, image);
- TH1F *fhMean = new TH1F("hMean","online - rec mean",1000, -5000, 5000);
+ TH1F *fhMean = new TH1F("hMean","online - rec mean;??;??",1000, -5000, 5000);
Add2RecPointsList ( fhMean,2, !expert, image);
}
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F *fhESDMean = new TH1F("hESDmean"," ESD mean",100,2400,2500);
+ TH1F *fhESDMean = new TH1F("hESDmean"," ESD mean;??;??",100,2400,2500);
Add2ESDsList(fhESDMean, 0, !expert, image) ;
- TH1F * fhESDVertex = new TH1F("hESDvertex","ESD vertex",82,-30,30);
+ TH1F * fhESDVertex = new TH1F("hESDvertex","ESD vertex;??;??",82,-30,30);
Add2ESDsList(fhESDVertex, 1, !expert, image) ;
TString timename;
- TH2F *fhHitsTimeA = new TH2F("hHitsTimeA", "Hits Efficiency", 25, 0, 25, 100,12,15 );
+ TH2F *fhHitsTimeA = new TH2F("hHitsTimeA", "Hits Efficiency;Time [ns];Efficiency [%]", 25, 0, 25, 100,12,15 );
Add2HitsList(fhHitsTimeA,0, !expert, image);
- TH2F *fhHitsTimeC = new TH2F("hHitsTimeC", "Hits Efficiency", 25, 0, 25, 100,2,5 );
+ TH2F *fhHitsTimeC = new TH2F("hHitsTimeC", "Hits Efficiency;Time [ns];Efficiency [%]", 25, 0, 25, 100,2,5 );
Add2HitsList(fhHitsTimeC,1, !expert, image);
}
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);
+ TH2F * fhDigCFD = new TH2F("fhDigCFD", " CFD digits;something;something else",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);
+ TH2F *fhDigLEDamp = new TH2F("fhDigLEDamp", " LED-CFD digits;something;something else",25,-0.5,24.5,100,100,1000);
Add2DigitsList( fhDigLEDamp,1, !expert, image);
- TH2F * fhDigQTC = new TH2F("fhDigQTC", " QTC digits",25,-0.5,24.5,100,100,1000);
+ TH2F * fhDigQTC = new TH2F("fhDigQTC", " QTC digits;something;something else",25,-0.5,24.5,100,100,1000);
Add2DigitsList( fhDigQTC,2, !expert, image);
const Bool_t saveCorr = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F * h0 = new TH1F("hTOFRaws", "Number of TOF Raws ",301, -1.02, 5.) ;
+ TH1F * h0 = new TH1F("hTOFRaws", "Number of TOF Raws;TOF raw number [10 power];Counts ",301, -1.02, 5.) ;
h0->Sumw2() ;
- h0->GetXaxis()->SetTitle("TOF raw number [10 power]");
Add2RawsList(h0, 0, !expert, image, !saveCorr) ;
- TH1F * h1 = new TH1F("hTOFRawsTime", "Raws Time Spectrum in TOF (ns)", 2000, 0., 200) ;
+ TH1F * h1 = new TH1F("hTOFRawsTime", "Raws Time Spectrum in TOF (ns);Measured TOF time [ns];Counts", 2000, 0., 200) ;
h1->Sumw2() ;
- h1->GetXaxis()->SetTitle("Measured TOF time [ns]");
Add2RawsList(h1, 1, !expert, image, !saveCorr) ;
- TH1F * h2 = new TH1F("hTOFRawsToT", "Raws ToT Spectrum in TOF (ns)", 500, 0., 50) ;
+ TH1F * h2 = new TH1F("hTOFRawsToT", "Raws ToT Spectrum in TOF (ns);Measured TOT time [ns];Counts", 500, 0., 50) ;
h2->Sumw2() ;
- h2->GetXaxis()->SetTitle("Measured TOT [ns]");
- h2->GetYaxis()->SetTitle("Measured TOF time [ns]");
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) ;
+ TH2F * h3 = new TH2F("hTOFRawsClusMap","Raws vs TOF eta-phi;2*strip+padz (eta);48*sector+padx (phi)",183, -0.5, 182.5,865,-0.5,864.5) ;
h3->Sumw2() ;
- h3->GetXaxis()->SetTitle("2*strip+padz (eta)");
- h3->GetYaxis()->SetTitle("48*sector+padx (phi)");
h3->GetYaxis()->SetTitleOffset(1.15);
Add2RawsList(h3, 3, !expert, image, !saveCorr) ;
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F * h0 = new TH1F("hTOFDigits", "Number of TOF Digits ",301, -1.02, 5.) ;
+ TH1F * h0 = new TH1F("hTOFDigits", "Number of TOF Digits;TOF digit number [10 power];Counts ",301, -1.02, 5.) ;
h0->Sumw2() ;
- h0->GetXaxis()->SetTitle("TOF digit number [10 power]");
Add2DigitsList(h0, 0, !expert, image) ;
- TH1F * h1 = new TH1F("hTOFDigitsTime", "Digits Time Spectrum in TOF (ns)", 2000, 0., 200) ;
+ TH1F * h1 = new TH1F("hTOFDigitsTime", "Digits Time Spectrum in TOF (ns);Digitized TOF time [ns];Counts", 2000, 0., 200) ;
h1->Sumw2() ;
- h1->GetXaxis()->SetTitle("Digitized TOF time [ns]");
Add2DigitsList(h1, 1, !expert, image) ;
- TH1F * h2 = new TH1F("hTOFDigitsToT", "Digits ToT Spectrum in TOF (ns)", 500, 0., 50) ;
+ TH1F * h2 = new TH1F("hTOFDigitsToT", "Digits ToT Spectrum in TOF (ns);Digitized TOF time [ns];Counts", 500, 0., 50) ;
h2->Sumw2() ;
- h2->GetYaxis()->SetTitle("Digitized TOF time [ns]");
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) ;
+ TH2F * h3 = new TH2F("hTOFDigitsClusMap","Digits vs TOF eta-phi;2*strip+padz (eta);48*sector+padx (phi)",183, -0.5, 182.5,865,-0.5,864.5) ;
h3->Sumw2() ;
- h3->GetXaxis()->SetTitle("2*strip+padz (eta)");
- h3->GetYaxis()->SetTitle("48*sector+padx (phi)");
h3->GetYaxis()->SetTitleOffset(1.15);
Add2DigitsList(h3, 3, !expert, image) ;
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F * h0 = new TH1F("hTOFRecPoints", "Number of TOF RecPoints ",301, -1.02, 5.) ;
+ TH1F * h0 = new TH1F("hTOFRecPoints", "Number of TOF RecPoints;TOF recPoint number [10 power];Counts",301, -1.02, 5.) ;
h0->Sumw2() ;
- h0->GetXaxis()->SetTitle("TOF recPoint number [10 power]");
Add2RecPointsList(h0, 0, !expert, image) ;
- TH1F * h1 = new TH1F("hTOFRecPointsTime", "RecPoints Time Spectrum in TOF (ns)", 2000, 0., 200) ;
+ TH1F * h1 = new TH1F("hTOFRecPointsTime", "RecPoints Time Spectrum in TOF (ns);Calibrated TOF time [ns];Counts", 2000, 0., 200) ;
h1->Sumw2() ;
- h1->GetXaxis()->SetTitle("Calibrated TOF time [ns]");
Add2RecPointsList(h1, 1, !expert, image) ;
- TH1F * h2 = new TH1F("hTOFRecPointsRawTime", "RecPoints raw Time Spectrum in TOF (ns)", 2000, 0., 200) ;
+ TH1F * h2 = new TH1F("hTOFRecPointsRawTime", "RecPoints raw Time Spectrum in TOF (ns);Measured TOF time [ns];Counts", 2000, 0., 200) ;
h2->Sumw2() ;
- h2->GetXaxis()->SetTitle("Measured TOT [ns]");
- h2->GetYaxis()->SetTitle("Measured TOF time [ns]");
Add2RecPointsList(h2, 2, !expert, image) ;
- TH1F * h3 = new TH1F("hTOFRecPointsToT", "RecPoints ToT Spectrum in TOF (ns)", 500, 0., 50) ;
+ TH1F * h3 = new TH1F("hTOFRecPointsToT", "RecPoints ToT Spectrum in TOF (ns);Measured TOT [ns];Counts", 500, 0., 50) ;
h3->Sumw2() ;
- h3->GetXaxis()->SetTitle("Measured TOT [ns]");
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) ;
+ TH2F * h4 = new TH2F("hTOFRecPointsClusMap","RecPoints vs TOF phi-eta;2*strip+padz (eta);48*sector+padx (phi)",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)");
h4->GetYaxis()->SetTitleOffset(1.15);
Add2RecPointsList(h4, 4, !expert, image) ;
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.) ;
+ TH1F * h0 = new TH1F("hTOFESDs", "Number of matched TOF tracks over ESDs;Number of TOF matched ESD tracks [10 power];Counts", 250, -1., 4.) ;
h0->Sumw2() ;
- h0->GetXaxis()->SetTitle("Number of TOF matched ESD tracks [10 power]");
Add2ESDsList(h0, 0, !expert, image) ;
- TH1F * h1 = new TH1F("hTOFESDsTime", "Time Spectrum in TOF (ns)", 2000, 0., 200) ;
+ TH1F * h1 = new TH1F("hTOFESDsTime", "Time Spectrum in TOF (ns);Calibrated TOF time [ns];Counts", 2000, 0., 200) ;
h1->Sumw2() ;
- h1->GetXaxis()->SetTitle("Calibrated TOF time [ns]");
Add2ESDsList(h1, 1, !expert, image) ;
- TH1F * h2 = new TH1F("hTOFESDsRawTime", "raw Time Spectrum in TOF (ns)", 2000, 0., 200) ;
+ TH1F * h2 = new TH1F("hTOFESDsRawTime", "raw Time Spectrum in TOF (ns);Measured TOF time [ns];Counts", 2000, 0., 200) ;
h2->Sumw2() ;
- h2->GetXaxis()->SetTitle("Measured TOF time [ns]");
Add2ESDsList(h2, 2, !expert, image) ;
- TH1F * h3 = new TH1F("hTOFESDsToT", "ToT Spectrum in TOF (ns)", 500, 0., 50) ;
+ TH1F * h3 = new TH1F("hTOFESDsToT", "ToT Spectrum in TOF (ns);Measured TOF time [ns];Counts", 500, 0., 50) ;
h3->Sumw2() ;
- h3->GetXaxis()->SetTitle("Measured TOT [ns]");
Add2ESDsList(h3, 3, !expert, image) ;
- TH1F * h4 = new TH1F("hTOFESDsPID", "Fraction of matched TOF tracks with good PID flag (%)", 101, 0., 101.) ;
+ TH1F * h4 = new TH1F("hTOFESDsPID", "Fraction of matched TOF tracks with good PID flag (%);Fraction of TOF matched ESD tracks with good flag [%];Counts", 101, 0., 101.) ;
h4->Sumw2() ;
- h4->GetXaxis()->SetTitle("Fraction of TOF matched ESD tracks with good flag [%]");
Add2ESDsList(h4, 4, !expert, image) ;
}
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F * h0 = new TH1F("hTOFHits", "Number of TOF Hits ",301, -1.02, 5.) ;
+ TH1F * h0 = new TH1F("hTOFHits", "Number of TOF Hits;TOF hit number [10 power];Counts ",301, -1.02, 5.) ;
h0->Sumw2() ;
- h0->GetXaxis()->SetTitle("TOF hit number [10 power]");
Add2HitsList(h0, 0, !expert, image) ;
- TH1F * h1 = new TH1F("hTOFHitsTime", "Hits Time Spectrum in TOF (ns)", 2000, 0., 200) ;
+ TH1F * h1 = new TH1F("hTOFHitsTime", "Hits Time Spectrum in TOF (ns);Simulated TOF time [ns];Counts", 2000, 0., 200) ;
h1->Sumw2() ;
- h1->GetXaxis()->SetTitle("Simulated TOF time [ns]");
Add2HitsList(h1, 1, !expert, image) ;
- TH1F * h2 = new TH1F("hTOFHitsLength", "Length Spectrum in TOF (cm)", 500, 0., 500) ;
+ TH1F * h2 = new TH1F("hTOFHitsLength", "Length Spectrum in TOF (cm);Track length from primary vertex till hit TOF pad [cm];Counts", 500, 0., 500) ;
h2->Sumw2() ;
- h2->GetXaxis()->SetTitle("Track length from primary vertex till hit TOF pad [cm]");
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) ;
+ TH2F * h3 = new TH2F("hTOFHitsClusMap","Hits vs TOF eta-phi;2*strip+padz (eta);48*sector+padx (phi)",183, -0.5, 182.5,865,-0.5,864.5) ;
h3->Sumw2() ;
- h3->GetXaxis()->SetTitle("2*strip+padz (eta)");
- h3->GetYaxis()->SetTitle("48*sector+padx (phi)");
h3->GetYaxis()->SetTitleOffset(1.15);
Add2HitsList(h3, 3, !expert, image) ;
}
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F * h0 = new TH1F("hTOFDigits", "Number of TOF Digits ",301, -1.02, 5.) ;
+ TH1F * h0 = new TH1F("hTOFDigits", "Number of TOF Digit;TOF digit number [10 power];Counts ",301, -1.02, 5.) ;
h0->Sumw2() ;
- h0->GetXaxis()->SetTitle("TOF digit number [10 power]");
Add2DigitsList(h0, 0, !expert, image) ;
- TH1F * h1 = new TH1F("hTOFDigitsTime", "Digits Time Spectrum in TOF (ns)", 2000, 0., 200) ;
+ TH1F * h1 = new TH1F("hTOFDigitsTime", "Digits Time Spectrum in TOF (ns);Digitized TOF time [ns];Counts", 2000, 0., 200) ;
h1->Sumw2() ;
- h1->GetXaxis()->SetTitle("Digitized TOF time [ns]");
Add2DigitsList(h1, 1, !expert, image) ;
- TH1F * h2 = new TH1F("hTOFDigitsToT", "Digits ToT Spectrum in TOF (ns)", 500, 0., 50) ;
+ TH1F * h2 = new TH1F("hTOFDigitsToT", "Digits ToT Spectrum in TOF (ns);Digitized TOF time [ns];Counts", 500, 0., 50) ;
h2->Sumw2() ;
- h2->GetYaxis()->SetTitle("Digitized TOF time [ns]");
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) ;
+ TH2F * h3 = new TH2F("hTOFDigitsClusMap","Digits vs TOF eta-phi;2*strip+padz (eta);48*sector+padx (phi)",183, -0.5, 182.5,865,-0.5,864.5) ;
h3->Sumw2() ;
- h3->GetXaxis()->SetTitle("2*strip+padz (eta)");
- h3->GetYaxis()->SetTitle("48*sector+padx (phi)");
h3->GetYaxis()->SetTitleOffset(1.15);
Add2DigitsList(h3, 3, !expert, image) ;
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1F * h0 = new TH1F("hTOFSDigits", "Number of TOF SDigits ",301, -1.02, 5.) ;
+ TH1F * h0 = new TH1F("hTOFSDigits", "Number of TOF SDigits;TOF sdigit number [10 power];Counts ",301, -1.02, 5.) ;
h0->Sumw2() ;
- h0->GetXaxis()->SetTitle("TOF sdigit number [10 power]");
Add2SDigitsList(h0, 0, !expert, image) ;
- TH1F * h1 = new TH1F("hTOFSDigitsTime", "SDigits Time Spectrum in TOF (ns)", 2000, 0., 200) ;
+ TH1F * h1 = new TH1F("hTOFSDigitsTime", "SDigits Time Spectrum in TOF (ns);SDigitized TOF time [ns];Counts", 2000, 0., 200) ;
h1->Sumw2() ;
- h1->GetXaxis()->SetTitle("SDigitized TOF time [ns]");
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) ;
+ TH2F * h2 = new TH2F("hTOFSDigitsClusMap","SDigits vs TOF eta-phi;2*strip+padz (eta);48*sector+padx (phi)",183, -0.5, 182.5,865,-0.5,864.5) ;
h2->Sumw2() ;
- h2->GetXaxis()->SetTitle("2*strip+padz (eta)");
- h2->GetYaxis()->SetTitle("48*sector+padx (phi)");
h2->GetYaxis()->SetTitleOffset(1.15);
Add2SDigitsList(h2, 2, !expert, image) ;
TH1 *hist[kNhist];
Int_t histoCounter = -1 ;
- hist[++histoCounter] = new TH1D("qaTRD_esd_ntracks", ";Number of tracks", 300, -0.5, 299.5);
- hist[++histoCounter] = new TH1D("qaTRD_esd_sector", ";Sector", 18, -0.5, 17.7);
- hist[++histoCounter] = new TH1D("qaTRD_esd_bits", ";Bits", 64, -0.5, 63.5);
+ hist[++histoCounter] = new TH1D("qaTRD_esd_ntracks", "TRD esd ntracks;Number of tracks;Counts", 300, -0.5, 299.5);
+ hist[++histoCounter] = new TH1D("qaTRD_esd_sector", "TRD esd sector;Sector;Counts", 18, -0.5, 17.7);
+ hist[++histoCounter] = new TH1D("qaTRD_esd_bits", "TRD esd bits;Bits;Counts", 64, -0.5, 63.5);
const Int_t knbits = 6;
const char *suf[knbits] = {"TPCi", "TPCo", "TPCz", "TRDo", "TRDr", "TRDz"};
// histo = 3
for(Int_t i=0; i<knbits; i++) {
- hist[++histoCounter] = new TH1D(Form("qaTRD_esd_pt%s",suf[i]), ";p_{T} (GeV/c);", 100, 0, 10);
+ hist[++histoCounter] = new TH1D(Form("qaTRD_esd_pt%s",suf[i]), Form("qaTRD_esd_pt%s;p_{T} (GeV/c);Counts",suf[i]), 100, 0, 10);
hist[++histoCounter] = new TH1D(Form("qaTRD_esd_trdz%s", suf[i]), ";z (cm)", 200, -400, 400);
}
- hist[++histoCounter] = new TH1D("qaTRD_esd_clsTRDo", "TRDo;number of clusters", 180, -0.5, 179.5);;
- hist[++histoCounter] = new TH1D("qaTRD_esd_clsTRDr", "TRDr;number of clusters", 180, -0.5, 179.5);;
- hist[++histoCounter] = new TH1D("qaTRD_esd_clsTRDz", "TRDz;number of clusters", 180, -0.5, 179.5);;
+ hist[++histoCounter] = new TH1D("qaTRD_esd_clsTRDo", "TRDo;number of clusters;Counts", 180, -0.5, 179.5);;
+ hist[++histoCounter] = new TH1D("qaTRD_esd_clsTRDr", "TRDr;number of clusters;Counts", 180, -0.5, 179.5);;
+ hist[++histoCounter] = new TH1D("qaTRD_esd_clsTRDz", "TRDz;number of clusters;Counts", 180, -0.5, 179.5);;
//hist[++histoCounter] = new TH1D("qaTRD_esd_clsRatio", ";cluster ratio", 100, 0., 1.3);;
- hist[++histoCounter] = new TH2D("qaTRD_esd_sigMom", ";momentum (GeV/c);signal", 100, 0, 5, 200, 0, 1e3);
+ hist[++histoCounter] = new TH2D("qaTRD_esd_sigMom", "TRD esd sig Mom;momentum (GeV/c);signal", 100, 0, 5, 200, 0, 1e3);
// end of cycle plots (hist 19)
const char *sufRatio[4] = {"TRDrTRDo", "TRDoTPCo", "TRDrTPCo", "TRDzTPCo"};
}
// 27 - 31
- hist[27] = new TH1D("qaTRD_esd_quality", ";quality", 120, 0, 12);
- hist[28] = new TH1D("qaTRD_esd_budget", ";NN", 110, -1000, 100);
- hist[29] = new TH1D("qaTRD_esd_chi2", ";chi2", 200, 0, 100);
- hist[30] = new TH1D("qaTRD_esd_timeBin", ";time bin", 7, -0.5, 6.5);
- hist[31] = new TH1D("qaTRD_esd_pidQuality", "pid Quality", 7, -0.5, 6.5);
+ hist[27] = new TH1D("qaTRD_esd_quality", "TRD esd quality;quality;Counts", 120, 0, 12);
+ hist[28] = new TH1D("qaTRD_esd_budget", "TRD esd budget;NN;Counts", 110, -1000, 100);
+ hist[29] = new TH1D("qaTRD_esd_chi2", "TRD esd chi2;chi2;Counts", 200, 0, 100);
+ hist[30] = new TH1D("qaTRD_esd_timeBin", "TRD esd timeBin;time bin;Counts", 7, -0.5, 6.5);
+ hist[31] = new TH1D("qaTRD_esd_pidQuality", "pid Quality;quality;;Counts", 7, -0.5, 6.5);
// stack by stack electron identyfication
- hist[32] = new TH1D("qaTRD_esd_tracksStack", "number of all tracks;stack", 90, -0.5, 89.5);
- hist[33] = new TH1D("qaTRD_esd_electronStack", "number of electron tracks;stack", 90, -0.5, 89.5);
- hist[34] = new TH1D("qaTRD_esd_elRatioStack", "fraction of electron tracks;stack", 90, -0.5, 89.5);
+ hist[32] = new TH1D("qaTRD_esd_tracksStack", "number of all tracks;stack;Counts", 90, -0.5, 89.5);
+ hist[33] = new TH1D("qaTRD_esd_electronStack", "number of electron tracks;stack;Counts", 90, -0.5, 89.5);
+ hist[34] = new TH1D("qaTRD_esd_elRatioStack", "fraction of electron tracks;stack;Counts", 90, -0.5, 89.5);
hist[35] = new TH1D("qaTRD_esd_thetaOut", ";tan(theta);", 100, -1, 1);
const char *partType[5] = {"Electron", "Muon", "Pion", "Kaon", "Proton"};
for(Int_t i=0; i<AliPID::kSPECIES; i++)
hist[36+i] = new TH1D(Form("qaTRD_esd_pid%d",i),
- Form("%s;probability",partType[i]), 100, 0, 1);
+ Form("%s;probability;Counts",partType[i]), 100, 0, 1);
// dE/dX vs momentum in three regions
const char *zoneName[4] = {"total charge", "ampilification range", "plateau", "TR range"};
for(Int_t i=0; i<4; i++) {
hist[41+i] = new TH2D(Form("qaTRD_esd_signalPzone_%d",i),
- Form("%s;momentum (GeV/c);singal (a.u.)", zoneName[i]),
+ Form("%s;momentum (GeV/c);signal (a.u.)", zoneName[i]),
nscalex, scalex, nscaley, scaley);
}
const Int_t kNhist = 14 + 4 * 18 + 2 + 9;// + 540;
TH1 *hist[kNhist];
- hist[0] = new TH1D("qaTRD_recPoints_det", ";Detector ID of the cluster", 540, -0.5, 539.5);
- hist[1] = new TH2D("qaTRD_recPoints_amp", ";Amplitude", 540, -0.5, 539, 200, -0.5, 199.5);
- hist[2] = new TH1D("qaTRD_recPoints_npad", ";Number of Pads", 12, -0.5, 11.5);
+ hist[0] = new TH1D("qaTRD_recPoints_det", "RRD recPoints det;Detector ID of the cluster;Counts", 540, -0.5, 539.5);
+ hist[1] = new TH2D("qaTRD_recPoints_amp", "TRD recPoints amp;Amplitude;??", 540, -0.5, 539, 200, -0.5, 199.5);
+ hist[2] = new TH1D("qaTRD_recPoints_npad", "TRD recPoints npad;Number of Pads;Counts", 12, -0.5, 11.5);
- hist[3] = new TH1D("qaTRD_recPoints_dist2", ";residuals [2pad]", 100, -1, 1);
- hist[4] = new TH1D("qaTRD_recPoints_dist3", ";residuals [3pad]", 100, -1, 1);
- hist[5] = new TH1D("qaTRD_recPoints_dist4", ";residuals [4pad]", 100, -1, 1);
- hist[6] = new TH1D("qaTRD_recPoints_dist5", ";residuals [5pad]", 100, -1, 1);
+ hist[3] = new TH1D("qaTRD_recPoints_dist2", "TRD recPoints dist2;residuals [2pad];Counts", 100, -1, 1);
+ hist[4] = new TH1D("qaTRD_recPoints_dist3", "TRD recPoints dist3;residuals [3pad];Counts", 100, -1, 1);
+ hist[5] = new TH1D("qaTRD_recPoints_dist4", "TRD recPoints dist4;residuals [4pad];Counts", 100, -1, 1);
+ hist[6] = new TH1D("qaTRD_recPoints_dist5", "TRD recPoints dist5;residuals [5pad];Counts", 100, -1, 1);
- hist[7] = new TH2D("qaTRD_recPoints_rowCol", ";row;col", 16, -0.5, 15.5, 145, -0.5, 144.5);
- hist[8] = new TH1D("qaTRD_recPoints_time", ";time bin", kTimeBin, -0.5, kTimeBin-0.5);
- hist[9] = new TH1D("qaTRD_recPoints_nCls", ";number of clusters", 500, -0.5, 499.5);
+ hist[7] = new TH2D("qaTRD_recPoints_rowCol", "TRDrecPointsrowCol;row;col", 16, -0.5, 15.5, 145, -0.5, 144.5);
+ hist[8] = new TH1D("qaTRD_recPoints_time", "TRDrecPoints time;time bin;Counts", kTimeBin, -0.5, kTimeBin-0.5);
+ hist[9] = new TH1D("qaTRD_recPoints_nCls", "TRD recPoints nCls;number of clusters;Counts", 500, -0.5, 499.5);
- hist[10] = new TH3D("qaTRD_recPoints_sigTime", ";chamber;time bin;signal",
+ hist[10] = new TH3D("qaTRD_recPoints_sigTime", "TRD recPoints sigTime;chamber;time bin;signal",
540, -0.5, 539.5, kTimeBin, -0.5, kTimeBin-0.5, 200, -0.5, 199.5);
- hist[11] = new TProfile("qaTRD_recPoints_prf", ";distance;center of gravity"
+ hist[11] = new TProfile("qaTRD_recPoints_prf", "TRD recPoints prf;distance;center of gravity;Counts"
, 120, -0.6, 0.6, -1.2, 1.2, "");
- hist[12] = new TH1D("qaTRD_recPoints_ampMPV", ";amplitude MPV", 150, 0, 150);
- hist[13] = new TH1D("qaTRD_recPoints_ampSigma", ";amplitude Sigma", 200, 0, 200);
+ hist[12] = new TH1D("qaTRD_recPoints_ampMPV", "TRD recPoints ampMPV;amplitude MPV;Counts", 150, 0, 150);
+ hist[13] = new TH1D("qaTRD_recPoints_ampSigma", "TRD recPoints ampSigma;amplitude Sigma;Counts", 200, 0, 200);
// chamber by chamber
for(Int_t i=0; i<18; i++) {
kTimeBin, -0.5, kTimeBin-0.5);
}
- hist[86] = new TH1D("qaTRD_recPoints_signal", ";amplitude", 400, -0.5, 399.5);
- hist[87] = new TH2D("qaTRD_recPoints_detMap", ";sm;chamber", 18, -0.5, 17.5, 30, -0.5, 29.5);
+ hist[86] = new TH1D("qaTRD_recPoints_signal", "TRD recPoints signal;amplitude;Counts", 400, -0.5, 399.5);
+ hist[87] = new TH2D("qaTRD_recPoints_detMap", "TRD recPoints detMap;sm;chamber;Counts", 18, -0.5, 17.5, 30, -0.5, 29.5);
// amplitude as a function of the pad size
for(Int_t i=0; i<9; i++) {
- hist[88+i] = new TH1D(Form("qaTRD_recPoints_signalNpad_%d", i+2), ";amplitude, ADC", 400, -0.5, 399.5);
+ hist[88+i] = new TH1D(Form("qaTRD_recPoints_signalNpad_%d", i+2), Form("qaTRD_recPoints_signalNpad_%d;amplitude, ADC", i+2), 400, -0.5, 399.5);
}
// one 2D histogram per chamber
18, -0.5, 17.5, 60, -0.5, 59.5);
}
- hist[3] = new TH1D("qaTRD_raws_errorHC", ";error ID;", 18, -3.5, 14.5);
- hist[4] = new TH1D("qaTRD_raws_errorMCM", ";error ID;", 18, -3.5, 14.5);
- hist[5] = new TH1D("qaTRD_raws_errorADC", ";error ID;", 18, -3.5, 14.5);
+ hist[3] = new TH1D("qaTRD_raws_errorHC", "TRD raws error HC;error ID;Counts", 18, -3.5, 14.5);
+ hist[4] = new TH1D("qaTRD_raws_errorMCM", "TRD raws error MCM;error ID;Counts", 18, -3.5, 14.5);
+ hist[5] = new TH1D("qaTRD_raws_errorADC", "TRD raws errorADC;error ID;Counts", 18, -3.5, 14.5);
/*
// four histograms to be published
const Int_t kNhist = 4;
TH1D *hist[kNhist];
- hist[0] = new TH1D("qaTRD_hits_det", ";Detector Id of the hit", 540, -0.5, 539.5) ;
+ hist[0] = new TH1D("qaTRD_hits_det", "TRD hits det;Detector Id of the hit;Counts", 540, -0.5, 539.5) ;
- hist[1] = new TH1D("qaTRD_hist_Qdrift", ";Charge from tracks", 100, 0, 100);
- hist[2] = new TH1D("qaTRD_hist_Qamp", ";Charge from TRD photon", 100, 0, 100);
- hist[3] = new TH1D("qaTRD_hist_Qphoton", ";Charge from TRD photon", 100, 0, 100);
+ hist[1] = new TH1D("qaTRD_hist_Qdrift", "TRD hits Qdrift;Charge from tracks;Counts", 100, 0, 100);
+ hist[2] = new TH1D("qaTRD_hist_Qamp", "TRD hits Qamp;Charge from TRD photon;Counts", 100, 0, 100);
+ hist[3] = new TH1D("qaTRD_hist_Qphoton", "TRD hits Qphoton;Charge from TRD photon;Counts", 100, 0, 100);
for(Int_t i=0; i<kNhist; i++) {
//hist[i]->Sumw2();
const Int_t kNhist = 3;
TH1D *hist[kNhist];
- hist[0] = new TH1D("qaTRD_digits_det", ";Detector Id of the digit", 540, -0.5, 539.5);
- hist[1] = new TH1D("qaTRD_digits_time", ";Time bin", 40, -0.5, 39.5);
- hist[2] = new TH1D("qaTRD_digits_amp", ";Amplitude", 100, -5.5, 94.5);
+ hist[0] = new TH1D("qaTRD_digits_det", "TRD digits det;Detector Id of the digit;Counts", 540, -0.5, 539.5);
+ hist[1] = new TH1D("qaTRD_digits_time", "TRDdigits time;Time bin;Counts", 40, -0.5, 39.5);
+ hist[2] = new TH1D("qaTRD_digits_amp", "TRD digits amp;Amplitude;Counts", 100, -5.5, 94.5);
for(Int_t i=0; i<kNhist; i++) {
hist[i]->Sumw2();
const Int_t kNhist = 3;
TH1D *hist[kNhist];
- hist[0] = new TH1D("qaTRD_sdigits_det", ";Detector Id of the digit", 540, -0.5, 539.5);
- hist[1] = new TH1D("qaTRD_sdigits_time", ";Time bin", 40, -0.5, 39.5);
- hist[2] = new TH1D("qaTRD_sdigits_amp", ";Amplitude", 100, 0, 1e7);
+ hist[0] = new TH1D("qaTRD_sdigits_det", "TRD sdigits det;Detector Id of the digit;Counts", 540, -0.5, 539.5);
+ hist[1] = new TH1D("qaTRD_sdigits_time", "TRD sdigits time;Time bin;Counts", 40, -0.5, 39.5);
+ hist[2] = new TH1D("qaTRD_sdigits_amp", "TRD sdigits amp;Amplitude;Counts", 100, 0, 1e7);
for(Int_t i=0; i<kNhist; i++) {
hist[i]->Sumw2();
TH1I * h1i;
TH1D * h1d;
- h1i = new TH1I("H1I_Cell_Multiplicity_V0A", "Cell Multiplicity in V0A", 35, 0, 35) ;
- h1i->GetXaxis()->SetTitle("Multiplicity (Nb of Cell)");
+ h1i = new TH1I("H1I_Cell_Multiplicity_V0A", "Cell Multiplicity in V0A;Multiplicity (Nb of Cell);Counts", 35, 0, 35) ;
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)");
+ h1i = new TH1I("H1I_Cell_Multiplicity_V0C", "Cell Multiplicity in V0;Multiplicity (Nb of Cell);Counts", 35, 0, 35) ;
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)");
+ h1d = new TH1D("H1D_MIP_Multiplicity_V0A", "MIP Multiplicity in V0A;Multiplicity (Nb of MIP);Counts", 1000, 0, 1000) ;
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)");
+ h1d = new TH1D("H1D_MIP_Multiplicity_V0C", "MIP Multiplicity in V0C;Multiplicity (Nb of MIP);Counts", 1000, 0, 1000) ;
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)");
+ h2d = new TH2D("H2D_MIP_Multiplicity_Channel", "MIP Multiplicity per Channel;Channel;Multiplicity (Nb of MIP)",64, 0, 64, 100, 0, 100) ;
Add2ESDsList(h2d, kMIPMultiChannel, !expert, image) ;
- h1d = new TH1D("H1D_BBFlag_Counters", "BB Flag Counters",64, 0, 64) ;
- h1d->GetXaxis()->SetTitle("Channel");
+ h1d = new TH1D("H1D_BBFlag_Counters", "BB Flag Counters;Channel;Counts",64, 0, 64) ;
Add2ESDsList(h1d, kBBFlag, !expert, image) ;
- h1d = new TH1D("H1D_BGFlag_Counters", "BG Flag Counters",64, 0, 64) ;
- h1d->GetXaxis()->SetTitle("Channel");
+ h1d = new TH1D("H1D_BGFlag_Counters", "BG Flag Counters;Channel;Counts",64, 0, 64) ;
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)");
+ h2d = new TH2D("H2D_Charge_Channel", "ADC Charge per channel;Channel;Charge (ADC counts)",64, 0, 64, 1024, 0, 1024) ;
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)");
+ h2d = new TH2D("H2D_Time_Channel", "Time per channel;Channel;Time (ns)",64, 0, 64, 820, 0, 410) ;
Add2ESDsList(h2d, kTimeChannel, !expert, image) ;
- h1d = new TH1D("H1D_V0A_Time", "Mean V0A Time",2048, 0., 409.6);
- h1d->GetXaxis()->SetTitle("Time (ns)");
+ h1d = new TH1D("H1D_V0A_Time", "Mean V0A Time;Time (ns);Counts",2048, 0., 409.6);
Add2ESDsList(h1d,kESDV0ATime, !expert, image);
- h1d = new TH1D("H1D_V0C_Time", "Mean V0C Time",2048, 0., 409.6);
- h1d->GetXaxis()->SetTitle("Time (ns)");
+ h1d = new TH1D("H1D_V0C_Time", "Mean V0C Time;Time (ns);Counts",2048, 0., 409.6);
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)");
+ h1d = new TH1D("H1D_Diff_Time", "Diff Time V0A - V0C;Diff Time V0A - V0C (ns);Counts",2*2048, -409.6, 409.6);
Add2ESDsList(h1d,kESDDiffTime, !expert, image);
}
int iHisto =0;
// Creation of Cell Multiplicity Histograms
- h1i = new TH1I("H1I_Multiplicity_V0A", "Cell Multiplicity in V0A", 35, 0, 35) ;
+ h1i = new TH1I("H1I_Multiplicity_V0A", "Cell Multiplicity in V0A;# of Cells;Entries", 35, 0, 35) ;
Add2RawsList(h1i,kMultiV0A, !expert, image, saveCorr); iHisto++;
- h1i = new TH1I("H1I_Multiplicity_V0C", "Cell Multiplicity in V0C", 35, 0, 35) ;
+ h1i = new TH1I("H1I_Multiplicity_V0C", "Cell Multiplicity in V0C;# of Cells;Entries", 35, 0, 35) ;
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) ;
+ h1d = new TH1D("H1D_Charge_V0A", "Total Charge in V0A;Charge [ADC counts];Counts", 2048, 0, 32768) ;
Add2RawsList(h1d,kChargeV0A, !expert, image, saveCorr); iHisto++;
- h1d = new TH1D("H1D_Charge_V0C", "Total Charge in V0C", 2048, 0, 32768) ;
+ h1d = new TH1D("H1D_Charge_V0C", "Total Charge in V0C;Charge [ADC counts];Counts", 2048, 0, 32768) ;
Add2RawsList(h1d,kChargeV0C, !expert, image, saveCorr); iHisto++;
- h1d = new TH1D("H1D_Charge_V0", "Total Charge in V0", 2048, 0, 65536) ;
+ h1d = new TH1D("H1D_Charge_V0", "Total Charge in V0;Charge [ADC counts];Counts", 2048, 0, 65536) ;
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) ;
+ h1d = new TH1D("H1D_MIP_V0A", "Total MIP in V0A;Charge [MIP];Counts", 2*kNMIPBins,kMIPMin ,32*kMIPMax) ;
Add2RawsList(h1d,kRawMIPV0A, !expert, image, saveCorr); iHisto++;
- h1d = new TH1D("H1D_MIP_V0C", "Total MIP in V0C", 2*kNMIPBins,kMIPMin ,32*kMIPMax) ;
+ h1d = new TH1D("H1D_MIP_V0C", "Total MIP in V0C;Charge [MIP];Counts", 2*kNMIPBins,kMIPMin ,32*kMIPMax) ;
Add2RawsList(h1d,kRawMIPV0C, !expert, image, saveCorr); iHisto++;
- h1d = new TH1D("H1D_MIP_V0", "Total MIP in V0", 2*kNMIPBins,kMIPMin ,32*kMIPMax) ;
+ h1d = new TH1D("H1D_MIP_V0", "Total MIP in V0;Charge [MIP];Counts", 2*kNMIPBins,kMIPMin ,32*kMIPMax) ;
Add2RawsList(h1d,kRawMIPV0, !expert, image, saveCorr); iHisto++;
- h2d = new TH2D("H2D_MIP_Channel", "Nb of MIP per channel", kNChannelBins, kChannelMin, kChannelMax,kNMIPBins,kMIPMin ,kMIPMax) ;
+ h2d = new TH2D("H2D_MIP_Channel", "Nb of MIP per channel;Channel;# of Mips", kNChannelBins, kChannelMin, kChannelMax,kNMIPBins,kMIPMin ,kMIPMax) ;
Add2RawsList(h2d,kRawMIPChannel, expert, !image, !saveCorr); iHisto++;
for(Int_t iInt=0;iInt<kNintegrator;iInt++){
// Creation of Pedestal histograms
sprintf(name,"H2I_Pedestal_Int%d",iInt);
- sprintf(title,"Pedestal (Int%d)",iInt);
+ sprintf(title,"Pedestal (Int%d);Pedestal [ADC counts];Counts",iInt);
h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax,kNPedestalBins,kPedestalMin ,kPedestalMax );
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);
+ sprintf(title,"One Cycle Pedestal (Int%d);Pedestal [ADC counts];Counts",iInt);
h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax,kNPedestalBins,kPedestalMin ,kPedestalMax );
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);
+ sprintf(title,"Pedestal Versus Time (Int%d);Time [ns];Pedestal [ADC counts]",iInt);
h2d = new TH2D(name, title,kNChannelBins, kChannelMin, kChannelMax,kTimeMax,kTimeMin ,kTimeMax );
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);
+ sprintf(title,"Charge EoI (Int%d);Charge [ADC counts];Counts",iInt);
h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, kChargeMax);
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);
+ sprintf(title,"One Cycle Charge EoI (Int%d);Charge [ADC counts];Counts",iInt);
h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, kChargeMax);
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);
+ sprintf(title,"Charge EoI Versus Time (Int%d);Time [ns];Charge [ADC counts]",iInt);
h2d = new TH2D(name, title,kNChannelBins, kChannelMin, kChannelMax,kTimeMax,kTimeMin ,kTimeMax );
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);
+ sprintf(title,"Charge EoI w/ BB Flag (Int%d);??;Charge [ADC counts]",iInt);
h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, kChargeMax);
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);
+ sprintf(title,"Charge EoI w/ BG Flag (Int%d);??;Charge [ADC counts]",iInt);
h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, kChargeMax);
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);
+ sprintf(title,"Charge Versus LHC-Clock (Int%d);Tine [ns];Charge [ADC counts]",iInt);
h2d = new TH2D(name, title,kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 );
Add2RawsList(h2d,(iInt == 0 ? kChargeVsClockInt0 : kChargeVsClockInt1 ), expert, !image, !saveCorr); iHisto++;
for(Int_t iBB=0;iBB<2;iBB++){
for(Int_t iBG=0;iBG<2;iBG++){
sprintf(name,"H2I_ChargeMB_BB%d_BG%d_Int%d",iBB,iBG,iInt);
- sprintf(title,"MB Charge (BB=%d, BG=%d, Int=%d)",iBB,iBG,iInt);
+ sprintf(title,"MB Charge (BB=%d, BG=%d, Int=%d);Charge [ADC counts];Counts",iBB,iBG,iInt);
h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax,kNChargeBins, kChargeMin, kChargeMax);
int idx;
if(iInt==0){
// Creation of Time histograms
sprintf(name,"H2I_Width");
- sprintf(title,"HPTDC Width");
+ sprintf(title,"HPTDC Width;Width [ns];Counts");
h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax, kNTdcWidthBins, kTdcWidthMin, kTdcWidthMax);
Add2RawsList(h2i,kWidth, expert, !image, !saveCorr); iHisto++;
sprintf(name,"H2I_Width_BB");
- sprintf(title,"HPTDC Width w/ BB Flag condition");
+ sprintf(title,"HPTDC Width w/ BB Flag condition;??;Width [ns]");
h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax, kNTdcWidthBins, kTdcWidthMin, kTdcWidthMax);
Add2RawsList(h2i,kWidthBB, expert, !image, !saveCorr); iHisto++;
sprintf(name,"H2I_Width_BG");
- sprintf(title,"HPTDC Width w/ BG Flag condition");
+ sprintf(title,"HPTDC Width w/ BG Flag condition??;Width [ns]");
h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax, kNTdcWidthBins, kTdcWidthMin, kTdcWidthMax);
Add2RawsList(h2i,kWidthBG, expert, !image, !saveCorr); iHisto++;
sprintf(name,"H2I_HPTDCTime");
- sprintf(title,"HPTDC Time");
+ sprintf(title,"HPTDC Time;??;Width [ns]");
h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax, kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
Add2RawsList(h2i,kHPTDCTime, !expert, image, !saveCorr); iHisto++;
sprintf(name,"H2I_HPTDCTime_BB");
- sprintf(title,"HPTDC Time w/ BB Flag condition");
+ sprintf(title,"HPTDC Time w/ BB Flag condition;??;Width [ns]");
h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax, kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
Add2RawsList(h2i,kHPTDCTimeBB, expert, !image, !saveCorr); iHisto++;
sprintf(name,"H2I_HPTDCTime_BG");
- sprintf(title,"HPTDC Time w/ BG Flag condition");
+ sprintf(title,"HPTDC Time w/ BG Flag condition;??;Width [ns]");
h2i = new TH2I(name, title,kNChannelBins, kChannelMin, kChannelMax, kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
Add2RawsList(h2i,kHPTDCTimeBG, expert, !image, !saveCorr); iHisto++;
sprintf(name,"H1D_V0A_Time");
- sprintf(title,"V0A Time");
+ sprintf(title,"V0A Time;Time [ns];Counts");
h1d = new TH1D(name, title,kNTdcTimeBins, kTdcTimeMin/10, kTdcTimeMax/10);
Add2RawsList(h1d,kV0ATime, !expert, !image, saveCorr); iHisto++;
sprintf(name,"H1D_V0C_Time");
- sprintf(title,"V0C Time");
+ sprintf(title,"V0C Time;Time [ns];Counts");
h1d = new TH1D(name, title,kNTdcTimeBins, kTdcTimeMin/10, kTdcTimeMax/10);
Add2RawsList(h1d,kV0CTime, !expert, !image, saveCorr); iHisto++;
sprintf(name,"H1D_Diff_Time");
- sprintf(title,"Diff V0A-V0C Time");
+ sprintf(title,"Diff V0A-V0C Time;Time [ns];Counts");
h1d = new TH1D(name, title,2*kNTdcTimeBins, -kTdcTimeMax/10, kTdcTimeMax/10);
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");
+ sprintf(title,"BB-Flags Versus LHC-Clock;Time [ns];??");
h2d = new TH2D(name, title,kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 );
Add2RawsList(h2d,kBBFlagVsClock, expert, !image, !saveCorr); iHisto++;
sprintf(name,"H2D_BGFlagVsClock");
- sprintf(title,"BG-Flags Versus LHC-Clock");
+ sprintf(title,"BG-Flags Versus LHC-Clock;Time [ns];??");
h2d = new TH2D(name, title,kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 );
Add2RawsList(h2d,kBGFlagVsClock, expert, !image, !saveCorr); iHisto++;
char texte[100];
// create Digits histograms in Digits subdir
- TH1I * h0 = new TH1I("hDigitMultiplicity", "Digits multiplicity distribution in VZERO", 100, 0, 99) ;
+ TH1I * h0 = new TH1I("hDigitMultiplicity", "Digits multiplicity distribution in VZERO;# of Digits;Entries", 100, 0, 99) ;
h0->Sumw2() ;
Add2DigitsList(h0, 0, !expert, image) ;
for (Int_t i=0; i<64; i++)
{
sprintf(TDCname, "hDigitTDC%d", i);
- sprintf(texte,"Digit TDC in cell %d",i);
+ sprintf(texte,"Digit TDC in cell %d; TDC value;Entries",i);
fhDigTDC[i] = new TH1I(TDCname,texte,300,0.,149.);
sprintf(ADCname,"hDigitADC%d",i);
- sprintf(texte,"Digit ADC in cell %d",i);
+ sprintf(texte,"Digit ADC in cell %d;ADC value;Entries",i);
fhDigADC[i]= new TH1I(ADCname,texte,1024,0.,1023.);
Add2DigitsList(fhDigTDC[i],i+1, !expert, image);
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH1I * h0 = new TH1I("hHitMultiplicity", "Hit multiplicity distribution in VZERO", 300, 0, 299) ;
+ TH1I * h0 = new TH1I("hHitMultiplicity", "Hit multiplicity distribution in VZERO;# of Hits;Entries", 300, 0, 299) ;
h0->Sumw2() ;
Add2HitsList(h0, 0, !expert, image) ;
- TH1I * h1 = new TH1I("hHitCellNumber", "Hit cell distribution in VZERO", 80, 0, 79) ;
+ TH1I * h1 = new TH1I("hHitCellNumber", "Hit cell distribution in VZERO;# of Hits;Entries", 80, 0, 79) ;
h1->Sumw2() ;
Add2HitsList(h1, 1, !expert, image) ;
char texte[100];
// create Digits histograms in Digits subdir
- TH1I * h0 = new TH1I("hDigitMultiplicity", "Digits multiplicity distribution in VZERO", 100, 0, 99) ;
+ TH1I * h0 = new TH1I("hDigitMultiplicity", "Digits multiplicity distribution in VZERO;# of Digits;Entries", 100, 0, 99) ;
h0->Sumw2() ;
Add2DigitsList(h0, 0, !expert, image) ;
for (Int_t i=0; i<64; i++)
{
sprintf(TDCname, "hDigitTDC%d", i);
- sprintf(texte,"Digit TDC in cell %d",i);
+ sprintf(texte,"Digit TDC in cell %d; TDC value;Entries",i);
fhDigTDC[i] = new TH1I(TDCname,texte,300,0.,149.);
sprintf(ADCname,"hDigitADC%d",i);
- sprintf(texte,"Digit ADC in cell %d",i);
+ sprintf(texte,"Digit ADC in cell %d;ADC value;Entries",i);
fhDigADC[i]= new TH1I(ADCname,texte,1024,0.,1023.);
Add2DigitsList(fhDigTDC[i],i+1, !expert, image);
// create Digits histograms in Digits subdir
//
// ------------------- HIGH GAIN CHAIN ---------------------------
- TH1F * hRawZNCTot = new TH1F("hRawZNCTot", "Raw signal in ZNC", 100, 0., 6000.);
- TH1F * hRawZNATot = new TH1F("hRawZNATot", "Raw signal in ZNA", 100, 0., 6000.);
- TH1F * hRawZPCTot = new TH1F("hRawZPCTot", "Raw signal in ZPC", 100, 0., 10000.);
- TH1F * hRawZPATot = new TH1F("hRawZPATot", "Raw signal in ZPA", 100, 0., 10000.);
+ TH1F * hRawZNCTot = new TH1F("hRawZNCTot", "Raw signal in ZNC;Amplitude [ADC counts];Counts", 100, 0., 6000.);
+ TH1F * hRawZNATot = new TH1F("hRawZNATot", "Raw signal in ZNA;Amplitude [ADC counts];Counts", 100, 0., 6000.);
+ TH1F * hRawZPCTot = new TH1F("hRawZPCTot", "Raw signal in ZPC;Amplitude [ADC counts];Counts", 100, 0., 10000.);
+ TH1F * hRawZPATot = new TH1F("hRawZPATot", "Raw signal in ZPA;Amplitude [ADC counts];Counts", 100, 0., 10000.);
Add2RawsList(hRawZNCTot, 0);
Add2RawsList(hRawZNATot, 1);
Add2RawsList(hRawZPCTot, 2);
Add2RawsList(hRawZPATot, 3);
//
- TH1F * hRawSumQZNC = new TH1F("hRawSumQZNC", "Raw summed 4 ZNC quadrants",100, 0., 4000.);
- TH1F * hRawSumQZNA = new TH1F("hRawSumQZNA", "Raw summed 4 ZNA quadrants",100, 0., 4000.);
- TH1F * hRawSumQZPC = new TH1F("hRawSumQZPC", "Raw summed 4 ZPC quadrants",100, 0., 4000.);
- TH1F * hRawSumQZPA = new TH1F("hRawSumQZPA", "Raw summed 4 ZPA quadrants",100, 0., 4000.);
+ TH1F * hRawSumQZNC = new TH1F("hRawSumQZNC", "Raw summed 4 ZNC quadrants;Amplitude [ADC counts];Counts",100, 0., 4000.);
+ TH1F * hRawSumQZNA = new TH1F("hRawSumQZNA", "Raw summed 4 ZNA quadrants;Amplitude [ADC counts];Counts",100, 0., 4000.);
+ TH1F * hRawSumQZPC = new TH1F("hRawSumQZPC", "Raw summed 4 ZPC quadrants;Amplitude [ADC counts];Counts",100, 0., 4000.);
+ TH1F * hRawSumQZPA = new TH1F("hRawSumQZPA", "Raw summed 4 ZPA quadrants;Amplitude [ADC counts];Counts",100, 0., 4000.);
Add2RawsList(hRawSumQZNC, 4, kTRUE);
Add2RawsList(hRawSumQZNA, 5, kTRUE);
Add2RawsList(hRawSumQZPC, 6, kTRUE);
Add2RawsList(hRawSumQZPA, 7, kTRUE);
//
- TH1F * hRawPMCZNC = new TH1F("hRawPMCZNC", "Raw common ZNC PMT",100, 0., 4000.);
- TH1F * hRawPMCZNA = new TH1F("hRawPMCZNA", "Raw common ZNA PMT",100, 0., 4000.);
- TH1F * hRawPMCZPC = new TH1F("hRawPMCZPC", "Raw common ZPC PMT",100, 0., 4000.);
- TH1F * hRawPMCZPA = new TH1F("hRawPMCZPA", "Raw common ZPA PMT",100, 0., 4000.);
+ TH1F * hRawPMCZNC = new TH1F("hRawPMCZNC", "Raw common ZNC PMT;Amplitude [ADC counts];Counts",100, 0., 4000.);
+ TH1F * hRawPMCZNA = new TH1F("hRawPMCZNA", "Raw common ZNA PMT;Amplitude [ADC counts];Counts",100, 0., 4000.);
+ TH1F * hRawPMCZPC = new TH1F("hRawPMCZPC", "Raw common ZPC PMT;Amplitude [ADC counts];Counts",100, 0., 4000.);
+ TH1F * hRawPMCZPA = new TH1F("hRawPMCZPA", "Raw common ZPA PMT;Amplitude [ADC counts];Counts",100, 0., 4000.);
Add2RawsList(hRawPMCZNC, 8 , kTRUE);
Add2RawsList(hRawPMCZNA, 9 , kTRUE);
Add2RawsList(hRawPMCZPC, 10, kTRUE);
const Bool_t image = kTRUE ;
// ------------------- HIGH GAIN CHAIN ---------------------------
- TH1F * hDigZNCTot = new TH1F("hDigZNCTot", "Signal in ZNC", 100, 0., 6000.);
- TH1F * hDigZNATot = new TH1F("hDigZNATot", "Signal in ZNA", 100, 0., 6000.);
- TH1F * hDigZPCTot = new TH1F("hDigZPCTot", "Signal in ZPC", 100, 0., 6000.);
- TH1F * hDigZPATot = new TH1F("hDigZPATot", "Signal in ZPA", 100, 0., 6000.);
+ TH1F * hDigZNCTot = new TH1F("hDigZNCTot", "Signal in ZNC;Amplitude [ADC counts];Counts", 100, 0., 6000.);
+ TH1F * hDigZNATot = new TH1F("hDigZNATot", "Signal in ZNA;Amplitude [ADC counts];Counts", 100, 0., 6000.);
+ TH1F * hDigZPCTot = new TH1F("hDigZPCTot", "Signal in ZPC;Amplitude [ADC counts];Counts", 100, 0., 6000.);
+ TH1F * hDigZPATot = new TH1F("hDigZPATot", "Signal in ZPA;Amplitude [ADC counts];Counts", 100, 0., 6000.);
Add2DigitsList(hDigZNCTot, 0, !expert, image);
Add2DigitsList(hDigZNATot, 1, !expert, image);
Add2DigitsList(hDigZPCTot, 2, !expert, image);
Add2DigitsList(hDigZPATot, 3, !expert, image);
//
- TH1F * hDigSumQZNC = new TH1F("hDigSumQZNC", "Signal in 4 ZNC PMQ",100, 0., 4000.);
- TH1F * hDigSumQZNA = new TH1F("hDigSumQZNA", "Signal in 4 ZNA PMQ",100, 0., 4000.);
- TH1F * hDigSumQZPC = new TH1F("hDigSumQZPC", "Signal in 4 ZPC PMQ",100, 0., 4000.);
- TH1F * hDigSumQZPA = new TH1F("hDigSumQZPA", "Signal in 4 ZPA PMQ",100, 0., 4000.);
+ TH1F * hDigSumQZNC = new TH1F("hDigSumQZNC", "Signal in 4 ZNC PMQ;Amplitude [ADC counts];Counts",100, 0., 4000.);
+ TH1F * hDigSumQZNA = new TH1F("hDigSumQZNA", "Signal in 4 ZNA PMQ;Amplitude [ADC counts];Counts",100, 0., 4000.);
+ TH1F * hDigSumQZPC = new TH1F("hDigSumQZPC", "Signal in 4 ZPC PMQ;Amplitude [ADC counts];Counts",100, 0., 4000.);
+ TH1F * hDigSumQZPA = new TH1F("hDigSumQZPA", "Signal in 4 ZPA PMQ;Amplitude [ADC counts];Counts",100, 0., 4000.);
Add2DigitsList(hDigSumQZNC, 4, expert, !image);
Add2DigitsList(hDigSumQZNA, 5, expert, !image);
Add2DigitsList(hDigSumQZPC, 6, expert, !image);
Add2DigitsList(hDigSumQZPA, 7, expert, !image);
//
- TH1F * hDigPMCZNC = new TH1F("hDigPMCZNC", "Signal in ZNC PMC",100, 0., 4000.);
- TH1F * hDigPMCZNA = new TH1F("hDigPMCZNA", "Signal in ZNA PMC",100, 0., 4000.);
- TH1F * hDigPMCZPC = new TH1F("hDigPMCZPC", "Signal in ZPC PMC",100, 0., 4000.);
- TH1F * hDigPMCZPA = new TH1F("hDigPMCZPA", "Signal in ZPA PMC",100, 0., 4000.);
+ TH1F * hDigPMCZNC = new TH1F("hDigPMCZNC", "Signal in ZNC PMC;Amplitude [ADC counts];Counts",100, 0., 4000.);
+ TH1F * hDigPMCZNA = new TH1F("hDigPMCZNA", "Signal in ZNA PMC;Amplitude [ADC counts];Counts",100, 0., 4000.);
+ TH1F * hDigPMCZPC = new TH1F("hDigPMCZPC", "Signal in ZPC PMC;Amplitude [ADC counts];Counts",100, 0., 4000.);
+ TH1F * hDigPMCZPA = new TH1F("hDigPMCZPA", "Signal in ZPA PMC;Amplitude [ADC counts];Counts",100, 0., 4000.);
Add2DigitsList(hDigPMCZNC, 8, expert, !image);
Add2DigitsList(hDigPMCZNA, 9, expert, !image);
Add2DigitsList(hDigPMCZPC, 10, expert, !image);
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
+ TH2F * hZNCh = new TH2F("hZNCh", "Hits centroid in ZNC;Centroid position [cm];Counts", 100, -5.,5.,100,-5.,5.);\r
+ TH2F * hZNAh = new TH2F("hZNAh", "Hits centroid in ZNA;Centroid position [cm];Counts", 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
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
+ TH1F * hDigZNCTot = new TH1F("hDigZNCTot", "Signal in ZNC;Amplitude [ADC counts];Counts", 100, 0., 6000.);\r
+ TH1F * hDigZNATot = new TH1F("hDigZNATot", "Signal in ZNA;Amplitude [ADC counts];Counts", 100, 0., 6000.);\r
+ TH1F * hDigZPCTot = new TH1F("hDigZPCTot", "Signal in ZPC;Amplitude [ADC counts];Counts", 100, 0., 6000.);\r
+ TH1F * hDigZPATot = new TH1F("hDigZPATot", "Signal in ZPA;Amplitude [ADC counts];Counts", 100, 0., 6000.);\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
+ TH1F * hDigSumQZNC = new TH1F("hDigSumQZNC", "Signal in 4 ZNC PMQ;Amplitude [ADC counts];Counts",100, 0., 4000.);\r
+ TH1F * hDigSumQZNA = new TH1F("hDigSumQZNA", "Signal in 4 ZNA PMQ;Amplitude [ADC counts];Counts",100, 0., 4000.);\r
+ TH1F * hDigSumQZPC = new TH1F("hDigSumQZPC", "Signal in 4 ZPC PMQ;Amplitude [ADC counts];Counts",100, 0., 4000.);\r
+ TH1F * hDigSumQZPA = new TH1F("hDigSumQZPA", "Signal in 4 ZPA PMQ;Amplitude [ADC counts];Counts",100, 0., 4000.);\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
+ TH1F * hDigPMCZNC = new TH1F("hDigPMCZNC", "Signal in ZNC PMC;Amplitude [ADC counts];Counts",100, 0., 4000.);\r
+ TH1F * hDigPMCZNA = new TH1F("hDigPMCZNA", "Signal in ZNA PMC;Amplitude [ADC counts];Counts",100, 0., 4000.);\r
+ TH1F * hDigPMCZPC = new TH1F("hDigPMCZPC", "Signal in ZPC PMC;Amplitude [ADC counts];Counts",100, 0., 4000.);\r
+ TH1F * hDigPMCZPA = new TH1F("hDigPMCZPA", "Signal in ZPA PMC;Amplitude [ADC counts];Counts",100, 0., 4000.);\r
Add2DigitsList(hDigPMCZNC, 8, expert, !image);\r
Add2DigitsList(hDigPMCZNA, 9, expert, !image);\r
Add2DigitsList(hDigPMCZPC, 10, expert, !image);\r