fhClusterCuts[i] = new TH1F(Form("hCut_%d_%s", i, cut[i].Data()),
Form("Number of clusters that pass cuts <= %d, %s", i, cut[i].Data()),
nptbins,ptmin,ptmax);
- fhClusterCuts[i]->SetYTitle("dN/dE ");
- fhClusterCuts[i]->SetXTitle("E (GeV)");
+ fhClusterCuts[i]->SetYTitle("d#it{N}/d#it{E} ");
+ fhClusterCuts[i]->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhClusterCuts[i]) ;
}
nptbins,ptmin,ptmax,
GetCaloUtils()->GetNumberOfSuperModulesUsed(),0,GetCaloUtils()->GetNumberOfSuperModulesUsed());
fhEClusterSM->SetYTitle("SuperModule ");
- fhEClusterSM->SetXTitle("E (GeV)");
+ fhEClusterSM->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhEClusterSM) ;
- fhPtClusterSM = new TH2F("hPtClusterSM","Raw clusters p_{T} and super-module number",
+ fhPtClusterSM = new TH2F("hPtClusterSM","Raw clusters #it{p}_[T] and super-module number",
nptbins,ptmin,ptmax,
GetCaloUtils()->GetNumberOfSuperModulesUsed(),0,GetCaloUtils()->GetNumberOfSuperModulesUsed());
fhPtClusterSM->SetYTitle("SuperModule ");
- fhPtClusterSM->SetXTitle("E (GeV)");
+ fhPtClusterSM->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhPtClusterSM) ;
fhEPhotonSM = new TH2F("hEPhotonSM","Selected clusters E and super-module number",
nptbins,ptmin,ptmax,
GetCaloUtils()->GetNumberOfSuperModulesUsed(),0,GetCaloUtils()->GetNumberOfSuperModulesUsed());
fhEPhotonSM->SetYTitle("SuperModule ");
- fhEPhotonSM->SetXTitle("E (GeV)");
+ fhEPhotonSM->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhEPhotonSM) ;
- fhPtPhotonSM = new TH2F("hPtPhotonSM","Selected clusters p_{T} and super-module number",
+ fhPtPhotonSM = new TH2F("hPtPhotonSM","Selected clusters #it{p}_[T] and super-module number",
nptbins,ptmin,ptmax,
GetCaloUtils()->GetNumberOfSuperModulesUsed(),0,GetCaloUtils()->GetNumberOfSuperModulesUsed());
fhPtPhotonSM->SetYTitle("SuperModule ");
- fhPtPhotonSM->SetXTitle("E (GeV)");
+ fhPtPhotonSM->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhPtPhotonSM) ;
fhNCellsE = new TH2F ("hNCellsE","# of cells in cluster vs E of clusters", nptbins,ptmin,ptmax, nbins,nmin,nmax);
- fhNCellsE->SetXTitle("E (GeV)");
+ fhNCellsE->SetXTitle("#it{E} (GeV)");
fhNCellsE->SetYTitle("# of cells in cluster");
outputContainer->Add(fhNCellsE);
fhCellsE = new TH2F ("hCellsE","energy of cells in cluster vs E of clusters", nptbins,ptmin,ptmax, nptbins*2,ptmin,ptmax);
- fhCellsE->SetXTitle("E_{cluster} (GeV)");
- fhCellsE->SetYTitle("E_{cell} (GeV)");
+ fhCellsE->SetXTitle("#it{E}_{cluster} (GeV)");
+ fhCellsE->SetYTitle("#it{E}_{cell} (GeV)");
outputContainer->Add(fhCellsE);
fhTimePt = new TH2F ("hTimePt","time of cluster vs pT of clusters", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimePt->SetXTitle("p_{T} (GeV/c)");
- fhTimePt->SetYTitle("time (ns)");
+ fhTimePt->SetXTitle("#it{p}_[T] (GeV/#it{c})");
+ fhTimePt->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimePt);
fhMaxCellDiffClusterE = new TH2F ("hMaxCellDiffClusterE","energy vs difference of cluster energy - max cell energy / cluster energy, good clusters",
nptbins,ptmin,ptmax, 500,0,1.);
- fhMaxCellDiffClusterE->SetXTitle("E_{cluster} (GeV) ");
- fhMaxCellDiffClusterE->SetYTitle("(E_{cluster} - E_{cell max})/ E_{cluster}");
+ fhMaxCellDiffClusterE->SetXTitle("#it{E}_{cluster} (GeV) ");
+ fhMaxCellDiffClusterE->SetYTitle("(#it{E}_{cluster} - #it{E}_{cell max})/ #it{E}_{cluster}");
outputContainer->Add(fhMaxCellDiffClusterE);
fhEPhoton = new TH1F("hEPhoton","Number of #gamma over calorimeter vs energy",nptbins,ptmin,ptmax);
- fhEPhoton->SetYTitle("N");
- fhEPhoton->SetXTitle("E_{#gamma}(GeV)");
+ fhEPhoton->SetYTitle("#it{counts}");
+ fhEPhoton->SetXTitle("#it{E}_{#gamma}(GeV)");
outputContainer->Add(fhEPhoton) ;
- fhPtPhoton = new TH1F("hPtPhoton","Number of #gamma over calorimeter vs p_{T}",nptbins,ptmin,ptmax);
- fhPtPhoton->SetYTitle("N");
- fhPtPhoton->SetXTitle("p_{T #gamma}(GeV/c)");
+ fhPtPhoton = new TH1F("hPtPhoton","Number of #gamma over calorimeter vs #it{p}_[T]",nptbins,ptmin,ptmax);
+ fhPtPhoton->SetYTitle("#it{counts}");
+ fhPtPhoton->SetXTitle("p_{T #gamma}(GeV/#it{c})");
outputContainer->Add(fhPtPhoton) ;
- fhPtCentralityPhoton = new TH2F("hPtCentralityPhoton","centrality vs p_{T}",nptbins,ptmin,ptmax, 100,0,100);
+ fhPtCentralityPhoton = new TH2F("hPtCentralityPhoton","centrality vs #it{p}_[T]",nptbins,ptmin,ptmax, 100,0,100);
fhPtCentralityPhoton->SetYTitle("Centrality");
- fhPtCentralityPhoton->SetXTitle("p_{T}(GeV/c)");
+ fhPtCentralityPhoton->SetXTitle("#it{p}_[T](GeV/#it{c})");
outputContainer->Add(fhPtCentralityPhoton) ;
- fhPtEventPlanePhoton = new TH2F("hPtEventPlanePhoton","centrality vs p_{T}",nptbins,ptmin,ptmax, 100,0,TMath::Pi());
+ fhPtEventPlanePhoton = new TH2F("hPtEventPlanePhoton","centrality vs #it{p}_[T]",nptbins,ptmin,ptmax, 100,0,TMath::Pi());
fhPtEventPlanePhoton->SetYTitle("Event plane angle (rad)");
- fhPtEventPlanePhoton->SetXTitle("p_{T} (GeV/c)");
+ fhPtEventPlanePhoton->SetXTitle("#it{p}_[T] (GeV/#it{c})");
outputContainer->Add(fhPtEventPlanePhoton) ;
fhEtaPhi = new TH2F
- ("hEtaPhi","cluster,E > 0.5 GeV, #eta vs #phi",netabins,etamin,etamax,nphibins,phimin,phimax);
+ ("hEtaPhi","cluster,#it{E} > 0.5 GeV, #eta vs #phi",netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhi->SetYTitle("#phi (rad)");
fhEtaPhi->SetXTitle("#eta");
outputContainer->Add(fhEtaPhi) ;
if(fCalorimeter=="EMCAL" && fFillEMCALBCHistograms)
{
fhEtaPhiEMCALBC0 = new TH2F
- ("hEtaPhiEMCALBC0","cluster,E > 2 GeV, #eta vs #phi, for clusters with |time| < 25 ns, EMCAL-BC=0",netabins,etamin,etamax,nphibins,phimin,phimax);
+ ("hEtaPhiEMCALBC0","cluster,#it{E} > 2 GeV, #eta vs #phi, for clusters with |time| < 25 ns, EMCAL-BC=0",netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiEMCALBC0->SetYTitle("#phi (rad)");
fhEtaPhiEMCALBC0->SetXTitle("#eta");
outputContainer->Add(fhEtaPhiEMCALBC0) ;
fhEtaPhiEMCALBC1 = new TH2F
- ("hEtaPhiEMCALBC1","cluster,E > 2 GeV, #eta vs #phi, for clusters with 25 < |time| < 75 ns, EMCAL-BC=1",netabins,etamin,etamax,nphibins,phimin,phimax);
+ ("hEtaPhiEMCALBC1","cluster,#it{E} > 2 GeV, #eta vs #phi, for clusters with 25 < |time| < 75 ns, EMCAL-BC=1",netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiEMCALBC1->SetYTitle("#phi (rad)");
fhEtaPhiEMCALBC1->SetXTitle("#eta");
outputContainer->Add(fhEtaPhiEMCALBC1) ;
fhEtaPhiEMCALBCN = new TH2F
- ("hEtaPhiEMCALBCN","cluster,E > 2 GeV, #eta vs #phi, for clusters with |time| > 75 ns, EMCAL-BC>1",netabins,etamin,etamax,nphibins,phimin,phimax);
+ ("hEtaPhiEMCALBCN","cluster,#it{E} > 2 GeV, #eta vs #phi, for clusters with |time| > 75 ns, EMCAL-BC>1",netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiEMCALBCN->SetYTitle("#phi (rad)");
fhEtaPhiEMCALBCN->SetXTitle("#eta");
outputContainer->Add(fhEtaPhiEMCALBCN) ;
{
fhEtaPhiTriggerEMCALBC[i] = new TH2F
(Form("hEtaPhiTriggerEMCALBC%d",i-iBCShift),
- Form("cluster E > 2 GeV, #eta vs #phi, Trigger EMCAL-BC=%d",i-iBCShift),
+ Form("cluster #it{E} > 2 GeV, #eta vs #phi, Trigger EMCAL-BC=%d",i-iBCShift),
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBC[i]->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBC[i]->SetXTitle("#eta");
fhTimeTriggerEMCALBC[i] = new TH2F
(Form("hTimeTriggerEMCALBC%d",i-iBCShift),
- Form("cluster time vs E of clusters, Trigger EMCAL-BC=%d",i-iBCShift),
+ Form("cluster #it{time} vs #it{E} of clusters, Trigger EMCAL-BC=%d",i-iBCShift),
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBC[i]->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBC[i]->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBC[i]->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBC[i]->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBC[i]);
fhTimeTriggerEMCALBCPileUpSPD[i] = new TH2F
(Form("hTimeTriggerEMCALBC%dPileUpSPD",i-iBCShift),
- Form("cluster time vs E of clusters, Trigger EMCAL-BC=%d",i-iBCShift),
+ Form("cluster #it{time} vs #it{E} of clusters, Trigger EMCAL-BC=%d",i-iBCShift),
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCPileUpSPD[i]->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCPileUpSPD[i]->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCPileUpSPD[i]->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCPileUpSPD[i]->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCPileUpSPD[i]);
fhEtaPhiTriggerEMCALBCUM[i] = new TH2F
(Form("hEtaPhiTriggerEMCALBC%d_UnMatch",i-iBCShift),
- Form("cluster E > 2 GeV, #eta vs #phi, unmatched trigger EMCAL-BC=%d",i-iBCShift),
+ Form("cluster #it{E} > 2 GeV, #eta vs #phi, unmatched trigger EMCAL-BC=%d",i-iBCShift),
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCUM[i]->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCUM[i]->SetXTitle("#eta");
fhTimeTriggerEMCALBCUM[i] = new TH2F
(Form("hTimeTriggerEMCALBC%d_UnMatch",i-iBCShift),
- Form("cluster time vs E of clusters, unmatched trigger EMCAL-BC=%d",i-iBCShift),
+ Form("cluster #it{time} vs #it{E} of clusters, unmatched trigger EMCAL-BC=%d",i-iBCShift),
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCUM[i]->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCUM[i]->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCUM[i]->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCUM[i]->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCUM[i]);
fhEtaPhiTriggerEMCALBCCluster[i] = new TH2F
}
fhTimeTriggerEMCALBCCluster = new TH2F("hTimeTriggerEMCALBC_OnlyTrigger",
- "trigger cluster time vs E of clusters",
+ "trigger cluster #it{time} vs #it{E} of clusters",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCCluster->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCCluster->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCCluster->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCCluster->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCCluster);
fhTimeTriggerEMCALBCUMCluster = new TH2F("hTimeTriggerEMCALBC_OnlyTrigger_UnMatch",
- "trigger cluster time vs E of clusters, unmatched trigger",
+ "trigger cluster #it{time} vs #it{E} of clusters, unmatched trigger",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCUMCluster->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCUMCluster->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCUMCluster->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCUMCluster->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCUMCluster);
fhEtaPhiTriggerEMCALBCClusterOverTh = new TH2F
("hEtaPhiTriggerEMCALBC0_OnlyTrigger_OverThreshold",
- "trigger cluster E > trigger threshold, #eta vs #phi, Trigger EMCAL-BC=0",
+ "trigger cluster #it{E} > trigger threshold, #eta vs #phi, Trigger EMCAL-BC=0",
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCClusterOverTh->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCClusterOverTh->SetXTitle("#eta");
fhEtaPhiTriggerEMCALBCUMClusterOverTh = new TH2F
("hEtaPhiTriggerEMCALBC0_OnlyTrigger_OverThreshold_UnMatch",
- "trigger cluster E > trigger threshold, #eta vs #phi, unmatched trigger EMCAL-BC=0",
+ "trigger cluster #it{E} > trigger threshold, #eta vs #phi, unmatched trigger EMCAL-BC=0",
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCUMClusterOverTh->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCUMClusterOverTh->SetXTitle("#eta");
fhEtaPhiTriggerEMCALBCClusterBelowTh1 = new TH2F
("hEtaPhiTriggerEMCALBC0_OnlyTrigger_BelowThreshold1",
- "trigger cluster thresh-1 < E < thres, #eta vs #phi, Trigger EMCAL-BC=0",
+ "trigger cluster thresh-1 < #it{E} < thres, #eta vs #phi, Trigger EMCAL-BC=0",
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCClusterBelowTh1->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCClusterBelowTh1->SetXTitle("#eta");
fhEtaPhiTriggerEMCALBCUMClusterBelowTh1 = new TH2F
("hEtaPhiTriggerEMCALBC0_OnlyTrigger_BelowThreshold1_UnMatch",
- "trigger cluster thresh-1 < E < thres, #eta vs #phi, unmatched trigger EMCAL-BC=0",
+ "trigger cluster thresh-1 < #it{E} < thres, #eta vs #phi, unmatched trigger EMCAL-BC=0",
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCUMClusterBelowTh1->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCUMClusterBelowTh1->SetXTitle("#eta");
fhEtaPhiTriggerEMCALBCClusterBelowTh2 = new TH2F
("hEtaPhiTriggerEMCALBC0_OnlyTrigger_BelowThreshold2",
- "trigger cluster thresh-2 < E < thres, #eta vs #phi, Trigger EMCAL-BC=0",
+ "trigger cluster thresh-2 < #it{E} < thres, #eta vs #phi, Trigger EMCAL-BC=0",
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCClusterBelowTh2->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCClusterBelowTh2->SetXTitle("#eta");
fhEtaPhiTriggerEMCALBCUMClusterBelowTh2 = new TH2F
("hEtaPhiTriggerEMCALBC0_OnlyTrigger_BelowThreshold2_UnMatch",
- "trigger cluster thresh-2 < E < thres, #eta vs #phi, unmatched trigger EMCAL-BC=0",
+ "trigger cluster thresh-2 < #it{E} < thres, #eta vs #phi, unmatched trigger EMCAL-BC=0",
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCUMClusterBelowTh2->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCUMClusterBelowTh2->SetXTitle("#eta");
{
fhEtaPhiTriggerEMCALBCExotic = new TH2F
("hEtaPhiTriggerExotic",
- "cluster E > 2 GeV, #eta vs #phi, Trigger Exotic",
+ "cluster #it{E} > 2 GeV, #eta vs #phi, Trigger Exotic",
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCExotic->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCExotic->SetXTitle("#eta");
fhTimeTriggerEMCALBCExotic = new TH2F
("hTimeTriggerExotic",
- "cluster time vs E of clusters, Trigger Exotic ",
+ "cluster #it{time} vs #it{E} of clusters, Trigger Exotic ",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCExotic->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCExotic->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCExotic->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCExotic->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCExotic);
fhEtaPhiTriggerEMCALBCUMExotic = new TH2F
("hEtaPhiTriggerExotic_UnMatch",
- "cluster E > 2 GeV, #eta vs #phi, unmatched trigger Exotic",
+ "cluster #it{E} > 2 GeV, #eta vs #phi, unmatched trigger Exotic",
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCUMExotic->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCUMExotic->SetXTitle("#eta");
fhTimeTriggerEMCALBCUMExotic = new TH2F
("hTimeTriggerExotic_UnMatch",
- "cluster time vs E of clusters, unmatched trigger Exotic",
+ "cluster #it{time} vs #it{E} of clusters, unmatched trigger Exotic",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCUMExotic->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCUMExotic->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCUMExotic->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCUMExotic->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCUMExotic);
fhEtaPhiTriggerEMCALBCExoticCluster = new TH2F
("hEtaPhiTriggerExotic_OnlyTrigger",
- "trigger cluster E > 2 GeV, #eta vs #phi, Trigger Exotic",
+ "trigger cluster #it{E} > 2 GeV, #eta vs #phi, Trigger Exotic",
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCExoticCluster->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCExoticCluster->SetXTitle("#eta");
fhTimeTriggerEMCALBCExoticCluster = new TH2F
("hTimeTriggerExotic_OnlyTrigger",
- "trigger cluster time vs E of clusters, Trigger Exotic",
+ "trigger cluster #it{time} vs #it{E} of clusters, Trigger Exotic",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCExoticCluster->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCExoticCluster->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCExoticCluster->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCExoticCluster->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCExoticCluster);
fhEtaPhiTriggerEMCALBCUMExoticCluster = new TH2F
("hEtaPhiTriggerExotic_OnlyTrigger_UnMatch",
- "trigger cluster E > 2 GeV, #eta vs #phi, unmatched trigger Exotic",
+ "trigger cluster #it{E} > 2 GeV, #eta vs #phi, unmatched trigger Exotic",
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCUMExoticCluster->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCUMExoticCluster->SetXTitle("#eta");
fhTimeTriggerEMCALBCUMExoticCluster = new TH2F
("hTimeTriggerExotic_OnlyTrigger_UnMatch",
- "trigger cluster time vs E of clusters, unmatched trigger Exotic",
+ "trigger cluster #it{time} vs #it{E} of clusters, unmatched trigger Exotic",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCUMExoticCluster->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCUMExoticCluster->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCUMExoticCluster->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCUMExoticCluster->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCUMExoticCluster);
fhEtaPhiTriggerEMCALBCBad = new TH2F
("hEtaPhiTriggerBad",
- "cluster E > 2 GeV, #eta vs #phi, Trigger Bad",
+ "cluster #it{E} > 2 GeV, #eta vs #phi, Trigger Bad",
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCBad->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCBad->SetXTitle("#eta");
fhTimeTriggerEMCALBCBad = new TH2F
("hTimeTriggerBad",
- "cluster time vs E of clusters, Trigger Bad ",
+ "cluster #it{time} vs #it{E} of clusters, Trigger Bad ",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCBad->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCBad->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCBad->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCBad->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCBad);
fhEtaPhiTriggerEMCALBCUMBad = new TH2F
("hEtaPhiTriggerBad_UnMatch",
- "cluster E > 2 GeV, #eta vs #phi, unmatched trigger Bad",
+ "cluster #it{E} > 2 GeV, #eta vs #phi, unmatched trigger Bad",
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCUMBad->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCUMBad->SetXTitle("#eta");
fhTimeTriggerEMCALBCUMBad = new TH2F
("hTimeTriggerBad_UnMatch",
- "cluster time vs E of clusters, unmatched trigger Bad",
+ "cluster #it{time} vs #it{E} of clusters, unmatched trigger Bad",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCUMBad->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCUMBad->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCUMBad->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCUMBad->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCUMBad);
fhEtaPhiTriggerEMCALBCBadCluster = new TH2F
("hEtaPhiTriggerBad_OnlyTrigger",
- "trigger cluster E > 2 GeV, #eta vs #phi, Trigger Bad",
+ "trigger cluster #it{E} > 2 GeV, #eta vs #phi, Trigger Bad",
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCBadCluster->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCBadCluster->SetXTitle("#eta");
fhTimeTriggerEMCALBCBadCluster = new TH2F
("hTimeTriggerBad_OnlyTrigger",
- "trigger cluster time vs E of clusters, Trigger Bad",
+ "trigger cluster #it{time} vs #it{E} of clusters, Trigger Bad",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCBadCluster->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCBadCluster->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCBadCluster->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCBadCluster->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCBadCluster);
fhEtaPhiTriggerEMCALBCUMBadCluster = new TH2F
("hEtaPhiTriggerBad_OnlyTrigger_UnMatch",
- "trigger cluster E > 2 GeV, #eta vs #phi, unmatched trigger Bad",
+ "trigger cluster #it{E} > 2 GeV, #eta vs #phi, unmatched trigger Bad",
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCUMBadCluster->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCUMBadCluster->SetXTitle("#eta");
fhTimeTriggerEMCALBCUMBadCluster = new TH2F
("hTimeTriggerBad_OnlyTrigger_UnMatch",
- "trigger cluster time vs E of clusters, unmatched trigger Bad",
+ "trigger cluster time vs #it{E} of clusters, unmatched trigger Bad",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCUMBadCluster->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCUMBadCluster->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCUMBadCluster->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCUMBadCluster->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCUMBadCluster);
fhEtaPhiTriggerEMCALBCBadExotic = new TH2F
("hEtaPhiTriggerBadExotic",
- "cluster E > 2 GeV, #eta vs #phi, Trigger Bad&Exotic",
+ "cluster #it{E} > 2 GeV, #eta vs #phi, Trigger Bad&Exotic",
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCBadExotic->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCBadExotic->SetXTitle("#eta");
fhTimeTriggerEMCALBCBadExotic = new TH2F
("hTimeTriggerBadExotic",
- "cluster time vs E of clusters, Trigger Bad&Exotic ",
+ "cluster #it{time} vs #it{E} of clusters, Trigger Bad&Exotic ",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCBadExotic->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCBadExotic->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCBadExotic->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCBadExotic->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCBadExotic);
fhEtaPhiTriggerEMCALBCUMBadExotic = new TH2F
("hEtaPhiTriggerBadExotic_UnMatch",
- "cluster E > 2 GeV, #eta vs #phi, unmatched trigger Bad&Exotic",
+ "cluster #it{E} > 2 GeV, #eta vs #phi, unmatched trigger Bad&Exotic",
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCUMBadExotic->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCUMBadExotic->SetXTitle("#eta");
fhTimeTriggerEMCALBCUMBadExotic = new TH2F
("hTimeTriggerBadExotic_UnMatch",
- "cluster time vs E of clusters, unmatched trigger Bad&Exotic",
+ "cluster #it{time} vs #it{E} of clusters, unmatched trigger Bad&Exotic",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCUMBadExotic->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCUMBadExotic->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCUMBadExotic->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCUMBadExotic->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCUMBadExotic);
fhEtaPhiTriggerEMCALBCBadExoticCluster = new TH2F
("hEtaPhiTriggerBadExotic_OnlyTrigger",
- "trigger cluster E > 2 GeV, #eta vs #phi, Trigger Bad&Exotic",
+ "trigger cluster #it{E} > 2 GeV, #eta vs #phi, Trigger Bad&Exotic",
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCBadExoticCluster->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCBadExoticCluster->SetXTitle("#eta");
fhTimeTriggerEMCALBCBadExoticCluster = new TH2F
("hTimeTriggerBadExotic_OnlyTrigger",
- "trigger cluster time vs E of clusters, Trigger Bad&Exotic",
+ "trigger cluster #it{time} vs #it{E} of clusters, Trigger Bad&Exotic",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCBadExoticCluster->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCBadExoticCluster->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCBadExoticCluster->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCBadExoticCluster->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCBadExoticCluster);
fhEtaPhiTriggerEMCALBCUMBadExoticCluster = new TH2F
("hEtaPhiTriggerBadExotic_OnlyTrigger_UnMatch",
- "trigger cluster E > 2 GeV, #eta vs #phi, unmatched trigger Bad&Exotic",
+ "trigger cluster #it{E} > 2 GeV, #eta vs #phi, unmatched trigger Bad&Exotic",
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCUMBadExoticCluster->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCUMBadExoticCluster->SetXTitle("#eta");
fhTimeTriggerEMCALBCUMBadExoticCluster = new TH2F
("hTimeTriggerBadExotic_OnlyTrigger_UnMatch",
- "trigger cluster time vs E of clusters, unmatched trigger Bad&Exotic",
+ "trigger cluster #it{time} vs #it{E} of clusters, unmatched trigger Bad&Exotic",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCUMBadExoticCluster->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCUMBadExoticCluster->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCUMBadExoticCluster->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCUMBadExoticCluster->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCUMBadExoticCluster);
fhTimeTriggerEMCALBCBadMaxCell = new TH2F
("hTimeTriggerBadMaxCell",
- "cluster time vs E of clusters, Trigger BadMaxCell",
+ "cluster #it{time} vs #it{E} of clusters, Trigger BadMaxCell",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCBadMaxCell->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCBadMaxCell->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCBadMaxCell->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCBadMaxCell->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCBadMaxCell);
fhTimeTriggerEMCALBCUMBadMaxCell = new TH2F
("hTimeTriggerBadMaxCell_UnMatch",
- "cluster time vs E of clusters, unmatched trigger BadMaxCell",
+ "cluster #it{time} vs #it{E} of clusters, unmatched trigger BadMaxCell",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCUMBadMaxCell->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCUMBadMaxCell->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCUMBadMaxCell->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCUMBadMaxCell->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCUMBadMaxCell);
fhTimeTriggerEMCALBCBadMaxCellExotic = new TH2F
("hTimeTriggerBadMaxCellExotic",
- "cluster time vs E of clusters, Trigger BadMaxCell&Exotic",
+ "cluster #it{time} vs #it{E} of clusters, Trigger BadMaxCell&Exotic",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCBadMaxCellExotic->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCBadMaxCellExotic->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCBadMaxCellExotic->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCBadMaxCellExotic->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCBadMaxCellExotic);
fhTimeTriggerEMCALBCUMBadMaxCellExotic = new TH2F
("hTimeTriggerBadMaxCellExotic_UnMatch",
- "cluster time vs E of clusters, unmatched trigger BadMaxCell&Exotic",
+ "cluster #it{time} vs #it{E} of clusters, unmatched trigger BadMaxCell&Exotic",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCUMBadMaxCellExotic->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCUMBadMaxCellExotic->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCUMBadMaxCellExotic->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCUMBadMaxCellExotic->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCUMBadMaxCellExotic);
fhTimeNoTrigger = new TH2F
("hTimeNoTrigger",
"events with no foundable trigger, time vs e of clusters",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeNoTrigger->SetXTitle("E (GeV)");
- fhTimeNoTrigger->SetYTitle("time (ns)");
+ fhTimeNoTrigger->SetXTitle("#it{E} (GeV)");
+ fhTimeNoTrigger->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeNoTrigger);
fhEtaPhiNoTrigger = new TH2F
}
fhEtaPhiTriggerEMCALBCUMReMatchOpenTimeCluster = new TH2F("hEtaPhiTriggerEMCALBC0_OnlyTrigger_UnMatch_ReMatch_OpenTime",
- "cluster E > 2 GeV, #eta vs #phi, Trigger EMCAL-BC=0, un match, rematch open time",
+ "cluster #it{E} > 2 GeV, #eta vs #phi, Trigger EMCAL-BC=0, un match, rematch open time",
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCUMReMatchOpenTimeCluster->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCUMReMatchOpenTimeCluster->SetXTitle("#eta");
outputContainer->Add(fhEtaPhiTriggerEMCALBCUMReMatchOpenTimeCluster) ;
fhTimeTriggerEMCALBCUMReMatchOpenTimeCluster = new TH2F("hTimeTrigger_OnlyTrigger_UnMatch_ReMatch_OpenTime",
- "cluster time vs E of clusters, no match, rematch open time",
+ "cluster #it{time} vs #it{E} of clusters, no match, rematch open time",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCUMReMatchOpenTimeCluster->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCUMReMatchOpenTimeCluster->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCUMReMatchOpenTimeCluster->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCUMReMatchOpenTimeCluster->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCUMReMatchOpenTimeCluster);
fhEtaPhiTriggerEMCALBCUMReMatchCheckNeighCluster = new TH2F("hEtaPhiTriggerEMCALBC0_OnlyTrigger_UnMatch_ReMatch_CheckNeighbours",
- "cluster E > 2 GeV, #eta vs #phi, Trigger EMCAL-BC=0, un match, rematch with neighbour patches",
+ "cluster #it{E} > 2 GeV, #eta vs #phi, Trigger EMCAL-BC=0, un match, rematch with neighbour patches",
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCUMReMatchCheckNeighCluster->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCUMReMatchCheckNeighCluster->SetXTitle("#eta");
outputContainer->Add(fhEtaPhiTriggerEMCALBCUMReMatchCheckNeighCluster) ;
fhTimeTriggerEMCALBCUMReMatchCheckNeighCluster = new TH2F("hTimeTrigger_OnlyTrigger_UnMatch_ReMatch_CheckNeighbours",
- "cluster time vs E of clusters, no match, rematch with neigbour parches",
+ "cluster #it{time} vs #it{E} of clusters, no match, rematch with neigbour parches",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCUMReMatchCheckNeighCluster->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCUMReMatchCheckNeighCluster->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCUMReMatchCheckNeighCluster->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCUMReMatchCheckNeighCluster->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCUMReMatchCheckNeighCluster);
fhEtaPhiTriggerEMCALBCUMReMatchBothCluster = new TH2F("hEtaPhiTriggerEMCALBC0_OnlyTrigger_UnMatch_ReMatch_Both",
- "cluster E > 2 GeV, #eta vs #phi, Trigger EMCAL-BC=0, un match, rematch open time and neighbour",
+ "cluster #it{E} > 2 GeV, #eta vs #phi, Trigger EMCAL-BC=0, un match, rematch open time and neighbour",
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiTriggerEMCALBCUMReMatchBothCluster->SetYTitle("#phi (rad)");
fhEtaPhiTriggerEMCALBCUMReMatchBothCluster->SetXTitle("#eta");
outputContainer->Add(fhEtaPhiTriggerEMCALBCUMReMatchBothCluster) ;
fhTimeTriggerEMCALBCUMReMatchBothCluster = new TH2F("hTimeTrigger_OnlyTrigger_UnMatch_ReMatch_Both",
- "cluster time vs E of clusters, no match, rematch open time and neigbour",
+ "cluster #it{time} vs #it{E} of clusters, no match, rematch open time and neigbour",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBCUMReMatchBothCluster->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBCUMReMatchBothCluster->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBCUMReMatchBothCluster->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBCUMReMatchBothCluster->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBCUMReMatchBothCluster);
fhTimeTriggerEMCALBC0UMReMatchOpenTime = new TH2F("hTimeTriggerBC0_UnMatch_ReMatch_OpenTime",
- "cluster time vs E of clusters, no match, rematch open time",
+ "cluster #it{time} vs #it{E} of clusters, no match, rematch open time",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBC0UMReMatchOpenTime->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBC0UMReMatchOpenTime->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBC0UMReMatchOpenTime->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBC0UMReMatchOpenTime->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBC0UMReMatchOpenTime);
fhTimeTriggerEMCALBC0UMReMatchCheckNeigh = new TH2F("hTimeTriggerBC0_UnMatch_ReMatch_CheckNeighbours",
- "cluster time vs E of clusters, no match, rematch with neigbour parches",
+ "cluster #it{time} vs #it{E} of clusters, no match, rematch with neigbour parches",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBC0UMReMatchCheckNeigh->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBC0UMReMatchCheckNeigh->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBC0UMReMatchCheckNeigh->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBC0UMReMatchCheckNeigh->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBC0UMReMatchCheckNeigh);
fhTimeTriggerEMCALBC0UMReMatchBoth = new TH2F("hTimeTriggerBC0_UnMatch_ReMatch_Both",
- "cluster time vs E of clusters, no match, rematch open time and neigbour",
+ "cluster #it{time} vs #it{E} of clusters, no match, rematch open time and neigbour",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeTriggerEMCALBC0UMReMatchBoth->SetXTitle("E (GeV)");
- fhTimeTriggerEMCALBC0UMReMatchBoth->SetYTitle("time (ns)");
+ fhTimeTriggerEMCALBC0UMReMatchBoth->SetXTitle("#it{E} (GeV)");
+ fhTimeTriggerEMCALBC0UMReMatchBoth->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimeTriggerEMCALBC0UMReMatchBoth);
}
fhPhiPhoton = new TH2F
- ("hPhiPhoton","#phi_{#gamma} vs p_{T}",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
+ ("hPhiPhoton","#phi_{#gamma} vs #it{p}_[T]",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
fhPhiPhoton->SetYTitle("#phi (rad)");
- fhPhiPhoton->SetXTitle("p_{T #gamma} (GeV/c)");
+ fhPhiPhoton->SetXTitle("p_{T #gamma} (GeV/#it{c})");
outputContainer->Add(fhPhiPhoton) ;
fhEtaPhoton = new TH2F
- ("hEtaPhoton","#eta_{#gamma} vs p_{T}",nptbins,ptmin,ptmax,netabins,etamin,etamax);
+ ("hEtaPhoton","#eta_{#gamma} vs #it{p}_[T]",nptbins,ptmin,ptmax,netabins,etamin,etamax);
fhEtaPhoton->SetYTitle("#eta");
- fhEtaPhoton->SetXTitle("p_{T #gamma} (GeV/c)");
+ fhEtaPhoton->SetXTitle("p_{T #gamma} (GeV/#it{c})");
outputContainer->Add(fhEtaPhoton) ;
fhEtaPhiPhoton = new TH2F
if(fCalorimeter=="EMCAL" && fFillEMCALBCHistograms)
{
fhEtaPhiPhotonEMCALBC0 = new TH2F
- ("hEtaPhiPhotonEMCALBC0","identified photon, E > 2 GeV, #eta vs #phi, for clusters with |time| < 25 ns, EMCAL-BC=0",netabins,etamin,etamax,nphibins,phimin,phimax);
+ ("hEtaPhiPhotonEMCALBC0","identified photon, #it{E} > 2 GeV, #eta vs #phi, for clusters with |time| < 25 ns, EMCAL-BC=0",netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiPhotonEMCALBC0->SetYTitle("#phi (rad)");
fhEtaPhiPhotonEMCALBC0->SetXTitle("#eta");
outputContainer->Add(fhEtaPhiPhotonEMCALBC0) ;
fhEtaPhiPhotonEMCALBC1 = new TH2F
- ("hEtaPhiPhotonEMCALBC1","identified photon, E > 2 GeV, #eta vs #phi, for clusters with 25 < |time| < 75 ns, EMCAL-BC=1",netabins,etamin,etamax,nphibins,phimin,phimax);
+ ("hEtaPhiPhotonEMCALBC1","identified photon, #it{E} > 2 GeV, #eta vs #phi, for clusters with 25 < |time| < 75 ns, EMCAL-BC=1",netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiPhotonEMCALBC1->SetYTitle("#phi (rad)");
fhEtaPhiPhotonEMCALBC1->SetXTitle("#eta");
outputContainer->Add(fhEtaPhiPhotonEMCALBC1) ;
fhEtaPhiPhotonEMCALBCN = new TH2F
- ("hEtaPhiPhotonEMCALBCN","identified photon, E > 2 GeV, #eta vs #phi, for clusters with |time| > 75 ns, EMCAL-BC>1",netabins,etamin,etamax,nphibins,phimin,phimax);
+ ("hEtaPhiPhotonEMCALBCN","identified photon, #it{E} > 2 GeV, #eta vs #phi, for clusters with |time| > 75 ns, EMCAL-BC>1",netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiPhotonEMCALBCN->SetYTitle("#phi (rad)");
fhEtaPhiPhotonEMCALBCN->SetXTitle("#eta");
outputContainer->Add(fhEtaPhiPhotonEMCALBCN) ;
{
fhEtaPhiPhotonTriggerEMCALBC[i] = new TH2F
(Form("hEtaPhiPhotonTriggerEMCALBC%d",i-iBCShift),
- Form("photon E > 2 GeV, #eta vs #phi, PhotonTrigger EMCAL-BC=%d",i-iBCShift),
+ Form("photon #it{E} > 2 GeV, #eta vs #phi, PhotonTrigger EMCAL-BC=%d",i-iBCShift),
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiPhotonTriggerEMCALBC[i]->SetYTitle("#phi (rad)");
fhEtaPhiPhotonTriggerEMCALBC[i]->SetXTitle("#eta");
fhTimePhotonTriggerEMCALBC[i] = new TH2F
(Form("hTimePhotonTriggerEMCALBC%d",i-iBCShift),
- Form("photon time vs E of clusters, PhotonTrigger EMCAL-BC=%d",i-iBCShift),
+ Form("photon #it{time} vs #it{E} of clusters, PhotonTrigger EMCAL-BC=%d",i-iBCShift),
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimePhotonTriggerEMCALBC[i]->SetXTitle("E (GeV)");
- fhTimePhotonTriggerEMCALBC[i]->SetYTitle("time (ns)");
+ fhTimePhotonTriggerEMCALBC[i]->SetXTitle("#it{E} (GeV)");
+ fhTimePhotonTriggerEMCALBC[i]->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimePhotonTriggerEMCALBC[i]);
fhTimePhotonTriggerEMCALBCPileUpSPD[i] = new TH2F
(Form("hTimePhotonTriggerEMCALBC%dPileUpSPD",i-iBCShift),
- Form("photon time vs E, PhotonTrigger EMCAL-BC=%d",i-iBCShift),
+ Form("photon #it{time} vs #it{E}, PhotonTrigger EMCAL-BC=%d",i-iBCShift),
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimePhotonTriggerEMCALBCPileUpSPD[i]->SetXTitle("E (GeV)");
- fhTimePhotonTriggerEMCALBCPileUpSPD[i]->SetYTitle("time (ns)");
+ fhTimePhotonTriggerEMCALBCPileUpSPD[i]->SetXTitle("#it{E} (GeV)");
+ fhTimePhotonTriggerEMCALBCPileUpSPD[i]->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimePhotonTriggerEMCALBCPileUpSPD[i]);
fhEtaPhiPhotonTriggerEMCALBCUM[i] = new TH2F
(Form("hEtaPhiPhotonTriggerEMCALBC%d_UnMatch",i-iBCShift),
- Form("photon E > 2 GeV, #eta vs #phi, unmatched trigger EMCAL-BC=%d",i-iBCShift),
+ Form("photon #it{E} > 2 GeV, #eta vs #phi, unmatched trigger EMCAL-BC=%d",i-iBCShift),
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiPhotonTriggerEMCALBCUM[i]->SetYTitle("#phi (rad)");
fhEtaPhiPhotonTriggerEMCALBCUM[i]->SetXTitle("#eta");
fhTimePhotonTriggerEMCALBCUM[i] = new TH2F
(Form("hTimePhotonTriggerEMCALBC%d_UnMatch",i-iBCShift),
- Form("photon time vs E, unmatched trigger EMCAL-BC=%d",i-iBCShift),
+ Form("photon #it{time} vs #it{E}, unmatched trigger EMCAL-BC=%d",i-iBCShift),
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimePhotonTriggerEMCALBCUM[i]->SetXTitle("E (GeV)");
- fhTimePhotonTriggerEMCALBCUM[i]->SetYTitle("time (ns)");
+ fhTimePhotonTriggerEMCALBCUM[i]->SetXTitle("#it{E} (GeV)");
+ fhTimePhotonTriggerEMCALBCUM[i]->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimePhotonTriggerEMCALBCUM[i]);
}
fhTimePhotonTriggerEMCALBC0UMReMatchOpenTime = new TH2F("hTimePhotonTriggerBC0_UnMatch_ReMatch_OpenTime",
- "cluster time vs E of photons, no match, rematch open time",
+ "cluster #it{time} vs #it{E} of photons, no match, rematch open time",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimePhotonTriggerEMCALBC0UMReMatchOpenTime->SetXTitle("E (GeV)");
- fhTimePhotonTriggerEMCALBC0UMReMatchOpenTime->SetYTitle("time (ns)");
+ fhTimePhotonTriggerEMCALBC0UMReMatchOpenTime->SetXTitle("#it{E} (GeV)");
+ fhTimePhotonTriggerEMCALBC0UMReMatchOpenTime->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimePhotonTriggerEMCALBC0UMReMatchOpenTime);
fhTimePhotonTriggerEMCALBC0UMReMatchCheckNeigh = new TH2F("hTimePhotonTriggerBC0_UnMatch_ReMatch_CheckNeighbours",
- "cluster time vs E of photons, no match, rematch with neigbour parches",
+ "cluster #it{time} vs #it{E} of photons, no match, rematch with neigbour parches",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimePhotonTriggerEMCALBC0UMReMatchCheckNeigh->SetXTitle("E (GeV)");
- fhTimePhotonTriggerEMCALBC0UMReMatchCheckNeigh->SetYTitle("time (ns)");
+ fhTimePhotonTriggerEMCALBC0UMReMatchCheckNeigh->SetXTitle("#it{E} (GeV)");
+ fhTimePhotonTriggerEMCALBC0UMReMatchCheckNeigh->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimePhotonTriggerEMCALBC0UMReMatchCheckNeigh);
fhTimePhotonTriggerEMCALBC0UMReMatchBoth = new TH2F("hTimePhotonTriggerBC0_UnMatch_ReMatch_Both",
- "cluster time vs E of photons, no match, rematch open time and neigbour",
+ "cluster #it{time} vs #it{E} of photons, no match, rematch open time and neigbour",
nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimePhotonTriggerEMCALBC0UMReMatchBoth->SetXTitle("E (GeV)");
- fhTimePhotonTriggerEMCALBC0UMReMatchBoth->SetYTitle("time (ns)");
+ fhTimePhotonTriggerEMCALBC0UMReMatchBoth->SetXTitle("#it{E} (GeV)");
+ fhTimePhotonTriggerEMCALBC0UMReMatchBoth->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimePhotonTriggerEMCALBC0UMReMatchBoth);
}
fhNLocMax = new TH2F("hNLocMax","Number of local maxima in cluster",
nptbins,ptmin,ptmax,10,0,10);
fhNLocMax ->SetYTitle("N maxima");
- fhNLocMax ->SetXTitle("E (GeV)");
+ fhNLocMax ->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhNLocMax) ;
//Shower shape
{
fhLam0E = new TH2F ("hLam0E","#lambda_{0}^{2} vs E", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhLam0E->SetYTitle("#lambda_{0}^{2}");
- fhLam0E->SetXTitle("E (GeV)");
+ fhLam0E->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhLam0E);
fhLam1E = new TH2F ("hLam1E","#lambda_{1}^{2} vs E", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhLam1E->SetYTitle("#lambda_{1}^{2}");
- fhLam1E->SetXTitle("E (GeV)");
+ fhLam1E->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhLam1E);
fhDispE = new TH2F ("hDispE"," dispersion^{2} vs E", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhDispE->SetYTitle("D^{2}");
- fhDispE->SetXTitle("E (GeV) ");
+ fhDispE->SetXTitle("#it{E} (GeV) ");
outputContainer->Add(fhDispE);
if(!fRejectTrackMatch)
{
fhLam0ETM = new TH2F ("hLam0ETM","#lambda_{0}^{2} vs E, cut on track-matching residual |#Delta #eta| < 0.05, |#Delta #phi| < 0.05", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhLam0ETM->SetYTitle("#lambda_{0}^{2}");
- fhLam0ETM->SetXTitle("E (GeV)");
+ fhLam0ETM->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhLam0ETM);
fhLam1ETM = new TH2F ("hLam1ETM","#lambda_{1}^{2} vs E, cut on track-matching residual |#Delta #eta| < 0.05, |#Delta #phi| < 0.05", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhLam1ETM->SetYTitle("#lambda_{1}^{2}");
- fhLam1ETM->SetXTitle("E (GeV)");
+ fhLam1ETM->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhLam1ETM);
fhDispETM = new TH2F ("hDispETM"," dispersion^{2} vs E, cut on track-matching residual |#Delta #eta| < 0.05, |#Delta #phi| < 0.05", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhDispETM->SetYTitle("D^{2}");
- fhDispETM->SetXTitle("E (GeV) ");
+ fhDispETM->SetXTitle("#it{E} (GeV) ");
outputContainer->Add(fhDispETM);
}
{
fhLam0ETRD = new TH2F ("hLam0ETRD","#lambda_{0}^{2} vs E, EMCAL SM covered by TRD", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhLam0ETRD->SetYTitle("#lambda_{0}^{2}");
- fhLam0ETRD->SetXTitle("E (GeV)");
+ fhLam0ETRD->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhLam0ETRD);
fhLam1ETRD = new TH2F ("hLam1ETRD","#lambda_{1}^{2} vs E, EMCAL SM covered by TRD", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhLam1ETRD->SetYTitle("#lambda_{1}^{2}");
- fhLam1ETRD->SetXTitle("E (GeV)");
+ fhLam1ETRD->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhLam1ETRD);
fhDispETRD = new TH2F ("hDispETRD"," dispersion^{2} vs E, EMCAL SM covered by TRD", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhDispETRD->SetYTitle("Dispersion^{2}");
- fhDispETRD->SetXTitle("E (GeV) ");
+ fhDispETRD->SetXTitle("#it{E} (GeV) ");
outputContainer->Add(fhDispETRD);
if(!fRejectTrackMatch)
{
fhLam0ETMTRD = new TH2F ("hLam0ETMTRD","#lambda_{0}^{2} vs E, EMCAL SM covered by TRD, cut on track-matching residual |#Delta #eta| < 0.05, |#Delta #phi| < 0.05", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhLam0ETMTRD->SetYTitle("#lambda_{0}^{2}");
- fhLam0ETMTRD->SetXTitle("E (GeV)");
+ fhLam0ETMTRD->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhLam0ETMTRD);
fhLam1ETMTRD = new TH2F ("hLam1ETMTRD","#lambda_{1}^{2} vs E, EMCAL SM covered by TRD, cut on track-matching residual |#Delta #eta| < 0.05, |#Delta #phi| < 0.05", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhLam1ETMTRD->SetYTitle("#lambda_{1}^{2}");
- fhLam1ETMTRD->SetXTitle("E (GeV)");
+ fhLam1ETMTRD->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhLam1ETMTRD);
fhDispETMTRD = new TH2F ("hDispETMTRD"," dispersion^{2} vs E, EMCAL SM covered by TRD, cut on track-matching residual |#Delta #eta| < 0.05, |#Delta #phi| < 0.05", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhDispETMTRD->SetYTitle("Dispersion^{2}");
- fhDispETMTRD->SetXTitle("E (GeV) ");
+ fhDispETMTRD->SetXTitle("#it{E} (GeV) ");
outputContainer->Add(fhDispETMTRD);
}
}
fhNCellsLam0LowE->SetYTitle("#lambda_{0}^{2}");
outputContainer->Add(fhNCellsLam0LowE);
- fhNCellsLam0HighE = new TH2F ("hNCellsLam0HighE","N_{cells} in cluster vs #lambda_{0}^{2}, E > 2 GeV", nbins,nmin, nmax, ssbins,ssmin,ssmax);
+ fhNCellsLam0HighE = new TH2F ("hNCellsLam0HighE","N_{cells} in cluster vs #lambda_{0}^{2}, #it{E} > 2 GeV", nbins,nmin, nmax, ssbins,ssmin,ssmax);
fhNCellsLam0HighE->SetXTitle("N_{cells}");
fhNCellsLam0HighE->SetYTitle("#lambda_{0}^{2}");
outputContainer->Add(fhNCellsLam0HighE);
fhNCellsLam1LowE->SetYTitle("#lambda_{0}^{2}");
outputContainer->Add(fhNCellsLam1LowE);
- fhNCellsLam1HighE = new TH2F ("hNCellsLam1HighE","N_{cells} in cluster vs #lambda_{1}^{2}, E > 2 GeV", nbins,nmin, nmax, ssbins,ssmin,ssmax);
+ fhNCellsLam1HighE = new TH2F ("hNCellsLam1HighE","N_{cells} in cluster vs #lambda_{1}^{2}, #it{E} > 2 GeV", nbins,nmin, nmax, ssbins,ssmin,ssmax);
fhNCellsLam1HighE->SetXTitle("N_{cells}");
fhNCellsLam1HighE->SetYTitle("#lambda_{0}^{2}");
outputContainer->Add(fhNCellsLam1HighE);
fhPhiLam0LowE->SetXTitle("#phi");
outputContainer->Add(fhPhiLam0LowE);
- fhEtaLam0HighE = new TH2F ("hEtaLam0HighE","#eta vs #lambda_{0}^{2}, E > 2 GeV", netabins,etamin,etamax, ssbins,ssmin,ssmax);
+ fhEtaLam0HighE = new TH2F ("hEtaLam0HighE","#eta vs #lambda_{0}^{2}, #it{E} > 2 GeV", netabins,etamin,etamax, ssbins,ssmin,ssmax);
fhEtaLam0HighE->SetYTitle("#lambda_{0}^{2}");
fhEtaLam0HighE->SetXTitle("#eta");
outputContainer->Add(fhEtaLam0HighE);
- fhPhiLam0HighE = new TH2F ("hPhiLam0HighE","#phi vs #lambda_{0}^{2}, E > 2 GeV", nphibins,phimin,phimax, ssbins,ssmin,ssmax);
+ fhPhiLam0HighE = new TH2F ("hPhiLam0HighE","#phi vs #lambda_{0}^{2}, #it{E} > 2 GeV", nphibins,phimin,phimax, ssbins,ssmin,ssmax);
fhPhiLam0HighE->SetYTitle("#lambda_{0}^{2}");
fhPhiLam0HighE->SetXTitle("#phi");
outputContainer->Add(fhPhiLam0HighE);
fhLam1Lam0LowE->SetXTitle("#lambda_{1}^{2}");
outputContainer->Add(fhLam1Lam0LowE);
- fhLam1Lam0HighE = new TH2F ("hLam1Lam0HighE","#lambda_{0}^{2} vs #lambda_{1}^{2} in cluster of E > 2 GeV", ssbins,ssmin,ssmax, ssbins,ssmin,ssmax);
+ fhLam1Lam0HighE = new TH2F ("hLam1Lam0HighE","#lambda_{0}^{2} vs #lambda_{1}^{2} in cluster of #it{E} > 2 GeV", ssbins,ssmin,ssmax, ssbins,ssmin,ssmax);
fhLam1Lam0HighE->SetYTitle("#lambda_{0}^{2}");
fhLam1Lam0HighE->SetXTitle("#lambda_{1}^{2}");
outputContainer->Add(fhLam1Lam0HighE);
fhLam0DispLowE->SetYTitle("D^{2}");
outputContainer->Add(fhLam0DispLowE);
- fhLam0DispHighE = new TH2F ("hLam0DispHighE","#lambda_{0}^{2} vs dispersion^{2} in cluster of E > 2 GeV", ssbins,ssmin,ssmax, ssbins,ssmin,ssmax);
+ fhLam0DispHighE = new TH2F ("hLam0DispHighE","#lambda_{0}^{2} vs dispersion^{2} in cluster of #it{E} > 2 GeV", ssbins,ssmin,ssmax, ssbins,ssmin,ssmax);
fhLam0DispHighE->SetXTitle("#lambda_{0}^{2}");
fhLam0DispHighE->SetYTitle("D^{2}");
outputContainer->Add(fhLam0DispHighE);
fhDispLam1LowE->SetYTitle("#lambda_{1}^{2}");
outputContainer->Add(fhDispLam1LowE);
- fhDispLam1HighE = new TH2F ("hDispLam1HighE","Dispersion^{2} vs #lambda_{1^{2}} in cluster of E > 2 GeV", ssbins,ssmin,ssmax, ssbins,ssmin,ssmax);
+ fhDispLam1HighE = new TH2F ("hDispLam1HighE","Dispersion^{2} vs #lambda_{1^{2}} in cluster of #it{E} > 2 GeV", ssbins,ssmin,ssmax, ssbins,ssmin,ssmax);
fhDispLam1HighE->SetXTitle("D^{2}");
fhDispLam1HighE->SetYTitle("#lambda_{1}^{2}");
outputContainer->Add(fhDispLam1HighE);
if(fCalorimeter == "EMCAL")
{
fhDispEtaE = new TH2F ("hDispEtaE","#sigma^{2}_{#eta #eta} = #Sigma w_{i}(#eta_{i} - <#eta>)^{2}/ #Sigma w_{i} vs E", nptbins,ptmin,ptmax, ssbins,ssmin,ssmax);
- fhDispEtaE->SetXTitle("E (GeV)");
+ fhDispEtaE->SetXTitle("#it{E} (GeV)");
fhDispEtaE->SetYTitle("#sigma^{2}_{#eta #eta}");
outputContainer->Add(fhDispEtaE);
fhDispPhiE = new TH2F ("hDispPhiE","#sigma^{2}_{#phi #phi} = #Sigma w_{i}(#phi_{i} - <#phi>)^{2} / #Sigma w_{i} vs E", nptbins,ptmin,ptmax, ssbins,ssmin,ssmax);
- fhDispPhiE->SetXTitle("E (GeV)");
+ fhDispPhiE->SetXTitle("#it{E} (GeV)");
fhDispPhiE->SetYTitle("#sigma^{2}_{#phi #phi}");
outputContainer->Add(fhDispPhiE);
fhSumEtaE = new TH2F ("hSumEtaE","#delta^{2}_{#eta #eta} = #Sigma w_{i}(#eta_{i})^{2} / #Sigma w_{i} - <#eta>^{2} vs E", nptbins,ptmin,ptmax, ssbins,ssmin,ssmax);
- fhSumEtaE->SetXTitle("E (GeV)");
+ fhSumEtaE->SetXTitle("#it{E} (GeV)");
fhSumEtaE->SetYTitle("#delta^{2}_{#eta #eta}");
outputContainer->Add(fhSumEtaE);
fhSumPhiE = new TH2F ("hSumPhiE","#delta^{2}_{#phi #phi} = #Sigma w_{i}(#phi_{i})^{2}/ #Sigma w_{i} - <#phi>^{2} vs E",
nptbins,ptmin,ptmax, ssbins,ssmin,ssmax);
- fhSumPhiE->SetXTitle("E (GeV)");
+ fhSumPhiE->SetXTitle("#it{E} (GeV)");
fhSumPhiE->SetYTitle("#delta^{2}_{#phi #phi}");
outputContainer->Add(fhSumPhiE);
fhSumEtaPhiE = new TH2F ("hSumEtaPhiE","#delta^{2}_{#eta #phi} = #Sigma w_{i}(#phi_{i} #eta_{i} ) / #Sigma w_{i} - <#phi><#eta> vs E",
nptbins,ptmin,ptmax, 2*ssbins,-ssmax,ssmax);
- fhSumEtaPhiE->SetXTitle("E (GeV)");
+ fhSumEtaPhiE->SetXTitle("#it{E} (GeV)");
fhSumEtaPhiE->SetYTitle("#delta^{2}_{#eta #phi}");
outputContainer->Add(fhSumEtaPhiE);
fhDispEtaPhiDiffE = new TH2F ("hDispEtaPhiDiffE","#sigma^{2}_{#phi #phi} - #sigma^{2}_{#eta #eta} vs E",
nptbins,ptmin,ptmax,200, -10,10);
- fhDispEtaPhiDiffE->SetXTitle("E (GeV)");
+ fhDispEtaPhiDiffE->SetXTitle("#it{E} (GeV)");
fhDispEtaPhiDiffE->SetYTitle("#sigma^{2}_{#phi #phi}-#sigma^{2}_{#eta #eta}");
outputContainer->Add(fhDispEtaPhiDiffE);
fhSphericityE = new TH2F ("hSphericityE","(#sigma^{2}_{#phi #phi} - #sigma^{2}_{#eta #eta}) / (#sigma^{2}_{#eta #eta} + #sigma^{2}_{#phi #phi}) vs E",
nptbins,ptmin,ptmax, 200, -1,1);
- fhSphericityE->SetXTitle("E (GeV)");
+ fhSphericityE->SetXTitle("#it{E} (GeV)");
fhSphericityE->SetYTitle("s = (#sigma^{2}_{#phi #phi} - #sigma^{2}_{#eta #eta}) / (#sigma^{2}_{#eta #eta} + #sigma^{2}_{#phi #phi})");
outputContainer->Add(fhSphericityE);
fhDispSumEtaDiffE = new TH2F ("hDispSumEtaDiffE","#sigma^{2}_{#eta #eta} - #delta^{2}_{#eta #eta} / average vs E", nptbins,ptmin,ptmax, 200,-0.01,0.01);
- fhDispSumEtaDiffE->SetXTitle("E (GeV)");
+ fhDispSumEtaDiffE->SetXTitle("#it{E} (GeV)");
fhDispSumEtaDiffE->SetYTitle("#sigma^{2}_{#eta #eta} - #delta^{2}_{#eta #eta} / average");
outputContainer->Add(fhDispSumEtaDiffE);
fhDispSumPhiDiffE = new TH2F ("hDispSumPhiDiffE","#sigma^{2}_{#phi #phi} - #delta^{2}_{#phi #phi} / average vs E", nptbins,ptmin,ptmax, 200,-0.01,0.01);
- fhDispSumPhiDiffE->SetXTitle("E (GeV)");
+ fhDispSumPhiDiffE->SetXTitle("#it{E} (GeV)");
fhDispSumPhiDiffE->SetYTitle("#sigma^{2}_{#phi #phi} - #delta^{2}_{#phi #phi} / average");
outputContainer->Add(fhDispSumPhiDiffE);
Form("d#eta of cluster-track vs cluster energy, %s",cutTM[i].Data()),
nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
fhTrackMatchedDEta[i]->SetYTitle("d#eta");
- fhTrackMatchedDEta[i]->SetXTitle("E_{cluster} (GeV)");
+ fhTrackMatchedDEta[i]->SetXTitle("#it{E}_{cluster} (GeV)");
fhTrackMatchedDPhi[i] = new TH2F
(Form("hTrackMatchedDPhi%s",cutTM[i].Data()),
Form("d#phi of cluster-track vs cluster energy, %s",cutTM[i].Data()),
nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
fhTrackMatchedDPhi[i]->SetYTitle("d#phi (rad)");
- fhTrackMatchedDPhi[i]->SetXTitle("E_{cluster} (GeV)");
+ fhTrackMatchedDPhi[i]->SetXTitle("#it{E}_{cluster} (GeV)");
fhTrackMatchedDEtaDPhi[i] = new TH2F
(Form("hTrackMatchedDEtaDPhi%s",cutTM[i].Data()),
Form("d#eta of cluster-track vs cluster energy, %s",cutTM[i].Data()),
nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
fhTrackMatchedDEtaPos[i]->SetYTitle("d#eta");
- fhTrackMatchedDEtaPos[i]->SetXTitle("E_{cluster} (GeV)");
+ fhTrackMatchedDEtaPos[i]->SetXTitle("#it{E}_{cluster} (GeV)");
fhTrackMatchedDPhiPos[i] = new TH2F
(Form("hTrackMatchedDPhiPos%s",cutTM[i].Data()),
Form("d#phi of cluster-track vs cluster energy, %s",cutTM[i].Data()),
nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
fhTrackMatchedDPhiPos[i]->SetYTitle("d#phi (rad)");
- fhTrackMatchedDPhiPos[i]->SetXTitle("E_{cluster} (GeV)");
+ fhTrackMatchedDPhiPos[i]->SetXTitle("#it{E}_{cluster} (GeV)");
fhTrackMatchedDEtaDPhiPos[i] = new TH2F
(Form("hTrackMatchedDEtaDPhiPos%s",cutTM[i].Data()),
Form("d#eta of cluster-track vs cluster energy, %s",cutTM[i].Data()),
nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
fhTrackMatchedDEtaNeg[i]->SetYTitle("d#eta");
- fhTrackMatchedDEtaNeg[i]->SetXTitle("E_{cluster} (GeV)");
+ fhTrackMatchedDEtaNeg[i]->SetXTitle("#it{E}_{cluster} (GeV)");
fhTrackMatchedDPhiNeg[i] = new TH2F
(Form("hTrackMatchedDPhiNeg%s",cutTM[i].Data()),
Form("d#phi of cluster-track vs cluster energy, %s",cutTM[i].Data()),
nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
fhTrackMatchedDPhiNeg[i]->SetYTitle("d#phi (rad)");
- fhTrackMatchedDPhiNeg[i]->SetXTitle("E_{cluster} (GeV)");
+ fhTrackMatchedDPhiNeg[i]->SetXTitle("#it{E}_{cluster} (GeV)");
fhTrackMatchedDEtaDPhiNeg[i] = new TH2F
(Form("hTrackMatchedDEtaDPhiNeg%s",cutTM[i].Data()),
fhdEdx[i] = new TH2F (Form("hdEdx%s",cutTM[i].Data()),Form("matched track <dE/dx> vs cluster E, %s",cutTM[i].Data()),
nptbins,ptmin,ptmax,ndedxbins, dedxmin, dedxmax);
- fhdEdx[i]->SetXTitle("E (GeV)");
+ fhdEdx[i]->SetXTitle("#it{E} (GeV)");
fhdEdx[i]->SetYTitle("<dE/dx>");
fhEOverP[i] = new TH2F (Form("hEOverP%s",cutTM[i].Data()),Form("matched track E/p vs cluster E, %s",cutTM[i].Data()),
nptbins,ptmin,ptmax,nPoverEbins,pOverEmin,pOverEmax);
- fhEOverP[i]->SetXTitle("E (GeV)");
+ fhEOverP[i]->SetXTitle("#it{E} (GeV)");
fhEOverP[i]->SetYTitle("E/p");
outputContainer->Add(fhTrackMatchedDEta[i]) ;
Form("d#eta of cluster-track vs cluster energy, SM behind TRD, %s",cutTM[i].Data()),
nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
fhTrackMatchedDEtaTRD[i]->SetYTitle("d#eta");
- fhTrackMatchedDEtaTRD[i]->SetXTitle("E_{cluster} (GeV)");
+ fhTrackMatchedDEtaTRD[i]->SetXTitle("#it{E}_{cluster} (GeV)");
fhTrackMatchedDPhiTRD[i] = new TH2F
(Form("hTrackMatchedDPhiTRD%s",cutTM[i].Data()),
Form("d#phi of cluster-track vs cluster energy, SM behing TRD, %s",cutTM[i].Data()),
nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
fhTrackMatchedDPhiTRD[i]->SetYTitle("d#phi (rad)");
- fhTrackMatchedDPhiTRD[i]->SetXTitle("E_{cluster} (GeV)");
+ fhTrackMatchedDPhiTRD[i]->SetXTitle("#it{E}_{cluster} (GeV)");
fhEOverPTRD[i] = new TH2F
(Form("hEOverPTRD%s",cutTM[i].Data()),
Form("matched track E/p vs cluster E, behind TRD, %s",cutTM[i].Data()),
nptbins,ptmin,ptmax,nPoverEbins,pOverEmin,pOverEmax);
- fhEOverPTRD[i]->SetXTitle("E (GeV)");
+ fhEOverPTRD[i]->SetXTitle("#it{E} (GeV)");
fhEOverPTRD[i]->SetYTitle("E/p");
outputContainer->Add(fhTrackMatchedDEtaTRD[i]) ;
Form("d#eta of cluster-track vs cluster energy, no other MC particles overlap %s",cutTM[i].Data()),
nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
fhTrackMatchedDEtaMCNoOverlap[i]->SetYTitle("d#eta");
- fhTrackMatchedDEtaMCNoOverlap[i]->SetXTitle("E_{cluster} (GeV)");
+ fhTrackMatchedDEtaMCNoOverlap[i]->SetXTitle("#it{E}_{cluster} (GeV)");
fhTrackMatchedDPhiMCNoOverlap[i] = new TH2F
(Form("hTrackMatchedDPhiMCNoOverlap%s",cutTM[i].Data()),
Form("d#phi of cluster-track vs cluster energy, no other MC particles overlap %s",cutTM[i].Data()),
nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
fhTrackMatchedDPhiMCNoOverlap[i]->SetYTitle("d#phi (rad)");
- fhTrackMatchedDPhiMCNoOverlap[i]->SetXTitle("E_{cluster} (GeV)");
+ fhTrackMatchedDPhiMCNoOverlap[i]->SetXTitle("#it{E}_{cluster} (GeV)");
outputContainer->Add(fhTrackMatchedDEtaMCNoOverlap[i]) ;
outputContainer->Add(fhTrackMatchedDPhiMCNoOverlap[i]) ;
Form("d#eta of cluster-track vs cluster energy, several MC particles overlap %s",cutTM[i].Data()),
nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
fhTrackMatchedDEtaMCOverlap[i]->SetYTitle("d#eta");
- fhTrackMatchedDEtaMCOverlap[i]->SetXTitle("E_{cluster} (GeV)");
+ fhTrackMatchedDEtaMCOverlap[i]->SetXTitle("#it{E}_{cluster} (GeV)");
fhTrackMatchedDPhiMCOverlap[i] = new TH2F
(Form("hTrackMatchedDPhiMCOverlap%s",cutTM[i].Data()),
Form("d#phi of cluster-track vs cluster energy, several MC particles overlap %s",cutTM[i].Data()),
nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
fhTrackMatchedDPhiMCOverlap[i]->SetYTitle("d#phi (rad)");
- fhTrackMatchedDPhiMCOverlap[i]->SetXTitle("E_{cluster} (GeV)");
+ fhTrackMatchedDPhiMCOverlap[i]->SetXTitle("#it{E}_{cluster} (GeV)");
outputContainer->Add(fhTrackMatchedDEtaMCOverlap[i]) ;
outputContainer->Add(fhTrackMatchedDPhiMCOverlap[i]) ;
Form("d#eta of cluster-track vs cluster energy, no other MC particles overlap appart from conversions %s",cutTM[i].Data()),
nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
fhTrackMatchedDEtaMCConversion[i]->SetYTitle("d#eta");
- fhTrackMatchedDEtaMCConversion[i]->SetXTitle("E_{cluster} (GeV)");
+ fhTrackMatchedDEtaMCConversion[i]->SetXTitle("#it{E}_{cluster} (GeV)");
fhTrackMatchedDPhiMCConversion[i] = new TH2F
(Form("hTrackMatchedDPhiMCConversion%s",cutTM[i].Data()),
Form("d#phi of cluster-track vs cluster energy, no other MC particles overlap appart from conversions %s",cutTM[i].Data()),
nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
fhTrackMatchedDPhiMCConversion[i]->SetYTitle("d#phi (rad)");
- fhTrackMatchedDPhiMCConversion[i]->SetXTitle("E_{cluster} (GeV)");
+ fhTrackMatchedDPhiMCConversion[i]->SetXTitle("#it{E}_{cluster} (GeV)");
outputContainer->Add(fhTrackMatchedDEtaMCConversion[i]) ;
outputContainer->Add(fhTrackMatchedDPhiMCConversion[i]) ;
(Form("hTrackMatchedMCParticle%s",cutTM[i].Data()),
Form("Origin of particle vs energy %s",cutTM[i].Data()),
nptbins,ptmin,ptmax,8,0,8);
- fhTrackMatchedMCParticle[i]->SetXTitle("E (GeV)");
+ fhTrackMatchedMCParticle[i]->SetXTitle("#it{E} (GeV)");
//fhTrackMatchedMCParticle[i]->SetYTitle("Particle type");
fhTrackMatchedMCParticle[i]->GetYaxis()->SetBinLabel(1 ,"Photon");
for(Int_t i = 0 ; i < 7 ; i++)
{
fhPtPileUp[i] = new TH1F(Form("hPtPileUp%s",pileUpName[i].Data()),
- Form("Cluster p_{T} distribution, %s Pile-Up event",pileUpName[i].Data()), nptbins,ptmin,ptmax);
- fhPtPileUp[i]->SetXTitle("p_{T} (GeV/c)");
+ Form("Cluster #it{p}_[T] distribution, %s Pile-Up event",pileUpName[i].Data()), nptbins,ptmin,ptmax);
+ fhPtPileUp[i]->SetXTitle("#it{p}_[T] (GeV/#it{c})");
outputContainer->Add(fhPtPileUp[i]);
fhPtChargedPileUp[i] = new TH1F(Form("hPtChargedPileUp%s",pileUpName[i].Data()),
- Form("Charged clusters p_{T} distribution, %s Pile-Up event",pileUpName[i].Data()), nptbins,ptmin,ptmax);
- fhPtChargedPileUp[i]->SetXTitle("p_{T} (GeV/c)");
+ Form("Charged clusters #it{p}_[T] distribution, %s Pile-Up event",pileUpName[i].Data()), nptbins,ptmin,ptmax);
+ fhPtChargedPileUp[i]->SetXTitle("#it{p}_[T] (GeV/#it{c})");
outputContainer->Add(fhPtChargedPileUp[i]);
fhPtPhotonPileUp[i] = new TH1F(Form("hPtPhotonPileUp%s",pileUpName[i].Data()),
- Form("Selected photon p_{T} distribution, %s Pile-Up event",pileUpName[i].Data()), nptbins,ptmin,ptmax);
- fhPtPhotonPileUp[i]->SetXTitle("p_{T} (GeV/c)");
+ Form("Selected photon #it{p}_[T] distribution, %s Pile-Up event",pileUpName[i].Data()), nptbins,ptmin,ptmax);
+ fhPtPhotonPileUp[i]->SetXTitle("#it{p}_[T] (GeV/#it{c})");
outputContainer->Add(fhPtPhotonPileUp[i]);
fhClusterEFracLongTimePileUp[i] = new TH2F(Form("hClusterEFracLongTimePileUp%s",pileUpName[i].Data()),
Form("Cluster E vs fraction of cluster energy from large T cells, %s Pile-Up event",pileUpName[i].Data()),
nptbins,ptmin,ptmax,200,0,1);
- fhClusterEFracLongTimePileUp[i]->SetXTitle("E (GeV)");
+ fhClusterEFracLongTimePileUp[i]->SetXTitle("#it{E} (GeV)");
fhClusterEFracLongTimePileUp[i]->SetYTitle("E(large time) / E");
outputContainer->Add(fhClusterEFracLongTimePileUp[i]);
fhClusterCellTimePileUp[i] = new TH2F(Form("hClusterCellTimePileUp%s",pileUpName[i].Data()),
Form("Cluster E vs cell time in cluster, %s Pile-Up event",pileUpName[i].Data()),
nptbins,ptmin,ptmax,ntimebins,timemin,timemax);
- fhClusterCellTimePileUp[i]->SetXTitle("E (GeV)");
+ fhClusterCellTimePileUp[i]->SetXTitle("#it{E} (GeV)");
fhClusterCellTimePileUp[i]->SetYTitle("t_{cell} (ns)");
outputContainer->Add(fhClusterCellTimePileUp[i]);
fhClusterTimeDiffPileUp[i] = new TH2F(Form("hClusterTimeDiffPileUp%s",pileUpName[i].Data()),
Form("Cluster E vs t_{max}-t_{cell} in cluster, %s Pile-Up event",pileUpName[i].Data()),
nptbins,ptmin,ptmax,400,-200,200);
- fhClusterTimeDiffPileUp[i]->SetXTitle("E (GeV)");
+ fhClusterTimeDiffPileUp[i]->SetXTitle("#it{E} (GeV)");
fhClusterTimeDiffPileUp[i]->SetYTitle("t_{max}-t_{cell} (ns)");
outputContainer->Add(fhClusterTimeDiffPileUp[i]);
fhClusterTimeDiffChargedPileUp[i] = new TH2F(Form("hClusterTimeDiffChargedPileUp%s",pileUpName[i].Data()),
Form("Charged clusters E vs t_{max}-t_{cell} in cluster, %s Pile-Up event",pileUpName[i].Data()),
nptbins,ptmin,ptmax,400,-200,200);
- fhClusterTimeDiffChargedPileUp[i]->SetXTitle("E (GeV)");
+ fhClusterTimeDiffChargedPileUp[i]->SetXTitle("#it{E} (GeV)");
fhClusterTimeDiffChargedPileUp[i]->SetYTitle("t_{max}-t_{cell} (ns)");
outputContainer->Add(fhClusterTimeDiffChargedPileUp[i]);
fhClusterTimeDiffPhotonPileUp[i] = new TH2F(Form("hClusterTimeDiffPhotonPileUp%s",pileUpName[i].Data()),
Form("Selected photon E vs t_{max}-t_{cell} in cluster, %s Pile-Up event",pileUpName[i].Data()),
nptbins,ptmin,ptmax,400,-200,200);
- fhClusterTimeDiffPhotonPileUp[i]->SetXTitle("E (GeV)");
+ fhClusterTimeDiffPhotonPileUp[i]->SetXTitle("#it{E} (GeV)");
fhClusterTimeDiffPhotonPileUp[i]->SetYTitle("t_{max}-t_{cell} (ns)");
outputContainer->Add(fhClusterTimeDiffPhotonPileUp[i]);
fhLambda0PileUp[i] = new TH2F(Form("hLambda0PileUp%s",pileUpName[i].Data()),
Form("Cluster E vs #lambda^{2}_{0} in cluster, %s Pile-Up event",pileUpName[i].Data()),
nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
- fhLambda0PileUp[i]->SetXTitle("E (GeV)");
+ fhLambda0PileUp[i]->SetXTitle("#it{E} (GeV)");
fhLambda0PileUp[i]->SetYTitle("#lambda^{2}_{0}");
outputContainer->Add(fhLambda0PileUp[i]);
fhLambda0ChargedPileUp[i] = new TH2F(Form("hLambda0ChargedPileUp%s",pileUpName[i].Data()),
Form("Charged clusters E vs #lambda^{2}_{0}in cluster, %s Pile-Up event",pileUpName[i].Data()), nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
- fhLambda0ChargedPileUp[i]->SetXTitle("E (GeV)");
+ fhLambda0ChargedPileUp[i]->SetXTitle("#it{E} (GeV)");
fhLambda0ChargedPileUp[i]->SetYTitle("#lambda^{2}_{0}");
outputContainer->Add(fhLambda0ChargedPileUp[i]);
outputContainer->Add(fhEtaPhiBCMinusPileUpSPD);
fhTimePtNoCut = new TH2F ("hTimePt_NoCut","time of cluster vs pT of clusters, no cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimePtNoCut->SetXTitle("p_{T} (GeV/c)");
- fhTimePtNoCut->SetYTitle("time (ns)");
+ fhTimePtNoCut->SetXTitle("#it{p}_[T] (GeV/#it{c})");
+ fhTimePtNoCut->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimePtNoCut);
fhTimePtSPD = new TH2F ("hTimePt_SPD","time of cluster vs pT of clusters, SPD cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimePtSPD->SetXTitle("p_{T} (GeV/c)");
- fhTimePtSPD->SetYTitle("time (ns)");
+ fhTimePtSPD->SetXTitle("#it{p}_[T] (GeV/#it{c})");
+ fhTimePtSPD->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimePtSPD);
fhTimePtPhotonNoCut = new TH2F ("hTimePtPhoton_NoCut","time of photon cluster vs pT of clusters, no cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimePtPhotonNoCut->SetXTitle("p_{T} (GeV/c)");
- fhTimePtPhotonNoCut->SetYTitle("time (ns)");
+ fhTimePtPhotonNoCut->SetXTitle("#it{p}_[T] (GeV/#it{c})");
+ fhTimePtPhotonNoCut->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimePtPhotonNoCut);
fhTimePtPhotonSPD = new TH2F ("hTimePtPhoton_SPD","time of photon cluster vs pT of clusters, SPD cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimePtPhotonSPD->SetXTitle("p_{T} (GeV/c)");
- fhTimePtPhotonSPD->SetYTitle("time (ns)");
+ fhTimePtPhotonSPD->SetXTitle("#it{p}_[T] (GeV/#it{c})");
+ fhTimePtPhotonSPD->SetYTitle("#it{time} (ns)");
outputContainer->Add(fhTimePtPhotonSPD);
fhTimeNPileUpVertSPD = new TH2F ("hTime_NPileUpVertSPD","time of cluster vs N pile-up SPD vertex", ntimebins,timemin,timemax,20,0,20);
fhTimeNPileUpVertSPD->SetYTitle("# vertex ");
- fhTimeNPileUpVertSPD->SetXTitle("time (ns)");
+ fhTimeNPileUpVertSPD->SetXTitle("#it{time} (ns)");
outputContainer->Add(fhTimeNPileUpVertSPD);
fhTimeNPileUpVertTrack = new TH2F ("hTime_NPileUpVertTracks","time of cluster vs N pile-up Tracks vertex", ntimebins,timemin,timemax, 20,0,20 );
fhTimeNPileUpVertTrack->SetYTitle("# vertex ");
- fhTimeNPileUpVertTrack->SetXTitle("time (ns)");
+ fhTimeNPileUpVertTrack->SetXTitle("#it{time} (ns)");
outputContainer->Add(fhTimeNPileUpVertTrack);
fhTimeNPileUpVertContributors = new TH2F ("hTime_NPileUpVertContributors","time of cluster vs N constributors to pile-up SPD vertex", ntimebins,timemin,timemax,50,0,50);
fhTimeNPileUpVertContributors->SetYTitle("# vertex ");
- fhTimeNPileUpVertContributors->SetXTitle("time (ns)");
+ fhTimeNPileUpVertContributors->SetXTitle("#it{time} (ns)");
outputContainer->Add(fhTimeNPileUpVertContributors);
fhTimePileUpMainVertexZDistance = new TH2F ("hTime_PileUpMainVertexZDistance","time of cluster vs distance in Z pile-up SPD vertex - main SPD vertex",ntimebins,timemin,timemax,100,0,50);
fhTimePileUpMainVertexZDistance->SetYTitle("distance Z (cm) ");
- fhTimePileUpMainVertexZDistance->SetXTitle("time (ns)");
+ fhTimePileUpMainVertexZDistance->SetXTitle("#it{time} (ns)");
outputContainer->Add(fhTimePileUpMainVertexZDistance);
fhTimePileUpMainVertexZDiamond = new TH2F ("hTime_PileUpMainVertexZDiamond","time of cluster vs distance in Z pile-up SPD vertex - z diamond",ntimebins,timemin,timemax,100,0,50);
fhTimePileUpMainVertexZDiamond->SetYTitle("diamond distance Z (cm) ");
- fhTimePileUpMainVertexZDiamond->SetXTitle("time (ns)");
+ fhTimePileUpMainVertexZDiamond->SetXTitle("#it{time} (ns)");
outputContainer->Add(fhTimePileUpMainVertexZDiamond);
TString title[] = {"no |t diff| cut","|t diff|<20 ns","|t diff|>20 ns","|t diff|>40 ns"};
for(Int_t i = 0; i < 4; i++)
{
fhClusterMultSPDPileUp[i] = new TH2F(Form("fhClusterMultSPDPileUp_%s", name[i].Data()),
- Form("Number of clusters per pile up event with E > 0.5 and %s respect cluster max vs cluster max E ",title[i].Data()),
+ Form("Number of clusters per pile up event with #it{E} > 0.5 and %s respect cluster max vs cluster max E ",title[i].Data()),
nptbins,ptmin,ptmax,100,0,100);
fhClusterMultSPDPileUp[i]->SetYTitle("n clusters ");
- fhClusterMultSPDPileUp[i]->SetXTitle("E_{cluster max} (GeV)");
+ fhClusterMultSPDPileUp[i]->SetXTitle("#it{E}_{cluster max} (GeV)");
outputContainer->Add(fhClusterMultSPDPileUp[i]) ;
fhClusterMultNoPileUp[i] = new TH2F(Form("fhClusterMultNoPileUp_%s", name[i].Data()),
- Form("Number of clusters per non pile up event with E > 0.5 and %s respect cluster max vs cluster max E ",title[i].Data()),
+ Form("Number of clusters per non pile up event with #it{E} > 0.5 and %s respect cluster max vs cluster max E ",title[i].Data()),
nptbins,ptmin,ptmax,100,0,100);
fhClusterMultNoPileUp[i]->SetYTitle("n clusters ");
- fhClusterMultNoPileUp[i]->SetXTitle("E_{cluster max} (GeV)");
+ fhClusterMultNoPileUp[i]->SetXTitle("#it{E}_{cluster max} (GeV)");
outputContainer->Add(fhClusterMultNoPileUp[i]) ;
}
fhPtNPileUpSPDVtx = new TH2F ("hPt_NPileUpVertSPD","pT of cluster vs N pile-up SPD vertex",
nptbins,ptmin,ptmax,20,0,20);
fhPtNPileUpSPDVtx->SetYTitle("# vertex ");
- fhPtNPileUpSPDVtx->SetXTitle("p_{T} (GeV/c)");
+ fhPtNPileUpSPDVtx->SetXTitle("#it{p}_[T] (GeV/#it{c})");
outputContainer->Add(fhPtNPileUpSPDVtx);
fhPtNPileUpTrkVtx = new TH2F ("hPt_NPileUpVertTracks","pT of cluster vs N pile-up Tracks vertex",
nptbins,ptmin,ptmax, 20,0,20 );
fhPtNPileUpTrkVtx->SetYTitle("# vertex ");
- fhPtNPileUpTrkVtx->SetXTitle("p_{T} (GeV/c)");
+ fhPtNPileUpTrkVtx->SetXTitle("#it{p}_[T] (GeV/#it{c})");
outputContainer->Add(fhPtNPileUpTrkVtx);
fhPtNPileUpSPDVtxTimeCut = new TH2F ("hPt_NPileUpVertSPD_TimeCut","pT of cluster vs N pile-up SPD vertex, |tof| < 25 ns",
nptbins,ptmin,ptmax,20,0,20);
fhPtNPileUpSPDVtxTimeCut->SetYTitle("# vertex ");
- fhPtNPileUpSPDVtxTimeCut->SetXTitle("p_{T} (GeV/c)");
+ fhPtNPileUpSPDVtxTimeCut->SetXTitle("#it{p}_[T] (GeV/#it{c})");
outputContainer->Add(fhPtNPileUpSPDVtxTimeCut);
fhPtNPileUpTrkVtxTimeCut = new TH2F ("hPt_NPileUpVertTracks_TimeCut","pT of cluster vs N pile-up Tracks vertex, |tof| < 25 ns",
nptbins,ptmin,ptmax, 20,0,20 );
fhPtNPileUpTrkVtxTimeCut->SetYTitle("# vertex ");
- fhPtNPileUpTrkVtxTimeCut->SetXTitle("p_{T} (GeV/c)");
+ fhPtNPileUpTrkVtxTimeCut->SetXTitle("#it{p}_[T] (GeV/#it{c})");
outputContainer->Add(fhPtNPileUpTrkVtxTimeCut);
fhPtNPileUpSPDVtxTimeCut2 = new TH2F ("hPt_NPileUpVertSPD_TimeCut2","pT of cluster vs N pile-up SPD vertex, -25 < tof < 75 ns",
nptbins,ptmin,ptmax,20,0,20);
fhPtNPileUpSPDVtxTimeCut2->SetYTitle("# vertex ");
- fhPtNPileUpSPDVtxTimeCut2->SetXTitle("p_{T} (GeV/c)");
+ fhPtNPileUpSPDVtxTimeCut2->SetXTitle("#it{p}_[T] (GeV/#it{c})");
outputContainer->Add(fhPtNPileUpSPDVtxTimeCut2);
fhPtNPileUpTrkVtxTimeCut2 = new TH2F ("hPt_NPileUpVertTracks_TimeCut2","pT of cluster vs N pile-up Tracks vertex, -25 < tof < 75 ns",
nptbins,ptmin,ptmax, 20,0,20 );
fhPtNPileUpTrkVtxTimeCut2->SetYTitle("# vertex ");
- fhPtNPileUpTrkVtxTimeCut2->SetXTitle("p_{T} (GeV/c)");
+ fhPtNPileUpTrkVtxTimeCut2->SetXTitle("#it{p}_[T] (GeV/#it{c})");
outputContainer->Add(fhPtNPileUpTrkVtxTimeCut2);
fhPtPhotonNPileUpSPDVtx = new TH2F ("hPtPhoton_NPileUpVertSPD","pT of cluster vs N pile-up SPD vertex",
nptbins,ptmin,ptmax,20,0,20);
fhPtPhotonNPileUpSPDVtx->SetYTitle("# vertex ");
- fhPtPhotonNPileUpSPDVtx->SetXTitle("p_{T} (GeV/c)");
+ fhPtPhotonNPileUpSPDVtx->SetXTitle("#it{p}_[T] (GeV/#it{c})");
outputContainer->Add(fhPtPhotonNPileUpSPDVtx);
fhPtPhotonNPileUpTrkVtx = new TH2F ("hPtPhoton_NPileUpVertTracks","pT of cluster vs N pile-up Tracks vertex",
nptbins,ptmin,ptmax, 20,0,20 );
fhPtPhotonNPileUpTrkVtx->SetYTitle("# vertex ");
- fhPtPhotonNPileUpTrkVtx->SetXTitle("p_{T} (GeV/c)");
+ fhPtPhotonNPileUpTrkVtx->SetXTitle("#it{p}_[T] (GeV/#it{c})");
outputContainer->Add(fhPtPhotonNPileUpTrkVtx);
fhPtPhotonNPileUpSPDVtxTimeCut = new TH2F ("hPtPhoton_NPileUpVertSPD_TimeCut","pT of cluster vs N pile-up SPD vertex, |tof| < 25 ns",
nptbins,ptmin,ptmax,20,0,20);
fhPtPhotonNPileUpSPDVtxTimeCut->SetYTitle("# vertex ");
- fhPtPhotonNPileUpSPDVtxTimeCut->SetXTitle("p_{T} (GeV/c)");
+ fhPtPhotonNPileUpSPDVtxTimeCut->SetXTitle("#it{p}_[T] (GeV/#it{c})");
outputContainer->Add(fhPtPhotonNPileUpSPDVtxTimeCut);
fhPtPhotonNPileUpTrkVtxTimeCut = new TH2F ("hPtPhoton_NPileUpVertTracks_TimeCut","pT of cluster vs N pile-up Tracks vertex, |tof| < 25 ns",
nptbins,ptmin,ptmax, 20,0,20 );
fhPtPhotonNPileUpTrkVtxTimeCut->SetYTitle("# vertex ");
- fhPtPhotonNPileUpTrkVtxTimeCut->SetXTitle("p_{T} (GeV/c)");
+ fhPtPhotonNPileUpTrkVtxTimeCut->SetXTitle("#it{p}_[T] (GeV/#it{c})");
outputContainer->Add(fhPtPhotonNPileUpTrkVtxTimeCut);
fhPtPhotonNPileUpSPDVtxTimeCut2 = new TH2F ("hPtPhoton_NPileUpVertSPD_TimeCut2","pT of cluster vs N pile-up SPD vertex, -25 < tof < 75 ns",
nptbins,ptmin,ptmax,20,0,20);
fhPtPhotonNPileUpSPDVtxTimeCut2->SetYTitle("# vertex ");
- fhPtPhotonNPileUpSPDVtxTimeCut2->SetXTitle("p_{T} (GeV/c)");
+ fhPtPhotonNPileUpSPDVtxTimeCut2->SetXTitle("#it{p}_[T] (GeV/#it{c})");
outputContainer->Add(fhPtPhotonNPileUpSPDVtxTimeCut2);
fhPtPhotonNPileUpTrkVtxTimeCut2 = new TH2F ("hPtPhoton_NPileUpVertTracks_TimeCut2","pT of cluster vs N pile-up Tracks vertex, -25 < tof < 75 ns",
nptbins,ptmin,ptmax, 20,0,20 );
fhPtPhotonNPileUpTrkVtxTimeCut2->SetYTitle("# vertex ");
- fhPtPhotonNPileUpTrkVtxTimeCut2->SetXTitle("p_{T} (GeV/c)");
+ fhPtPhotonNPileUpTrkVtxTimeCut2->SetXTitle("#it{p}_[T] (GeV/#it{c})");
outputContainer->Add(fhPtPhotonNPileUpTrkVtxTimeCut2);
}
fhMCE[i] = new TH1F(Form("hE_MC%s",pname[i].Data()),
Form("cluster from %s : E ",ptype[i].Data()),
nptbins,ptmin,ptmax);
- fhMCE[i]->SetXTitle("E (GeV)");
+ fhMCE[i]->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhMCE[i]) ;
fhMCPt[i] = new TH1F(Form("hPt_MC%s",pname[i].Data()),
- Form("cluster from %s : p_{T} ",ptype[i].Data()),
+ Form("cluster from %s : #it{p}_[T] ",ptype[i].Data()),
nptbins,ptmin,ptmax);
- fhMCPt[i]->SetXTitle("p_{T} (GeV/c)");
+ fhMCPt[i]->SetXTitle("#it{p}_[T] (GeV/#it{c})");
outputContainer->Add(fhMCPt[i]) ;
fhMCEta[i] = new TH2F(Form("hEta_MC%s",pname[i].Data()),
Form("cluster from %s : #eta ",ptype[i].Data()),
nptbins,ptmin,ptmax,netabins,etamin,etamax);
fhMCEta[i]->SetYTitle("#eta");
- fhMCEta[i]->SetXTitle("E (GeV)");
+ fhMCEta[i]->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhMCEta[i]) ;
fhMCPhi[i] = new TH2F(Form("hPhi_MC%s",pname[i].Data()),
Form("cluster from %s : #phi ",ptype[i].Data()),
nptbins,ptmin,ptmax,nphibins,phimin,phimax);
fhMCPhi[i]->SetYTitle("#phi (rad)");
- fhMCPhi[i]->SetXTitle("E (GeV)");
+ fhMCPhi[i]->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhMCPhi[i]) ;
fhMCDeltaE[i] = new TH2F (Form("hDeltaE_MC%s",pname[i].Data()),
Form("MC - Reco E from %s",pname[i].Data()),
nptbins,ptmin,ptmax, 200,-50,50);
- fhMCDeltaE[i]->SetYTitle("#Delta E (GeV)");
- fhMCDeltaE[i]->SetXTitle("E (GeV)");
+ fhMCDeltaE[i]->SetYTitle("#Delta #it{E} (GeV)");
+ fhMCDeltaE[i]->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhMCDeltaE[i]);
fhMCDeltaPt[i] = new TH2F (Form("hDeltaPt_MC%s",pname[i].Data()),
- Form("MC - Reco p_{T} from %s",pname[i].Data()),
+ Form("MC - Reco #it{p}_[T] from %s",pname[i].Data()),
nptbins,ptmin,ptmax, 200,-50,50);
- fhMCDeltaPt[i]->SetXTitle("p_{T,rec} (GeV/c)");
- fhMCDeltaPt[i]->SetYTitle("#Delta p_{T} (GeV/c)");
+ fhMCDeltaPt[i]->SetXTitle("p_{T,rec} (GeV/#it{c})");
+ fhMCDeltaPt[i]->SetYTitle("#Delta #it{p}_[T] (GeV/#it{c})");
outputContainer->Add(fhMCDeltaPt[i]);
fhMC2E[i] = new TH2F (Form("h2E_MC%s",pname[i].Data()),
Form("E distribution, reconstructed vs generated from %s",pname[i].Data()),
nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
- fhMC2E[i]->SetXTitle("E_{rec} (GeV)");
- fhMC2E[i]->SetYTitle("E_{gen} (GeV)");
+ fhMC2E[i]->SetXTitle("#it{E}_{rec} (GeV)");
+ fhMC2E[i]->SetYTitle("#it{E}_{gen} (GeV)");
outputContainer->Add(fhMC2E[i]);
fhMC2Pt[i] = new TH2F (Form("h2Pt_MC%s",pname[i].Data()),
Form("p_T distribution, reconstructed vs generated from %s",pname[i].Data()),
nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
- fhMC2Pt[i]->SetXTitle("p_{T,rec} (GeV/c)");
- fhMC2Pt[i]->SetYTitle("p_{T,gen} (GeV/c)");
+ fhMC2Pt[i]->SetXTitle("p_{T,rec} (GeV/#it{c})");
+ fhMC2Pt[i]->SetYTitle("p_{T,gen} (GeV/#it{c})");
outputContainer->Add(fhMC2Pt[i]);
fhEPrimMC[i] = new TH1F(Form("hEPrim_MC%s",ppname[i].Data()),
Form("primary photon %s : E ",pptype[i].Data()),
nptbins,ptmin,ptmax);
- fhEPrimMC[i]->SetXTitle("E (GeV)");
+ fhEPrimMC[i]->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhEPrimMC[i]) ;
fhPtPrimMC[i] = new TH1F(Form("hPtPrim_MC%s",ppname[i].Data()),
- Form("primary photon %s : p_{T} ",pptype[i].Data()),
+ Form("primary photon %s : #it{p}_[T] ",pptype[i].Data()),
nptbins,ptmin,ptmax);
- fhPtPrimMC[i]->SetXTitle("p_{T} (GeV/c)");
+ fhPtPrimMC[i]->SetXTitle("#it{p}_[T] (GeV/#it{c})");
outputContainer->Add(fhPtPrimMC[i]) ;
fhYPrimMC[i] = new TH2F(Form("hYPrim_MC%s",ppname[i].Data()),
Form("primary photon %s : Rapidity ",pptype[i].Data()),
nptbins,ptmin,ptmax,200,-2,2);
fhYPrimMC[i]->SetYTitle("Rapidity");
- fhYPrimMC[i]->SetXTitle("E (GeV)");
+ fhYPrimMC[i]->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhYPrimMC[i]) ;
fhEtaPrimMC[i] = new TH2F(Form("hEtaPrim_MC%s",ppname[i].Data()),
Form("primary photon %s : #eta",pptype[i].Data()),
nptbins,ptmin,ptmax,200,-2,2);
fhEtaPrimMC[i]->SetYTitle("#eta");
- fhEtaPrimMC[i]->SetXTitle("E (GeV)");
+ fhEtaPrimMC[i]->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhEtaPrimMC[i]) ;
fhPhiPrimMC[i] = new TH2F(Form("hPhiPrim_MC%s",ppname[i].Data()),
Form("primary photon %s : #phi ",pptype[i].Data()),
nptbins,ptmin,ptmax,nphibins,0,TMath::TwoPi());
fhPhiPrimMC[i]->SetYTitle("#phi (rad)");
- fhPhiPrimMC[i]->SetXTitle("E (GeV)");
+ fhPhiPrimMC[i]->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhPhiPrimMC[i]) ;
fhEPrimMCAcc[i] = new TH1F(Form("hEPrimAcc_MC%s",ppname[i].Data()),
Form("primary photon %s in acceptance: E ",pptype[i].Data()),
nptbins,ptmin,ptmax);
- fhEPrimMCAcc[i]->SetXTitle("E (GeV)");
+ fhEPrimMCAcc[i]->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhEPrimMCAcc[i]) ;
fhPtPrimMCAcc[i] = new TH1F(Form("hPtPrimAcc_MC%s",ppname[i].Data()),
- Form("primary photon %s in acceptance: p_{T} ",pptype[i].Data()),
+ Form("primary photon %s in acceptance: #it{p}_[T] ",pptype[i].Data()),
nptbins,ptmin,ptmax);
- fhPtPrimMCAcc[i]->SetXTitle("p_{T} (GeV/c)");
+ fhPtPrimMCAcc[i]->SetXTitle("#it{p}_[T] (GeV/#it{c})");
outputContainer->Add(fhPtPrimMCAcc[i]) ;
fhYPrimMCAcc[i] = new TH2F(Form("hYPrimAcc_MC%s",ppname[i].Data()),
Form("primary photon %s in acceptance: Rapidity ",pptype[i].Data()),
nptbins,ptmin,ptmax,100,-1,1);
fhYPrimMCAcc[i]->SetYTitle("Rapidity");
- fhYPrimMCAcc[i]->SetXTitle("E (GeV)");
+ fhYPrimMCAcc[i]->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhYPrimMCAcc[i]) ;
fhEtaPrimMCAcc[i] = new TH2F(Form("hEtaPrimAcc_MC%s",ppname[i].Data()),
Form("primary photon %s in acceptance: #eta ",pptype[i].Data()),
nptbins,ptmin,ptmax,netabins,etamin,etamax);
fhEtaPrimMCAcc[i]->SetYTitle("#eta");
- fhEtaPrimMCAcc[i]->SetXTitle("E (GeV)");
+ fhEtaPrimMCAcc[i]->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhEtaPrimMCAcc[i]) ;
fhPhiPrimMCAcc[i] = new TH2F(Form("hPhiPrimAcc_MC%s",ppname[i].Data()),
Form("primary photon %s in acceptance: #phi ",pptype[i].Data()),
nptbins,ptmin,ptmax,nphibins,phimin,phimax);
fhPhiPrimMCAcc[i]->SetYTitle("#phi (rad)");
- fhPhiPrimMCAcc[i]->SetXTitle("E (GeV)");
+ fhPhiPrimMCAcc[i]->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhPhiPrimMCAcc[i]) ;
}
Form("cluster from %s : E vs #lambda_{0}^{2}",ptypess[i].Data()),
nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhMCELambda0[i]->SetYTitle("#lambda_{0}^{2}");
- fhMCELambda0[i]->SetXTitle("E (GeV)");
+ fhMCELambda0[i]->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhMCELambda0[i]) ;
fhMCELambda1[i] = new TH2F(Form("hELambda1_MC%s",pnamess[i].Data()),
Form("cluster from %s : E vs #lambda_{1}^{2}",ptypess[i].Data()),
nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhMCELambda1[i]->SetYTitle("#lambda_{1}^{2}");
- fhMCELambda1[i]->SetXTitle("E (GeV)");
+ fhMCELambda1[i]->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhMCELambda1[i]) ;
fhMCEDispersion[i] = new TH2F(Form("hEDispersion_MC%s",pnamess[i].Data()),
Form("cluster from %s : E vs dispersion^{2}",ptypess[i].Data()),
nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhMCEDispersion[i]->SetYTitle("D^{2}");
- fhMCEDispersion[i]->SetXTitle("E (GeV)");
+ fhMCEDispersion[i]->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhMCEDispersion[i]) ;
fhMCNCellsE[i] = new TH2F (Form("hNCellsE_MC%s",pnamess[i].Data()),
Form("# of cells in cluster from %s vs E of clusters",ptypess[i].Data()),
nptbins,ptmin,ptmax, nbins,nmin,nmax);
- fhMCNCellsE[i]->SetXTitle("E (GeV)");
+ fhMCNCellsE[i]->SetXTitle("#it{E} (GeV)");
fhMCNCellsE[i]->SetYTitle("# of cells in cluster");
outputContainer->Add(fhMCNCellsE[i]);
fhMCMaxCellDiffClusterE[i] = new TH2F (Form("hMaxCellDiffClusterE_MC%s",pnamess[i].Data()),
Form("energy vs difference of cluster energy from %s - max cell energy / cluster energy, good clusters",ptypess[i].Data()),
nptbins,ptmin,ptmax, 500,0,1.);
- fhMCMaxCellDiffClusterE[i]->SetXTitle("E_{cluster} (GeV) ");
- fhMCMaxCellDiffClusterE[i]->SetYTitle("(E_{cluster} - E_{cell max})/ E_{cluster}");
+ fhMCMaxCellDiffClusterE[i]->SetXTitle("#it{E}_{cluster} (GeV) ");
+ fhMCMaxCellDiffClusterE[i]->SetYTitle("(#it{E}_{cluster} - #it{E}_{cell max})/ #it{E}_{cluster}");
outputContainer->Add(fhMCMaxCellDiffClusterE[i]);
if(!fFillOnlySimpleSSHisto)
Form("cluster from %s : #lambda^{2}_{0} vs fraction of energy carried by max cell, E < 2 GeV",ptypess[i].Data()),
ssbins,ssmin,ssmax,500,0,1.);
fhMCLambda0vsClusterMaxCellDiffE0[i]->SetXTitle("#lambda_{0}^{2}");
- fhMCLambda0vsClusterMaxCellDiffE0[i]->SetYTitle("(E_{cluster} - E_{cell max})/ E_{cluster}");
+ fhMCLambda0vsClusterMaxCellDiffE0[i]->SetYTitle("(#it{E}_{cluster} - #it{E}_{cell max})/ #it{E}_{cluster}");
outputContainer->Add(fhMCLambda0vsClusterMaxCellDiffE0[i]) ;
fhMCLambda0vsClusterMaxCellDiffE2[i] = new TH2F(Form("hLambda0vsClusterMaxCellDiffE2_MC%s",pnamess[i].Data()),
Form("cluster from %s : #lambda^{2}_{0} vs fraction of energy carried by max cell, 2< E < 6 GeV",ptypess[i].Data()),
ssbins,ssmin,ssmax,500,0,1.);
fhMCLambda0vsClusterMaxCellDiffE2[i]->SetXTitle("#lambda_{0}^{2}");
- fhMCLambda0vsClusterMaxCellDiffE2[i]->SetYTitle("(E_{cluster} - E_{cell max})/ E_{cluster}");
+ fhMCLambda0vsClusterMaxCellDiffE2[i]->SetYTitle("(#it{E}_{cluster} - #it{E}_{cell max})/ #it{E}_{cluster}");
outputContainer->Add(fhMCLambda0vsClusterMaxCellDiffE2[i]) ;
fhMCLambda0vsClusterMaxCellDiffE6[i] = new TH2F(Form("hLambda0vsClusterMaxCellDiffE6_MC%s",pnamess[i].Data()),
- Form("cluster from %s : #lambda^{2}_{0} vs fraction of energy carried by max cell, E > 6 GeV",ptypess[i].Data()),
+ Form("cluster from %s : #lambda^{2}_{0} vs fraction of energy carried by max cell, #it{E} > 6 GeV",ptypess[i].Data()),
ssbins,ssmin,ssmax,500,0,1.);
fhMCLambda0vsClusterMaxCellDiffE6[i]->SetXTitle("#lambda_{0}^{2}");
- fhMCLambda0vsClusterMaxCellDiffE6[i]->SetYTitle("(E_{cluster} - E_{cell max})/ E_{cluster}");
+ fhMCLambda0vsClusterMaxCellDiffE6[i]->SetYTitle("(#it{E}_{cluster} - #it{E}_{cell max})/ #it{E}_{cluster}");
outputContainer->Add(fhMCLambda0vsClusterMaxCellDiffE6[i]) ;
fhMCNCellsvsClusterMaxCellDiffE0[i] = new TH2F(Form("hNCellsvsClusterMaxCellDiffE0_MC%s",pnamess[i].Data()),
Form("cluster from %s : N cells in cluster vs fraction of energy carried by max cell, E < 2 GeV",ptypess[i].Data()),
nbins/5,nmin,nmax/5,500,0,1.);
fhMCNCellsvsClusterMaxCellDiffE0[i]->SetXTitle("N cells in cluster");
- fhMCNCellsvsClusterMaxCellDiffE0[i]->SetYTitle("(E_{cluster} - E_{cell max})/ E_{cluster}");
+ fhMCNCellsvsClusterMaxCellDiffE0[i]->SetYTitle("(#it{E}_{cluster} - #it{E}_{cell max})/ #it{E}_{cluster}");
outputContainer->Add(fhMCNCellsvsClusterMaxCellDiffE0[i]) ;
fhMCNCellsvsClusterMaxCellDiffE2[i] = new TH2F(Form("hNCellsvsClusterMaxCellDiffE2_MC%s",pnamess[i].Data()),
Form("cluster from %s : N cells in cluster vs fraction of energy carried by max cell, 2< E < 6 GeV",ptypess[i].Data()),
nbins/5,nmin,nmax/5,500,0,1.);
fhMCNCellsvsClusterMaxCellDiffE2[i]->SetXTitle("N cells in cluster");
- fhMCNCellsvsClusterMaxCellDiffE2[i]->SetYTitle("(E_{cluster} - E_{cell max})/ E_{cluster}");
+ fhMCNCellsvsClusterMaxCellDiffE2[i]->SetYTitle("(#it{E}_{cluster} - #it{E}_{cell max})/ #it{E}_{cluster}");
outputContainer->Add(fhMCNCellsvsClusterMaxCellDiffE2[i]) ;
fhMCNCellsvsClusterMaxCellDiffE6[i] = new TH2F(Form("hNCellsvsClusterMaxCellDiffE6_MC%s",pnamess[i].Data()),
- Form("cluster from %s : N cells in cluster vs fraction of energy carried by max cell, E > 6 GeV",ptypess[i].Data()),
+ Form("cluster from %s : N cells in cluster vs fraction of energy carried by max cell, #it{E} > 6 GeV",ptypess[i].Data()),
nbins/5,nmin,nmax/5,500,0,1.);
fhMCNCellsvsClusterMaxCellDiffE6[i]->SetXTitle("N cells in cluster");
- fhMCNCellsvsClusterMaxCellDiffE6[i]->SetYTitle("E (GeV)");
+ fhMCNCellsvsClusterMaxCellDiffE6[i]->SetYTitle("#it{E} (GeV)");
outputContainer->Add(fhMCNCellsvsClusterMaxCellDiffE6[i]) ;
if(fCalorimeter=="EMCAL")
fhMCEDispEta[i] = new TH2F (Form("hEDispEtaE_MC%s",pnamess[i].Data()),
Form("cluster from %s : #sigma^{2}_{#eta #eta} = #Sigma w_{i}(#eta_{i} - <#eta>)^{2}/ #Sigma w_{i} vs E",ptypess[i].Data()),
nptbins,ptmin,ptmax, ssbins,ssmin,ssmax);
- fhMCEDispEta[i]->SetXTitle("E (GeV)");
+ fhMCEDispEta[i]->SetXTitle("#it{E} (GeV)");
fhMCEDispEta[i]->SetYTitle("#sigma^{2}_{#eta #eta}");
outputContainer->Add(fhMCEDispEta[i]);
fhMCEDispPhi[i] = new TH2F (Form("hEDispPhiE_MC%s",pnamess[i].Data()),
Form("cluster from %s : #sigma^{2}_{#phi #phi} = #Sigma w_{i}(#phi_{i} - <#phi>)^{2} / #Sigma w_{i} vs E",ptypess[i].Data()),
nptbins,ptmin,ptmax, ssbins,ssmin,ssmax);
- fhMCEDispPhi[i]->SetXTitle("E (GeV)");
+ fhMCEDispPhi[i]->SetXTitle("#it{E} (GeV)");
fhMCEDispPhi[i]->SetYTitle("#sigma^{2}_{#phi #phi}");
outputContainer->Add(fhMCEDispPhi[i]);
fhMCESumEtaPhi[i] = new TH2F (Form("hESumEtaPhiE_MC%s",pnamess[i].Data()),
Form("cluster from %s : #delta^{2}_{#eta #phi} = #Sigma w_{i}(#phi_{i} #eta_{i} ) / #Sigma w_{i} - <#phi><#eta> vs E",ptypess[i].Data()),
nptbins,ptmin,ptmax, 2*ssbins,-ssmax,ssmax);
- fhMCESumEtaPhi[i]->SetXTitle("E (GeV)");
+ fhMCESumEtaPhi[i]->SetXTitle("#it{E} (GeV)");
fhMCESumEtaPhi[i]->SetYTitle("#delta^{2}_{#eta #phi}");
outputContainer->Add(fhMCESumEtaPhi[i]);
fhMCEDispEtaPhiDiff[i] = new TH2F (Form("hEDispEtaPhiDiffE_MC%s",pnamess[i].Data()),
Form("cluster from %s : #sigma^{2}_{#phi #phi} - #sigma^{2}_{#eta #eta} vs E",ptypess[i].Data()),
nptbins,ptmin,ptmax,200,-10,10);
- fhMCEDispEtaPhiDiff[i]->SetXTitle("E (GeV)");
+ fhMCEDispEtaPhiDiff[i]->SetXTitle("#it{E} (GeV)");
fhMCEDispEtaPhiDiff[i]->SetYTitle("#sigma^{2}_{#phi #phi}-#sigma^{2}_{#eta #eta}");
outputContainer->Add(fhMCEDispEtaPhiDiff[i]);
fhMCESphericity[i] = new TH2F (Form("hESphericity_MC%s",pnamess[i].Data()),
Form("cluster from %s : (#sigma^{2}_{#phi #phi} - #sigma^{2}_{#eta #eta}) / (#sigma^{2}_{#eta #eta} + #sigma^{2}_{#phi #phi}) vs E",ptypess[i].Data()),
nptbins,ptmin,ptmax, 200,-1,1);
- fhMCESphericity[i]->SetXTitle("E (GeV)");
+ fhMCESphericity[i]->SetXTitle("#it{E} (GeV)");
fhMCESphericity[i]->SetYTitle("s = (#sigma^{2}_{#phi #phi} - #sigma^{2}_{#eta #eta}) / (#sigma^{2}_{#eta #eta} + #sigma^{2}_{#phi #phi})");
outputContainer->Add(fhMCESphericity[i]);
"cluster from Photon : E vs #lambda_{0}^{2}",
nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhMCPhotonELambda0NoOverlap->SetYTitle("#lambda_{0}^{2}");
- fhMCPhotonELambda0NoOverlap->SetXTitle("E (GeV)");
+ fhMCPhotonELambda0NoOverlap->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhMCPhotonELambda0NoOverlap) ;
fhMCPhotonELambda0TwoOverlap = new TH2F("hELambda0_MCPhoton_TwoOverlap",
"cluster from Photon : E vs #lambda_{0}^{2}",
nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhMCPhotonELambda0TwoOverlap->SetYTitle("#lambda_{0}^{2}");
- fhMCPhotonELambda0TwoOverlap->SetXTitle("E (GeV)");
+ fhMCPhotonELambda0TwoOverlap->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhMCPhotonELambda0TwoOverlap) ;
fhMCPhotonELambda0NOverlap = new TH2F("hELambda0_MCPhoton_NOverlap",
"cluster from Photon : E vs #lambda_{0}^{2}",
nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhMCPhotonELambda0NOverlap->SetYTitle("#lambda_{0}^{2}");
- fhMCPhotonELambda0NOverlap->SetXTitle("E (GeV)");
+ fhMCPhotonELambda0NOverlap->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhMCPhotonELambda0NOverlap) ;
} //No embedding
"Energy Fraction of embedded signal versus cluster energy",
nptbins,ptmin,ptmax,100,0.,1.);
fhEmbeddedSignalFractionEnergy->SetYTitle("Fraction");
- fhEmbeddedSignalFractionEnergy->SetXTitle("E (GeV)");
+ fhEmbeddedSignalFractionEnergy->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhEmbeddedSignalFractionEnergy) ;
fhEmbedPhotonELambda0FullSignal = new TH2F("hELambda0_EmbedPhoton_FullSignal",
"cluster from Photon embedded with more than 90% energy in cluster : E vs #lambda_{0}^{2}",
nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhEmbedPhotonELambda0FullSignal->SetYTitle("#lambda_{0}^{2}");
- fhEmbedPhotonELambda0FullSignal->SetXTitle("E (GeV)");
+ fhEmbedPhotonELambda0FullSignal->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhEmbedPhotonELambda0FullSignal) ;
fhEmbedPhotonELambda0MostlySignal = new TH2F("hELambda0_EmbedPhoton_MostlySignal",
"cluster from Photon embedded with 50% to 90% energy in cluster : E vs #lambda_{0}^{2}",
nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhEmbedPhotonELambda0MostlySignal->SetYTitle("#lambda_{0}^{2}");
- fhEmbedPhotonELambda0MostlySignal->SetXTitle("E (GeV)");
+ fhEmbedPhotonELambda0MostlySignal->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhEmbedPhotonELambda0MostlySignal) ;
fhEmbedPhotonELambda0MostlyBkg = new TH2F("hELambda0_EmbedPhoton_MostlyBkg",
"cluster from Photon embedded with 10% to 50% energy in cluster : E vs #lambda_{0}^{2}",
nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhEmbedPhotonELambda0MostlyBkg->SetYTitle("#lambda_{0}^{2}");
- fhEmbedPhotonELambda0MostlyBkg->SetXTitle("E (GeV)");
+ fhEmbedPhotonELambda0MostlyBkg->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhEmbedPhotonELambda0MostlyBkg) ;
fhEmbedPhotonELambda0FullBkg = new TH2F("hELambda0_EmbedPhoton_FullBkg",
"cluster from Photonm embedded with 0% to 10% energy in cluster : E vs #lambda_{0}^{2}",
nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhEmbedPhotonELambda0FullBkg->SetYTitle("#lambda_{0}^{2}");
- fhEmbedPhotonELambda0FullBkg->SetXTitle("E (GeV)");
+ fhEmbedPhotonELambda0FullBkg->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhEmbedPhotonELambda0FullBkg) ;
fhEmbedPi0ELambda0FullSignal = new TH2F("hELambda0_EmbedPi0_FullSignal",
"cluster from Pi0 embedded with more than 90% energy in cluster : E vs #lambda_{0}^{2}",
nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhEmbedPi0ELambda0FullSignal->SetYTitle("#lambda_{0}^{2}");
- fhEmbedPi0ELambda0FullSignal->SetXTitle("E (GeV)");
+ fhEmbedPi0ELambda0FullSignal->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhEmbedPi0ELambda0FullSignal) ;
fhEmbedPi0ELambda0MostlySignal = new TH2F("hELambda0_EmbedPi0_MostlySignal",
"cluster from Pi0 embedded with 50% to 90% energy in cluster : E vs #lambda_{0}^{2}",
nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhEmbedPi0ELambda0MostlySignal->SetYTitle("#lambda_{0}^{2}");
- fhEmbedPi0ELambda0MostlySignal->SetXTitle("E (GeV)");
+ fhEmbedPi0ELambda0MostlySignal->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhEmbedPi0ELambda0MostlySignal) ;
fhEmbedPi0ELambda0MostlyBkg = new TH2F("hELambda0_EmbedPi0_MostlyBkg",
"cluster from Pi0 embedded with 10% to 50% energy in cluster : E vs #lambda_{0}^{2}",
nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhEmbedPi0ELambda0MostlyBkg->SetYTitle("#lambda_{0}^{2}");
- fhEmbedPi0ELambda0MostlyBkg->SetXTitle("E (GeV)");
+ fhEmbedPi0ELambda0MostlyBkg->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhEmbedPi0ELambda0MostlyBkg) ;
fhEmbedPi0ELambda0FullBkg = new TH2F("hELambda0_EmbedPi0_FullBkg",
"cluster from Pi0 embedded with 0% to 10% energy in cluster : E vs #lambda_{0}^{2}",
nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhEmbedPi0ELambda0FullBkg->SetYTitle("#lambda_{0}^{2}");
- fhEmbedPi0ELambda0FullBkg->SetXTitle("E (GeV)");
+ fhEmbedPi0ELambda0FullBkg->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhEmbedPi0ELambda0FullBkg) ;
}// embedded histograms