diff --git a/Jets/JetQC.C b/Jets/JetQC.C index 7c7f744..92ce7ff 100644 --- a/Jets/JetQC.C +++ b/Jets/JetQC.C @@ -166,7 +166,7 @@ void JetQC() { // Draw_PtPeakPosition_vs_leadTrackCut(etaRangeSym, jetRadiusForDataComp); // Draw_PtLeadCutStudy_PtOfRatio1(etaRangeSym, "", jetRadiusForDataComp); - Draw_Pt_DatasetComparison(etaRangeSym, "normEvents", jetRadiusForDataComp); + // Draw_Pt_DatasetComparison(etaRangeSym, "normEvents", jetRadiusForDataComp); // Draw_Pt_DatasetComparison_withRun2RitsuyaHardcoded(etaRangeSym, "normEvents", jetRadiusForDataComp); for(int iPtBin = 0; iPtBin < nPtBins; iPtBin++){ jetPtMinCut = jetPtMinCutArray[iPtBin]; @@ -184,6 +184,7 @@ void JetQC() { // Draw_Eta_DatasetComparison(jetRadiusForDataComp, ptRange, "normEvents"); // Draw_Eta_DatasetComparison(jetRadiusForDataComp, ptRange, "normEntries"); // Draw_Phi_DatasetComparison(jetRadiusForDataComp, ptRange, "normEvents"); + Draw_Phi_DatasetComparison(jetRadiusForDataComp, ptRange, "normEvents"); // Draw_Constituent_Pt_DatasetComparison(ptRange, jetRadiusForDataComp); @@ -851,7 +852,7 @@ void Draw_Pt_DatasetComparison(float* etaRange, std::string options, float jetRa std::array, 2> drawnWindow = {{{-25, 200},{10E-9, 40}}}; std::array, 2> drawnWindowZoom = {{{-10, 200},{0.6, 1.6}}}; - + std::array, 2> drawnWindowZoomTwoByTwo = {{{-25, 200},{0.5, 2}}}; std::array, 2> legendPlacement = {{{0.65, 0.6}, {0.85, 0.85}}}; // {{{x1, y1}, {x2, y2}}} std::array, 2> legendPlacementRatio = {{{0.6, 0.2}, {0.8, 0.45}}}; // {{{x1, y1}, {x2, y2}}} // std::array, 2> legendPlacementAuto = {{{-999, -999}, {-999, -999}}}; // {{{x1, y1}, {x2, y2}}} @@ -859,7 +860,7 @@ void Draw_Pt_DatasetComparison(float* etaRange, std::string options, float jetRa Draw_TH1_Histograms(H1D_jetPt_rebinned, DatasetsNames, nDatasets, textContext, pdfName, iJetFinderQaType == 0 ? texPtJetRawX : texPtJetBkgCorrX, texJetPtYield_EventNorm, texCollisionDataInfo, drawnWindow, legendPlacement, contextPlacementAuto, "logy"+histDatasetComparisonStructure); if (divideSuccess == true) { if (histDatasetComparisonStructure.find("twoByTwoDatasetPairs") != std::string::npos) { - Draw_TH1_Histograms(H1D_jetPt_rebinned_ratios, DatasetsNamesPairRatio, nHistPairRatio, textContext, pdfName_ratio, iJetFinderQaType == 0 ? texPtJetRawX : texPtJetBkgCorrX, texRatio, texCollisionDataInfo, drawnWindow, legendPlacementRatio, contextPlacementAuto, "zoomToOneMedium1"); + Draw_TH1_Histograms(H1D_jetPt_rebinned_ratios, DatasetsNamesPairRatio, nHistPairRatio, textContext, pdfName_ratio, iJetFinderQaType == 0 ? texPtJetRawX : texPtJetBkgCorrX, texRatio, texCollisionDataInfo, drawnWindowZoomTwoByTwo, legendPlacementRatio, contextPlacementAuto, "zoomToOneMedium1"); } else { Draw_TH1_Histograms(H1D_jetPt_rebinned_ratios, DatasetsNames, nDatasets, textContext, pdfName_ratio, iJetFinderQaType == 0 ? texPtJetRawX : texPtJetBkgCorrX, texRatioDatasets, texCollisionDataInfo, drawnWindow, legendPlacementRatio, contextPlacementAuto, "noMarkerFirst"+histDatasetComparisonStructure); Draw_TH1_Histograms(H1D_jetPt_rebinned_ratios, DatasetsNames, nDatasets, textContext, pdfName_ratio_zoom, iJetFinderQaType == 0 ? texPtJetRawX : texPtJetBkgCorrX, texRatioDatasets, texCollisionDataInfo, drawnWindowZoom, legendPlacementAuto, contextPlacementAuto, "noMarkerFirst"); @@ -944,9 +945,25 @@ void Draw_Eta_DatasetComparison(float jetRadius, float* PtRange, std::string opt pdfNameNorm = "normEvents"; } - H1D_jetEta_rebinned_ratios[iDataset] = (TH1D*)H1D_jetEta_rebinned[iDataset]->Clone("jetEta_rebinned_ratios"+Datasets[iDataset]+DatasetsNames[iDataset]+"Radius"+Form("%.1f",jetRadius)+Form("%.1f", PtCutLow)+"Reset("M"); - divideSuccess = H1D_jetEta_rebinned_ratios[iDataset]->Divide(H1D_jetEta_rebinned[iDataset], H1D_jetEta_rebinned[0], 1., 1., datasetsAreSubsetsofId0 ? "b" : ""); + + } + + TString DatasetsNamesPairRatio[nDatasets]; + int nHistPairRatio = (int)nDatasets / 2; + for(int iDataset = 0; iDataset < nDatasets; iDataset++){ + if (histDatasetComparisonStructure.find("twoByTwoDatasetPairs") != std::string::npos) { //twoByTwoDatasetPairs assumes a Datasets array like so: {pair1_element1, pair2_element1, ..., pairN_element1, pair1_element2, pair2_element2, ..., pairN_element2} + if (iDataset < nHistPairRatio) { + DatasetsNamesPairRatio[iDataset] = DatasetsNames[2*iDataset]+(TString)"/"+DatasetsNames[2*iDataset+1]; + H1D_jetEta_rebinned_ratios[iDataset] = (TH1D*)H1D_jetEta_rebinned[2*iDataset]->Clone("jetEta_rebinned_ratios"+Datasets[2*iDataset]+DatasetsNames[2*iDataset]+"Radius"+Form("%.1f",jetRadius)+Form("%.1f", PtCutLow)+"Reset("M"); + divideSuccess = H1D_jetEta_rebinned_ratios[iDataset]->Divide(H1D_jetEta_rebinned[2*iDataset], H1D_jetEta_rebinned[2*iDataset+1], 1., 1., datasetsAreSubsetsofId0 ? "b" : ""); + } + } else { + H1D_jetEta_rebinned_ratios[iDataset] = (TH1D*)H1D_jetEta_rebinned[iDataset]->Clone("jetEta_rebinned_ratios"+Datasets[iDataset]+DatasetsNames[iDataset]+"Radius"+Form("%.1f",jetRadius)+Form("%.1f", PtCutLow)+"Reset("M"); + divideSuccess = H1D_jetEta_rebinned_ratios[iDataset]->Divide(H1D_jetEta_rebinned[iDataset], H1D_jetEta_rebinned[0], 1., 1., datasetsAreSubsetsofId0 ? "b" : ""); + + } } TString* pdfName = new TString("jet_"+jetType[iJetType]+"_"+jetLevel[iJetLevel]+"_DataComp_R="+Form("%.1f", jetRadius)+"_Eta_@pT["+Form("%03.0f", PtCutLow)+","+Form("%03.0f", PtCutHigh)+"]"+jetFinderQaHistType[iJetFinderQaType]+"_"+(TString)pdfNameNorm); @@ -957,19 +974,27 @@ void Draw_Eta_DatasetComparison(float jetRadius, float* PtRange, std::string opt const std::array, 2> drawnWindow = {{{-1, 1}, {-999, -999}}}; // {{xmin, xmax}, {ymin, ymax}} const std::array, 2> legendPlacement = {{{0.65, 0.2}, {0.85, 0.45}}}; // xLeftLegend, yLowLegend, xRightLegend, yUpLegend + std::array, 2> drawnWindowZoomTwoByTwo = {{{-1, 1},{0.5, 2}}}; + std::array, 2> legendPlacementRatio = {{{0.5, 0.2}, {0.7, 0.4}}}; // {{{x1, y1}, {x2, y2}}} Draw_TH1_Histograms(H1D_jetEta_rebinned, DatasetsNames, nDatasets, textContext, pdfName, texEtaX, yAxisLabel, texCollisionDataInfo, drawnWindow, legendPlacement, contextPlacementAuto, ""); if (divideSuccess == true) { - Draw_TH1_Histograms(H1D_jetEta_rebinned_ratios, DatasetsNames, nDatasets, textContext, pdfName_ratio, texEtaX, texRatioDatasets, texCollisionDataInfo, drawnWindow, legendPlacement, contextPlacementAuto, "noMarkerFirst"+histDatasetComparisonStructure); - } + if (histDatasetComparisonStructure.find("twoByTwoDatasetPairs") != std::string::npos) { + Draw_TH1_Histograms(H1D_jetEta_rebinned_ratios, DatasetsNamesPairRatio, nHistPairRatio, textContext, pdfName_ratio, texEtaX, texRatio, texCollisionDataInfo, drawnWindowZoomTwoByTwo, legendPlacementRatio, contextPlacementAuto, "zoomToOneMedium1"); + } + else { + Draw_TH1_Histograms(H1D_jetEta_rebinned_ratios, DatasetsNames, nDatasets, textContext, pdfName_ratio, texEtaX, texRatioDatasets, texCollisionDataInfo, drawnWindow, legendPlacement, contextPlacementAuto, "noMarkerFirst"+histDatasetComparisonStructure); + } + } else { cout << "Divide failed in Draw_Eta_DatasetComparison" << endl; } + + } void Draw_Phi_DatasetComparison(float jetRadius, float* PtRange, std::string options) { - TH3D* H3D_jetRjetPtjetPhi[nDatasets]; TH1D* H1D_jetPhi[nDatasets]; TH1D* H1D_jetPhi_rebinned[nDatasets]; @@ -985,7 +1010,6 @@ void Draw_Phi_DatasetComparison(float jetRadius, float* PtRange, std::string opt TString* yAxisLabel; for(int iDataset = 0; iDataset < nDatasets; iDataset++){ - if (analysisWorkflow[iDataset].Contains("jet-finder-charged-qa") == true) { H3D_jetRjetPtjetPhi[iDataset] = (TH3D*)((TH3D*)file_O2Analysis_list[iDataset]->Get(analysisWorkflow[iDataset]+"/h3_jet_r_jet_pt_jet_eta"+jetFinderQaHistType[iJetFinderQaType]))->Clone("Draw_Phi_DatasetComparison"+Datasets[iDataset]+DatasetsNames[iDataset]+"Radius"+Form("%.1f",jetRadius)+jetRadius+Form("%.1f", PtRange[0])+"Clone("jetPhi_rebinned_ratios"+Datasets[iDataset]+DatasetsNames[iDataset]+"Radius"+Form("%.1f",jetRadius)+Form("%.1f", PtCutLow)+"Reset("M"); - divideSuccess = H1D_jetPhi_rebinned_ratios[iDataset]->Divide(H1D_jetPhi_rebinned[iDataset], H1D_jetPhi_rebinned[0], 1., 1., datasetsAreSubsetsofId0 ? "b" : ""); + } + + TString DatasetsNamesPairRatio[nDatasets]; + int nHistPairRatio = (int)nDatasets / 2; + for(int iDataset = 0; iDataset < nDatasets; iDataset++){ + if (histDatasetComparisonStructure.find("twoByTwoDatasetPairs") != std::string::npos) { //twoByTwoDatasetPairs assumes a Datasets array like so: {pair1_element1, pair2_element1, ..., pairN_element1, pair1_element2, pair2_element2, ..., pairN_element2} + if (iDataset < nHistPairRatio) { + DatasetsNamesPairRatio[iDataset] = DatasetsNames[2*iDataset]+(TString)"/"+DatasetsNames[2*iDataset+1]; + H1D_jetPhi_rebinned_ratios[iDataset] = (TH1D*)H1D_jetPhi_rebinned[2*iDataset]->Clone("jetPhi_rebinned_ratios"+Datasets[2*iDataset]+DatasetsNames[2*iDataset]+"Radius"+Form("%.1f",jetRadius)+Form("%.1f", PtCutLow)+"Reset("M"); + divideSuccess = H1D_jetPhi_rebinned_ratios[iDataset]->Divide(H1D_jetPhi_rebinned[2*iDataset], H1D_jetPhi_rebinned[2*iDataset+1], 1., 1., datasetsAreSubsetsofId0 ? "b" : ""); + } + } else { + H1D_jetPhi_rebinned_ratios[iDataset] = (TH1D*)H1D_jetPhi_rebinned[iDataset]->Clone("jetPhi_rebinned_ratios"+Datasets[iDataset]+DatasetsNames[iDataset]+"Radius"+Form("%.1f",jetRadius)+Form("%.1f", PtCutLow)+"Reset("M"); + divideSuccess = H1D_jetPhi_rebinned_ratios[iDataset]->Divide(H1D_jetPhi_rebinned[iDataset], H1D_jetPhi_rebinned[0], 1., 1., datasetsAreSubsetsofId0 ? "b" : ""); + + } + } + + TString* pdfName = new TString("jet_"+jetType[iJetType]+"_"+jetLevel[iJetLevel]+"_DataComp_R="+Form("%.1f", jetRadius)+"_Phi_@pT["+Form("%03.0f", PtCutLow)+","+Form("%03.0f", PtCutHigh)+"]"+jetFinderQaHistType[iJetFinderQaType]); TString* pdfName_ratio = new TString("jet_"+jetType[iJetType]+"_"+jetLevel[iJetLevel]+"_DataComp_R="+Form("%.1f", jetRadius)+"_Phi_@pT["+Form("%03.0f", PtCutLow)+","+Form("%03.0f", PtCutHigh)+"]"+jetFinderQaHistType[iJetFinderQaType]+"_ratio"); @@ -1045,11 +1087,18 @@ void Draw_Phi_DatasetComparison(float jetRadius, float* PtRange, std::string opt const std::array, 2> drawnWindowRatioCustom = {{{-999, -999}, {0, 1.9}}}; // {{xmin, xmax}, {ymin, ymax}} std::array, 2> legendPlacementCustom = {{{0.2, 0.2}, {0.4, 0.45}}}; // {{{x1, y1}, {x2, y2}}} + std::array, 2> drawnWindowZoomTwoByTwo = {{{-1, 7},{0.5, 2}}}; + std::array, 2> legendPlacementRatio = {{{0.5, 0.5}, {0.7, 0.7}}}; // {{{x1, y1}, {x2, y2}}} Draw_TH1_Histograms(H1D_jetPhi_rebinned, DatasetsNames, nDatasets, textContext, pdfName, texPhiX, texJetPhiYield_EventNorm, texCollisionDataInfo, drawnWindowAuto, legendPlacementCustom, contextPlacementAuto, "histWithLine"); if (divideSuccess == true) { + if (histDatasetComparisonStructure.find("twoByTwoDatasetPairs") != std::string::npos) { + Draw_TH1_Histograms(H1D_jetPhi_rebinned_ratios, DatasetsNamesPairRatio, nHistPairRatio, textContext, pdfName_ratio, texPhiX, texRatio, texCollisionDataInfo, drawnWindowZoomTwoByTwo, legendPlacementRatio, contextPlacementAuto, "zoomToOneMedium1"); + } + else{ Draw_TH1_Histograms(H1D_jetPhi_rebinned_ratios, DatasetsNames, nDatasets, textContext, pdfName_ratio, texPhiX, texRatioDatasets, texCollisionDataInfo, drawnWindowRatioCustom, legendPlacementCustom, contextPlacementAuto, "noMarkerFirst"+histDatasetComparisonStructure); + } } else { cout << "Divide failed in Draw_Phi_DatasetComparison" << endl; diff --git a/Tracks/TrackMcQC.C b/Tracks/TrackMcQC.C index c4a6ba1..fc09b70 100644 --- a/Tracks/TrackMcQC.C +++ b/Tracks/TrackMcQC.C @@ -90,6 +90,7 @@ void Draw_Phi_gen_DatasetComparison_H2CentVersion(std::string options); void Draw_Pt_tracksReco_fromEffWorkflow_DatasetComparison(float* etaRange, std::string options); void Draw_Eta_tracksReco_fromEffWorkflow_DatasetComparison(float* ptRange, std::string options); void Draw_Phi_tracksReco_fromEffWorkflow_DatasetComparison(float* ptRange, float* etaRange, std::string options); +void Draw_PtResolution_Residuals(std::string options); ///////////////////////////////////////////////////// ///////////////////// Main Macro //////////////////// @@ -108,9 +109,9 @@ void TrackMcQC() { float etaRange[2] = {-0.9, 0.9}; float ptRange[2] = {0.15, 100}; bool useLargeLegendWindow = false; - Draw_Efficiency_Pt_DatasetComparison(etaRange,useSplit, useLargeLegendWindow); - Draw_Efficiency_Eta_DatasetComparison(ptRange,useSplit); - Draw_Efficiency_Phi_DatasetComparison(ptRange, etaRange, useSplit); + // Draw_Efficiency_Pt_DatasetComparison(etaRange,useSplit, useLargeLegendWindow); + // Draw_Efficiency_Eta_DatasetComparison(ptRange,useSplit); + // Draw_Efficiency_Phi_DatasetComparison(ptRange, etaRange, useSplit); // Draw_Efficiency_Pt_ratio_etaNeg_etaPos_DatasetComparison(etaRange, useSplit); // // Draw_Efficiency_Phi_DatasetComparison_finerPhi(ptRange1, etaRange); // only works with very specific datasets created locally @@ -171,6 +172,7 @@ void TrackMcQC() { // Draw_Pt_gen_DatasetComparison_H2CentVersion("primaries,secondaries, ratio"); // Draw_Eta_gen_DatasetComparison_H2CentVersion("primaries,secondaries, ratio"); // Draw_Phi_gen_DatasetComparison_H2CentVersion("primaries,secondaries, ratio"); + Draw_PtResolution_Residuals("ptRes_vs_pt"); } ///////////////////////////////////////////////////// /////////////////// Misc utilities ////////////////// @@ -703,6 +705,8 @@ void Draw_Efficiency_Eta_DatasetComparison(float* ptRange, bool useSplit) { // TString textContext(contextDatasetComp("")); TString textContext(contextCustomTwoFields(*texDatasetsComparisonCommonDenominator, contextPtRange(ptRange), "")); + std::array, 2> drawnZoom = {{{(float)H1D_trackEta_efficiency[0]->GetXaxis()->GetXmin(), (float)H1D_trackEta_efficiency[0]->GetXaxis()->GetXmax()}, + {0.6, 1}}}; // {{xmin, xmax}, {ymin, ymax}} if (divideSuccess == true) { Draw_TH1_Histograms(H1D_trackEta_efficiency, DatasetsNames, nDatasets, textContext, pdfNameEntriesNorm, texEtaMC, texTrackEfficiency, texCollisionDataInfo, drawnWindowAuto, legendPlacementEta, contextPlacementAuto, "efficiency"+histDatasetComparisonStructure); @@ -855,7 +859,9 @@ void Draw_Efficiency_Phi_DatasetComparison(float* ptRange, float* etaRange, bool // TString textContext(contextDatasetComp("")); TString textContext(contextCustomTwoFields(*texDatasetsComparisonCommonDenominator, "#splitline{"+contextPtRange(ptRange)+"}{"+contextEtaRange(etaRange)+"}", "")); - std::array, 2> legendPlacementPhi = {{{0.55, 0.55}, {0.85, 0.85}}}; + std::array, 2> legendPlacementPhi = {{{0.65, 0.65}, {0.85, 0.85}}}; + std::array, 2> drawnZoom = {{{(float)H1D_trackPhi_efficiency[0]->GetXaxis()->GetXmin(), (float)H1D_trackPhi_efficiency[0]->GetXaxis()->GetXmax()}, + {0.45, 1}}}; // {{xmin, xmax}, {ymin, ymax}} std::array, 2> drawnWindowLogEff_zoom = {{{-999, -999}, {0.5, 1}}}; std::array, 2> drawnWindowLogEffRatio_zoom = {{{-999, -999}, {0.8, 1.2}}}; @@ -1642,10 +1648,12 @@ void Draw_Purity_Eta_DatasetComparison(float* etaRange, bool useSplit) { {0.9, 1}}}; // {{xmin, xmax}, {ymin, ymax}} std::array, 2> drawnZoom_split = {{{(float)H1D_trackEta_primaryPurity[0]->GetXaxis()->GetXmin(), (float)H1D_trackEta_primaryPurity[0]->GetXaxis()->GetXmax()}, {0.996, 1.002}}}; // {{xmin, xmax}, {ymin, ymax}} + std::array, 2> drawnZoom_prim2 = {{{(float)H1D_trackEta_primaryPurity[0]->GetXaxis()->GetXmin(), (float)H1D_trackEta_primaryPurity[0]->GetXaxis()->GetXmax()}, + {0.94, 1}}}; // {{xmin, xmax}, {ymin, ymax}} if (divideSuccess == true) { Draw_TH1_Histograms(H1D_trackEta_primaryPurity, DatasetsNames, nDatasets, textContext, pdfNameEntriesNorm, texEtaMC, texTrackPurity, texCollisionDataInfo, drawnWindowAuto, legendPlacementAuto, contextPlacementAuto, "efficiency"); - Draw_TH1_Histograms(H1D_trackEta_primaryPurity, DatasetsNames, nDatasets, textContext, pdfNameEntriesNorm_zoom, texEtaMC, texTrackPurity, texCollisionDataInfo, drawnZoom_prim, legendPlacementAuto, contextPlacementAuto, "efficiency"); + Draw_TH1_Histograms(H1D_trackEta_primaryPurity, DatasetsNames, nDatasets, textContext, pdfNameEntriesNorm_zoom, texEtaMC, texTrackPurity, texCollisionDataInfo, drawnZoom_prim2, legendPlacementAuto, contextPlacementAuto, "efficiency"); } else { cout << "Divide failed in Draw_Purity_Eta_DatasetComparison" << endl; @@ -1725,10 +1733,12 @@ void Draw_Purity_Phi_DatasetComparison(float* etaRange, bool useSplit) { {0.9, 1}}}; // {{xmin, xmax}, {ymin, ymax}} std::array, 2> drawnZoom_split = {{{(float)H1D_trackPhi_primaryPurity[0]->GetXaxis()->GetXmin(), (float)H1D_trackPhi_primaryPurity[0]->GetXaxis()->GetXmax()}, {0.995, 1.005}}}; // {{xmin, xmax}, {ymin, ymax}} + std::array, 2> drawnZoom_prim2 = {{{(float)H1D_trackPhi_primaryPurity[0]->GetXaxis()->GetXmin(), (float)H1D_trackPhi_primaryPurity[0]->GetXaxis()->GetXmax()}, + {0.94, 1}}}; // {{xmin, xmax}, {ymin, ymax}} if (divideSuccess == true) { Draw_TH1_Histograms(H1D_trackPhi_primaryPurity, DatasetsNames, nDatasets, textContext, pdfNameEntriesNorm, texPhiRec, texTrackPurity, texCollisionDataInfo, drawnWindowAuto, legendPlacementAuto, contextPlacementAuto, "efficiency"); - Draw_TH1_Histograms(H1D_trackPhi_primaryPurity, DatasetsNames, nDatasets, textContext, pdfNameEntriesNorm_zoom, texPhiRec, texTrackPurity, texCollisionDataInfo, drawnZoom_prim, legendPlacementAuto, contextPlacementAuto, "efficiency"); + Draw_TH1_Histograms(H1D_trackPhi_primaryPurity, DatasetsNames, nDatasets, textContext, pdfNameEntriesNorm_zoom, texPhiRec, texTrackPurity, texCollisionDataInfo, drawnZoom_prim2, legendPlacementAuto, contextPlacementAuto, "efficiency"); } else { cout << "Divide failed in Draw_Purity_Phi_DatasetComparison" << endl; @@ -3022,3 +3032,253 @@ void Draw_Phi_tracksReco_fromEffWorkflow_DatasetComparison(float* ptRange, float } } +void Draw_PtResolution_Residuals(std::string options = "") +{ + // ========================= + // Déclarations + // ========================= + TH2D* H2D_ptRes[nDatasets]; + TH1D* H1D_ptRes_mean[nDatasets]; + TH1D* H1D_ptRes_mean_rebinned[nDatasets]; + TH1D* H1D_ptRes_sigma[nDatasets]; + TH1D* H1D_ptRes_sigma_rebinned[nDatasets]; + + + // Fonction de fit (gaussienne) + TF1* gaus = new TF1("gaus", "gaus", -0.3, 0.3); + + // ========================= + // Loop datasets + // ========================= + + for (int iDataset = 0; iDataset < nDatasets; iDataset++) { + + // --- Récupération du TH2 --- + H2D_ptRes[iDataset] =(TH2D*) ((TH2D*)file_O2Analysis_list[iDataset]->Get(analysisWorkflow[iDataset] +"/h2_particle_pt_track_pt_deltaptoverparticlept"))->Clone("h2_ptRes_" + Datasets[iDataset] + DatasetsNames[iDataset]); + + // Sécurité + if (!H2D_ptRes[iDataset]) { + std::cout << "ERROR: H2 not found for dataset " << iDataset << std::endl; + continue; + } + // --- Range en Y pour stabiliser le fit --- on garde uniquement les valeurs entre -0.5 et 0.5 + H2D_ptRes[iDataset]->GetYaxis()->SetRangeUser(-0.5, 0.5); + + // --- Fit slice par slice --- + H2D_ptRes[iDataset]->FitSlicesY(gaus, 0, -1, 0, "R"); + + // --- Récupération des histos produits --- + H1D_ptRes_mean[iDataset] = + (TH1D*) gDirectory->Get( + TString(H2D_ptRes[iDataset]->GetName()) + "_1" + ); + + H1D_ptRes_sigma[iDataset] = + (TH1D*) gDirectory->Get( + TString(H2D_ptRes[iDataset]->GetName()) + "_2" + ); + + // --- Titres --- + H1D_ptRes_mean[iDataset]->SetYTitle("Mean((p_{T}^{gen}-p_{T}^{track})/p_{T}^{track})"); + H1D_ptRes_sigma[iDataset]->SetYTitle("#sigma((p_{T}^{gen}-p_{T}^{track})/p_{T}^{track})"); + H1D_ptRes_sigma[iDataset]->SetXTitle("p_{T}^{gen} (GeV/c)"); + + // ===================== Advanced rebinning for ptRes ===================== + std::vector xbinsVector = GetTH1Bins(H1D_ptRes_sigma[iDataset]); + double* xbinsInitial = &xbinsVector[0]; + double ptBinsNew[500]; // safe margin + int iBinNew = 0; + int iBinInitial = 0; + double binWidth = H1D_ptRes_sigma[iDataset]->GetXaxis()->GetBinWidth(1); + int increment; + + while (iBinInitial < H1D_ptRes_sigma[iDataset]->GetNbinsX()) { + double pt = xbinsInitial[iBinInitial]; + + if (pt < 0.3) { + increment = 1; + } else if (pt < 25.0) { + // increment = 1; + increment = 1 + pt / binWidth / 8; + } else { + ptBinsNew[iBinNew++] = pt; // left edge of large bin + ptBinsNew[iBinNew++] = 100.0; // right edge = 100 + break; + } + + ptBinsNew[iBinNew++] = pt; + iBinInitial += increment; + } + + // security: last edge = 100 + if (ptBinsNew[iBinNew-1] < 100.0) ptBinsNew[iBinNew++] = 100.0; + + int nBinsNew = iBinNew - 1; + + // ===== Rebin the histogram ===== + H1D_ptRes_mean_rebinned[iDataset] = (TH1D*)H1D_ptRes_mean[iDataset]->Rebin(nBinsNew,"H1D_ptRes_mean_rebinned" + Datasets[iDataset] + DatasetsNames[iDataset],ptBinsNew); + H1D_ptRes_sigma_rebinned[iDataset] = (TH1D*)H1D_ptRes_sigma[iDataset]->Rebin(nBinsNew,"H1D_ptRes_sigma_rebinned" + Datasets[iDataset] + DatasetsNames[iDataset],ptBinsNew); + + // ===== Optional: print bins for verification ===== + std::cout << "=== Bins du ptRes_mean rebinned ===" << std::endl; + for (int i = 1; i <= H1D_ptRes_mean_rebinned[iDataset]->GetNbinsX(); i++) { + double xlow = H1D_ptRes_mean_rebinned[iDataset]->GetBinLowEdge(i); + double xhigh = xlow + H1D_ptRes_mean_rebinned[iDataset]->GetBinWidth(i); + double content = H1D_ptRes_mean_rebinned[iDataset]->GetBinContent(i); + std::cout << "Bin " << i << ": [" << xlow << ", " << xhigh << "] -> " << content << std::endl; + } + std::cout << "=== Bins du ptRes_sigma rebinned ===" << std::endl; + for (int i = 1; i <= H1D_ptRes_sigma_rebinned[iDataset]->GetNbinsX(); i++) { + double xlow = H1D_ptRes_sigma_rebinned[iDataset]->GetBinLowEdge(i); + double xhigh = xlow + H1D_ptRes_sigma_rebinned[iDataset]->GetBinWidth(i); + double content = H1D_ptRes_sigma_rebinned[iDataset]->GetBinContent(i); + std::cout << "Bin " << i << ": [" << xlow << ", " << xhigh << "] -> " << content << std::endl; + } + + } + + + // ========================= + // Drawing + // ========================= + + TString textContext(contextTrackDatasetComp("")); + + TString* pdfName_mean = new TString("track_PtResolution_mean"); + TString* pdfName_sigma = new TString("track_PtResolution_sigma"); + TString* texPtResMean = new TString("Mean((p_{T}^{gen}-p_{T}^{track})/p_{T}^{track})"); + TString* texPtResSigma = new TString("#sigma((p_{T}^{gen}-p_{T}^{track})/p_{T}^{track})"); + + + const std::array, 2> drawnWindowResidualMean = {{{-999, -999}, {-1.5, 1.5}}}; + const std::array, 2> drawnWindowResidualSigma = {{{-999, -999}, {0, 0.4}}}; + const std::array, 2> legendPlacementResidual = {{{0.17, 0.65}, {0.45, 0.75}}}; + + // --- Mean vs pT --- + Draw_TH1_Histograms(H1D_ptRes_mean_rebinned,DatasetsNames,nDatasets,textContext,pdfName_mean,texPtX,texPtResMean,texCollisionDataInfo,drawnWindowResidualMean,legendPlacementResidual,contextPlacementAuto,"logx"); + + // --- Sigma vs pT --- + Draw_TH1_Histograms(H1D_ptRes_sigma_rebinned,DatasetsNames,nDatasets,textContext,pdfName_sigma,texPtX,texPtResSigma,texCollisionDataInfo,drawnWindowResidualSigma,legendPlacementResidual,contextPlacementAuto,"logx"); +} + +// void Draw_PtResolution_FromH2(std::string options = "") +// { +// std::cout << "test1 " << std::endl; + +// // ========================= +// // Déclarations +// // ========================= +// TH2D* H2D_ptRes[nDatasets]; +// TH1D* H1D_ptRes_mean[nDatasets]; +// TH1D* H1D_ptRes_sigma[nDatasets]; + +// // Fonction de fit (gaussienne) +// TF1* gaus = new TF1("gaus", "gaus", -0.3, 0.3); + +// // ========================= +// // Loop datasets +// // ========================= +// std::cout << "test2 " << std::endl; + +// for (int iDataset = 0; iDataset < nDatasets; iDataset++) { + +// // --- Récupération du TH2 --- +// H2D_ptRes[iDataset] = (TH2D*) ((TH2D*)file_O2Analysis_list[iDataset]->Get( +// analysisWorkflow[iDataset] + "/h2_particle_pt_track_pt_deltaptoverparticlept"))->Clone( +// "h2_ptRes_" + Datasets[iDataset] + DatasetsNames[iDataset] +// ); + +// // Sécurité +// if (!H2D_ptRes[iDataset]) { +// std::cout << "ERROR: H2 not found for dataset " << iDataset << std::endl; +// continue; +// } +// std::cout << "test3 " << std::endl; + +// // --- Range en Y pour stabiliser le fit --- +// H2D_ptRes[iDataset]->GetYaxis()->SetRangeUser(-0.5, 0.5); + +// // ========================= +// // --- Affichage des fits intermédiaires corrigé --- +// // ========================= +// int firstX = 1; +// int lastX = 50; + +// for(int iX = firstX; iX <= lastX; iX++){ + +// // Projection Y pour ce bin X +// TH1D* hY = H2D_ptRes[iDataset]->ProjectionY( +// TString::Format("hY_bin%d_dataset%d",iX,iDataset), iX, iX +// ); + +// if (!hY) { +// std::cout << "WARNING: ProjectionY failed for bin " << iX << std::endl; +// continue; +// } + +// // --- Création d'un canvas pour chaque slice --- +// TCanvas* cSlice = new TCanvas( +// TString::Format("cSlice_dataset%d_bin%d",iDataset,iX), +// TString::Format("Intermediate Fit: dataset %d, bin %d", iDataset, iX), +// 600, 400 +// ); + +// // --- Fit gaussien et affichage --- +// hY->Fit("gaus","R"); // R = respect de la range +// hY->SetTitle(TString::Format("Fit slice X bin %d", iX)); +// hY->Draw(); + +// // Forcer l'affichage du canvas +// cSlice->Update(); + +// // Optionnel : pause pour voir le fit avant le suivant +// // gSystem->Sleep(200); // 200 ms, ajuste si nécessaire +// } + + +// // ========================= +// // --- FitSlicesY pour remplir les histos 1D --- +// // ========================= +// H2D_ptRes[iDataset]->FitSlicesY(gaus, 0, -1, 0, "NR"); + +// // --- Récupération des histos produits --- +// H1D_ptRes_mean[iDataset] = +// (TH1D*) gDirectory->Get(TString(H2D_ptRes[iDataset]->GetName()) + "_1"); + +// H1D_ptRes_sigma[iDataset] = +// (TH1D*) gDirectory->Get(TString(H2D_ptRes[iDataset]->GetName()) + "_2"); + +// // --- Titres --- +// H1D_ptRes_mean[iDataset]->SetYTitle("Mean((p_{T}^{gen}-p_{T}^{track})/p_{T}^{track})"); +// H1D_ptRes_sigma[iDataset]->SetYTitle("#sigma((p_{T}^{gen}-p_{T}^{track})/p_{T}^{track})"); +// H1D_ptRes_sigma[iDataset]->SetXTitle("p_{T}^{gen} (GeV/c)"); +// } + +// // ========================= +// // Drawing des résultats finaux +// // ========================= +// TString textContext(contextTrackDatasetComp("")); + +// TString* pdfName_mean = new TString("track_PtResolution_mean"); +// TString* pdfName_sigma = new TString("track_PtResolution_sigma"); +// TString* texPtResMean = new TString("Mean((p_{T}^{gen}-p_{T}^{track})/p_{T}^{track})"); +// TString* texPtResSigma = new TString("#sigma((p_{T}^{gen}-p_{T}^{track})/p_{T}^{track})"); + +// const std::array, 2> drawnWindowAuto = {{{-999, -999}, {-999, -999}}}; +// const std::array, 2> legendPlacementAuto = {{{0.6, 0.65}, {0.85, 0.85}}}; + +// // --- Mean vs pT --- +// Draw_TH1_Histograms(H1D_ptRes_mean, DatasetsNames, nDatasets, +// textContext, pdfName_mean, texPtX, texPtResMean, +// texCollisionDataInfo, drawnWindowAuto, legendPlacementAuto, +// contextPlacementAuto, "logx"); + +// // --- Sigma vs pT --- +// Draw_TH1_Histograms(H1D_ptRes_sigma, DatasetsNames, nDatasets, +// textContext, pdfName_sigma, texPtX, texPtResSigma, +// texCollisionDataInfo, drawnWindowAuto, legendPlacementAuto, +// contextPlacementAuto, "logx"); +// } + + + diff --git a/Tracks/TrackQC.C b/Tracks/TrackQC.C index faacdc7..9093ef9 100644 --- a/Tracks/TrackQC.C +++ b/Tracks/TrackQC.C @@ -33,6 +33,7 @@ #include #include +#include #include #include using namespace std; @@ -110,26 +111,26 @@ void TrackQC() { const int nPtBins = 1; float jetPtMinCut, jetPtMaxCut; // float jetPtMinCutArray[nPtBins+1] = {0, 1, 2, 4, 6, 8, 10, 15, 20, 30, 200}; - float jetPtMinCutArray[nPtBins+1] = {0, 200}; + float jetPtMinCutArray[nPtBins+1] = {0.15, 100}; Draw_Pt_DatasetComparison("evtNorm"); - // Draw_Pt_DatasetComparison("entriesNorm"); + Draw_Pt_DatasetComparison("entriesNorm"); for(int iPtBin = 0; iPtBin < nPtBins; iPtBin++){ jetPtMinCut = jetPtMinCutArray[iPtBin]; jetPtMaxCut = jetPtMinCutArray[iPtBin+1]; float ptRange[2] = {jetPtMinCut, jetPtMaxCut}; Draw_Eta_DatasetComparison(ptRange, "evtNorm"); - // Draw_Eta_DatasetComparison(ptRange, "entriesNorm"); + Draw_Eta_DatasetComparison(ptRange, "entriesNorm"); Draw_Phi_DatasetComparison(ptRange, "evtNorm"); - // Draw_Phi_DatasetComparison(ptRange, "entriesNorm"); + Draw_Phi_DatasetComparison(ptRange, "entriesNorm"); // Draw_Eta_DatasetComparison_trackSelComp(); // Draw_Phi_DatasetComparison_trackSelComp(); } - Draw_Sigmapt_vs_pt_DatasetComp(); + // Draw_Sigmapt_vs_pt_DatasetComp(); // Draw_Sigmapt_nonGlobal_uniformTracks(); // Draw_Sigmapt_nonGlobal_uniformTracks_fromSubtraction(); // Draw_Sigmapt_nonGlobal_uniformTracks_centralEta(); @@ -238,7 +239,7 @@ void Draw_Pt_DatasetComparison(std::string options) { TH1D* H1D_trackPt[nDatasets]; TH1D* H1D_trackPt_rebinned[nDatasets]; - + TH1D* H1D_trackPt_rebinned_ratios[nDatasets]; bool divideSuccess = false; @@ -255,18 +256,75 @@ void Draw_Pt_DatasetComparison(std::string options) { H1D_trackPt[iDataset] = (TH1D*)H3D_track[iDataset]->ProjectionX("trackPt_"+Datasets[iDataset]+DatasetsNames[iDataset], 1, H3D_track[iDataset]->GetNbinsY(), 1, H3D_track[iDataset]->GetNbinsZ(), "e"); } + // ===================== Basic rebinning ===================== // H1D_trackPt_rebinned[iDataset] = (TH1D*)H1D_trackPt[iDataset]->Rebin(2.,"trackPt_rebinned_"+Datasets[iDataset]+DatasetsNames[iDataset]); + // int nBinsLogRough = 100; + // std::vector O2H1DPtLogBinsVector = MakeVariableBinning_logarithmic(H1D_trackPt[iDataset], nBinsLogRough); + // int nBinsLogResult = O2H1DPtLogBinsVector.size()-1; + // // std::vector O2H1DPtLogBinsVector = MakeVariableBinning_logarithmic(0.5, 100, nBinsLogRough); + // double* O2ptLogBins = &O2H1DPtLogBinsVector[0]; + // H1D_trackPt_rebinned[iDataset] = (TH1D*)H1D_trackPt[iDataset]->Rebin(nBinsLogResult, "trackPt_rebinned_"+Datasets[iDataset]+DatasetsNames[iDataset], O2ptLogBins); - int nBinsLogRough = 40; - std::vector O2H1DPtLogBinsVector = MakeVariableBinning_logarithmic(H1D_trackPt[iDataset], nBinsLogRough); - int nBinsLogResult = O2H1DPtLogBinsVector.size()-1; - // std::vector O2H1DPtLogBinsVector = MakeVariableBinning_logarithmic(0.5, 100, nBinsLogRough); - double* O2ptLogBins = &O2H1DPtLogBinsVector[0]; - H1D_trackPt_rebinned[iDataset] = (TH1D*)H1D_trackPt[iDataset]->Rebin(nBinsLogResult, "trackPt_rebinned_"+Datasets[iDataset]+DatasetsNames[iDataset], O2ptLogBins); + // NormaliseYieldToNEntries(H1D_trackPt_rebinned[iDataset]); + // ===================== Advanced rebinning ===================== + std::vector xbinsVector = GetTH1Bins(H1D_trackPt[iDataset]); + double* xbinsInitial = &xbinsVector[0]; + double ptBinsNew[500]; // 500 to be safe + int iBinNew = 0; + int iBinInitial = 0; + double binWidth = H1D_trackPt[iDataset]->GetXaxis()->GetBinWidth(1); //to be use in case we want to have larger bins in mid-pt range + + int increment; + + while (iBinInitial < H1D_trackPt[iDataset]->GetNbinsX()) { + double pt = xbinsInitial[iBinInitial]; + + if (pt < 0.3) { + increment = 1; + } + else if (pt < 25.0) { + increment = 1; + // increment = 1 + pt / binWidth / 8; //in case we want to have larger bins in mid-pt range + } + else { + //no need of increment because we want to stop at 100 + ptBinsNew[iBinNew++] = pt; // left edge of the large bin + ptBinsNew[iBinNew++] = 100.0; // right edge of the large bin + break; + } + ptBinsNew[iBinNew++] = pt; + iBinInitial += increment; + } + + // security to ensure the last bin edge is 100 GeV + if (ptBinsNew[iBinNew-1] < 100.0) ptBinsNew[iBinNew++] = 100.0; + + int nBinsNew = iBinNew - 1; + + // ======= Creation of the rebinned histogram ======= + H1D_trackPt_rebinned[iDataset] = (TH1D*)H1D_trackPt[iDataset]->Rebin(nBinsNew,"H1D_trackPt_rebinned" + Datasets[iDataset] + DatasetsNames[iDataset], ptBinsNew); + + // ===== Display of the initial histogram bins (for debbug) ===== + std::cout << "=== Bins de l'histogramme initial ===" << std::endl; + for (int i = 1; i <= H1D_trackPt[iDataset]->GetNbinsX(); i++) { + double xlow = H1D_trackPt[iDataset]->GetBinLowEdge(i); + double xhigh = H1D_trackPt[iDataset]->GetBinLowEdge(i) + H1D_trackPt[iDataset]->GetBinWidth(i); + double content = H1D_trackPt[iDataset]->GetBinContent(i); + std::cout << "Bin " << i << ": [" << xlow << ", " << xhigh << "] -> " << content << std::endl; + } + + // ===== Affichage des bins du nouvel histogramme rebinned (for debbug) ===== + std::cout << "=== Bins du nouvel histogramme rebinned ===" << std::endl; + for (int i = 1; i <= H1D_trackPt_rebinned[iDataset]->GetNbinsX(); i++) { + double xlow = H1D_trackPt_rebinned[iDataset]->GetBinLowEdge(i); + double xhigh = H1D_trackPt_rebinned[iDataset]->GetBinLowEdge(i) + H1D_trackPt_rebinned[iDataset]->GetBinWidth(i); + double content = H1D_trackPt_rebinned[iDataset]->GetBinContent(i); + std::cout << "Bin " << i << ": [" << xlow << ", " << xhigh << "] -> " << content << std::endl; + } + // ===================== End rebinning ===================== - // NormaliseYieldToNEntries(H1D_trackPt_rebinned[iDataset]); if (options.find("evtNorm") != std::string::npos) { if (isDatasetWeighted[iDataset]) { @@ -315,12 +373,17 @@ void Draw_Pt_DatasetComparison(std::string options) { TString* pdfName_ratio_zoom = new TString("track_Pt_DataComp"+pdfNameNorm+"_ratio_zoom"); std::array, 2> drawnWindowCustomRatio_zoom = {{{0.1, 100}, {0.9, 1.1}}}; // {{xmin, xmax}, {ymin, ymax}} + const std::array, 2> drawnWindowPt = {{{-999, -999}, {1e-8, 10}}}; // {{{xmin, xmax}, {ymin, ymax}}} + const std::array, 2> legendPlacementPt = {{{0.7, 0.65}, {0.85, 0.85}}}; // {{{x1, y1}, {x2, y2}}} + const std::array, 2> drawnWindowPtRatio = {{{-999, -999}, {0, 2.65}}}; // {{{xmin, xmax}, {ymin, ymax}}} + const std::array, 2> legendPlacementPtRatio = {{{0.17, 0.72}, {0.45, 0.81}}}; // {{{x1, y1}, {x2, y2}}} + - Draw_TH1_Histograms(H1D_trackPt_rebinned, DatasetsNames, nDatasets, textContext, pdfName, texPtX, textYaxis, texCollisionDataInfo, drawnWindowAuto, legendPlacementAuto, contextPlacementAuto, "logx,logy"+histDatasetComparisonStructure); + Draw_TH1_Histograms(H1D_trackPt_rebinned, DatasetsNames, nDatasets, textContext, pdfName, texPtX, textYaxis, texCollisionDataInfo, drawnWindowPt, legendPlacementPt, contextPlacementAuto, "logx,logy"+histDatasetComparisonStructure); if (divideSuccess == true) { if (histDatasetComparisonStructure.find("twoByTwoDatasetPairs") != std::string::npos) { - Draw_TH1_Histograms(H1D_trackPt_rebinned_ratios, DatasetsNamesPairRatio, nHistPairRatio, textContext, pdfName_ratio, texPtX, texRatio, texCollisionDataInfo, drawnWindowAuto, legendPlacementAuto, contextPlacementAuto, "logx,zoomToOneMedium1"); + Draw_TH1_Histograms(H1D_trackPt_rebinned_ratios, DatasetsNamesPairRatio, nHistPairRatio, textContext, pdfName_ratio, texPtX, texRatio, texCollisionDataInfo, drawnWindowPtRatio, legendPlacementPtRatio, contextPlacementAuto, "logx,zoomToOneMedium1"); } else { Draw_TH1_Histograms(H1D_trackPt_rebinned_ratios, DatasetsNames, nDatasets, textContext, pdfName_ratio, texPtX, texRatioDatasets, texCollisionDataInfo, drawnWindowAuto, legendPlacementAuto, contextPlacementAuto, "noMarkerFirst,logx"+histDatasetComparisonStructure); Draw_TH1_Histograms(H1D_trackPt_rebinned_ratios, DatasetsNames, nDatasets, textContext, pdfName_ratio_zoom, texPtX, texRatioDatasets, texCollisionDataInfo, drawnWindowCustomRatio_zoom, legendPlacementAuto, contextPlacementAuto, "noMarkerFirst,logx,zoomToOneMedium2"+histDatasetComparisonStructure); @@ -421,14 +484,16 @@ void Draw_Eta_DatasetComparison(float* ptRange, std::string options) { std::array, 2> drawnWindowEta = {{{-1, 1}, {260, 390}}}; // {{xmin, xmax}, {ymin, ymax}} std::array, 2> drawnWindowEtaZoom = {{{-1, 1}, {-999, -999}}}; // {{xmin, xmax}, {ymin, ymax}} + std::array, 2> drawnWindowEtaTwoByTwoRatio = {{{-1, 1}, {0.9, 1.1}}}; // {{xmin, xmax}, {ymin, ymax}} + std::array, 2> legendPlacementCustom = {{{0.65, 0.65}, {0.85, 0.85}}}; // {{{x1, y1}, {x2, y2}}} + std::array, 2> legendPlacementCustom2 = {{{0.2, 0.2}, {0.7, 0.38}}}; // {{{x1, y1}, {x2, y2}}} - std::array, 2> legendPlacementCustom = {{{0.2, 0.2}, {0.4, 0.45}}}; // {{{x1, y1}, {x2, y2}}} - Draw_TH1_Histograms(H1D_trackEta_rebinned, DatasetsNames, nDatasets, textContext, pdfName, texEtaX, textYaxis, texCollisionDataInfo, drawnWindowAuto, legendPlacementCustom, contextPlacementAuto, ""+histDatasetComparisonStructure); + Draw_TH1_Histograms(H1D_trackEta_rebinned, DatasetsNames, nDatasets, textContext, pdfName, texEtaX, textYaxis, texCollisionDataInfo, drawnWindowEtaZoom, legendPlacementCustom, contextPlacementAuto, ""+histDatasetComparisonStructure); if (divideSuccess == true) { if (histDatasetComparisonStructure.find("twoByTwoDatasetPairs") != std::string::npos) { - Draw_TH1_Histograms(H1D_trackEta_rebinned_ratios, DatasetsNamesPairRatio, nHistPairRatio, textContext, pdfName_ratio, texEtaX, texRatio, texCollisionDataInfo, drawnWindowAuto, legendPlacementAuto, contextPlacementAuto, ",zoomToOneExtra"); + Draw_TH1_Histograms(H1D_trackEta_rebinned_ratios, DatasetsNamesPairRatio, nHistPairRatio, textContext, pdfName_ratio, texEtaX, texRatio, texCollisionDataInfo, drawnWindowEtaTwoByTwoRatio, legendPlacementCustom2, contextPlacementAuto, ",zoomToOneExtra"); } else { Draw_TH1_Histograms(H1D_trackEta_rebinned_ratios, DatasetsNames, nDatasets, textContext, pdfName_ratio, texEtaX, texRatioDatasets, texCollisionDataInfo, drawnWindowAuto, legendPlacementAuto, contextPlacementAuto, "noMarkerFirst"+histDatasetComparisonStructure); Draw_TH1_Histograms(H1D_trackEta_rebinned_ratios, DatasetsNames, nDatasets, textContext, pdfName_ratio_zoom, texEtaX, texRatioDatasets, texCollisionDataInfo, drawnWindowAuto, legendPlacementAuto, contextPlacementAuto, "noMarkerFirst,zoomToOneMedium2"+histDatasetComparisonStructure); @@ -526,12 +591,15 @@ void Draw_Phi_DatasetComparison(float* ptRange, std::string options) { TString* pdfName = new TString((TString)"track_Phi_DataComp_@pT["+Form("%03.0f", ptCutLow)+","+Form("%03.0f", ptCutHigh)+"]"+pdfNameNorm); TString* pdfName_ratio = new TString((TString)"track_Phi_DataComp_@pT["+Form("%03.0f", ptCutLow)+","+Form("%03.0f", ptCutHigh)+"]"+pdfNameNorm+"_ratio"); - std::array, 2> legendPlacementCustom = {{{0.2, 0.2}, {0.4, 0.45}}}; // {{{x1, y1}, {x2, y2}}} + std::array, 2> drawnWindowEtaTwoByTwoRatio = {{{-1, 7}, {0.9, 1.5}}}; // {{xmin, xmax}, {ymin, ymax}} + std::array, 2> legendPlacementCustomRatio = {{{0.53, 0.65}, {0.58, 0.85}}}; // {{{x1, y1}, {x2, y2}}} + std::array, 2> legendPlacementCustom = {{{0.65, 0.68}, {0.85, 0.85}}}; // {{{x1, y1}, {x2, y2}}} + std::array, 2> drawnWindowEta = {{{-999, -999}, {-999, -999}}}; // {{xmin, xmax}, {ymin, ymax}} - Draw_TH1_Histograms(H1D_trackPhi_rebinned, DatasetsNames, nDatasets, textContext, pdfName, texPhiX, textYaxis, texCollisionDataInfo, drawnWindowAuto, legendPlacementCustom, contextPlacementAuto, "histWithLine"+histDatasetComparisonStructure); + Draw_TH1_Histograms(H1D_trackPhi_rebinned, DatasetsNames, nDatasets, textContext, pdfName, texPhiX, textYaxis, texCollisionDataInfo, drawnWindowEta, legendPlacementCustom, contextPlacementAuto, "histWithLine"+histDatasetComparisonStructure); if (divideSuccess == true) { if (histDatasetComparisonStructure.find("twoByTwoDatasetPairs") != std::string::npos) { - Draw_TH1_Histograms(H1D_trackPhi_rebinned_ratios, DatasetsNamesPairRatio, nHistPairRatio, textContext, pdfName_ratio, texPhiX, texRatio, texCollisionDataInfo, drawnWindowAuto, legendPlacementAuto, contextPlacementAuto, "zoomToOneExtraExtra"); + Draw_TH1_Histograms(H1D_trackPhi_rebinned_ratios, DatasetsNamesPairRatio, nHistPairRatio, textContext, pdfName_ratio, texPhiX, texRatio, texCollisionDataInfo, drawnWindowEtaTwoByTwoRatio, legendPlacementCustomRatio, contextPlacementAuto, "zoomToOneExtraExtra"); } else { Draw_TH1_Histograms(H1D_trackPhi_rebinned_ratios, DatasetsNames, nDatasets, textContext, pdfName_ratio, texPhiX, texRatioDatasets, texCollisionDataInfo, drawnWindowAuto, legendPlacementCustom, contextPlacementAuto, "noMarkerFirst"+histDatasetComparisonStructure); } @@ -547,7 +615,7 @@ void Draw_Pt_CentralityComparison(int iDataset) { TH2D* H2D_trackPttrackCent; TH1D* H1D_trackPt[nCentralityBins]; TH1D* H1D_trackPt_rebinned[nCentralityBins]; - + if (trackHistsObsoleteVersion[iDataset]) { H2D_trackPttrackCent = (TH2D*)((TH2D*)file_O2Analysis_list[iDataset]->Get(analysisWorkflow[iDataset]+"/h2_centrality_track_pt"))->Clone("Draw_Pt_CentralityComparison"+Datasets[iDataset]+DatasetsNames[iDataset]); H2D_trackPttrackCent->Sumw2(); @@ -1020,6 +1088,7 @@ void Draw_Sigmapt_vs_pt_DatasetComp() { // TString textContext(contextDatasetComp("")); TString textContext(contextCustomTwoFields(*texDatasetsComparisonCommonDenominator, *texDatasetsComparisonType, "")); + std::array, 2> legendPlacement = {{{0.55, 0.65}, {0.65, 0.75}}}; // {{{x1, y1}, {x2, y2}}} std::array, 3> drawnWindow2DSigma = {{{0.1, 100}, {0.001, 100}, {-999, -999}}}; // {{xmin, xmax}, {ymin, ymax}} // Draw_TH2_Histograms(H2D_sigmapt_pt_concatenated, DatasetsNames, nDatasets, textContext, pdfName, texPtX, texSigmaPt, texCollisionDataInfo, drawnWindowSigma, th2ContoursNone, contourNumberNone, "logx,logz,autoRangeSame"); // ? @@ -1309,5 +1378,4 @@ void Draw_DcaXY_DatasetComp() { } cout << "tesst3" << endl; -} - +} \ No newline at end of file