diff --git a/PWGLF/TableProducer/Common/spvector.cxx b/PWGLF/TableProducer/Common/spvector.cxx index a4745326074..50c5528c1ef 100644 --- a/PWGLF/TableProducer/Common/spvector.cxx +++ b/PWGLF/TableProducer/Common/spvector.cxx @@ -114,6 +114,7 @@ struct spvector { Configurable hfinebinTime{"hfinebinTime", 120, "higher bin value in Time fine histograms"}; } configbins; + Configurable useoldrecentering{"useoldrecentering", true, "flag to perform old vs new recentering"}; Configurable useShift{"useShift", false, "shift histograms"}; Configurable ispolarization{"ispolarization", false, "Flag to check polarization"}; Configurable followpub{"followpub", true, "flag to use alphaZDC"}; @@ -175,27 +176,56 @@ struct spvector { Configurable confRecentereTimeSp2{"confRecentereTimeSp2", "Users/p/prottay/My/Object/GCwithoutcfactorgoodVztimedep/From676541/TestDDlocal/2024PbPbpass3_23062026/recenterlast2", "Path to time recentering map 2"}; Configurable confRecentereTimeSp3{"confRecentereTimeSp3", "Users/p/prottay/My/Object/GCwithoutcfactorgoodVztimedep/From676541/TestDDlocal/2024PbPbpass3_23062026/recenterlast3", "Path to time recentering map 3"}; - // Event selection cuts - Alex - /* - TF1* fMultPVCutLow = nullptr; - TF1* fMultPVCutHigh = nullptr; - TF1* fMultCutLow = nullptr; - TF1* fMultCutHigh = nullptr; - TF1* fMultMultPVCut = nullptr; - */ - /* - template - bool eventSelected(TCollision collision, const double& centrality) - { - auto multNTracksPV = collision.multNTracksPV(); - if (multNTracksPV < fMultPVCutLow->Eval(centrality)) - return 0; - if (multNTracksPV > fMultPVCutHigh->Eval(centrality)) - return 0; - - return 1; - } - */ + struct : ConfigurableGroup { + // Five recentering stages. Each stage is applied in the strict order: + // cent -> (cent,Vx) -> (cent,Vy) -> (cent,Vz). + Configurable finecent1{"finecent1", false, "Apply fine centrality recentering, stage 1"}; + Configurable finecent2{"finecent2", false, "Apply fine centrality recentering, stage 2"}; + Configurable finecent3{"finecent3", false, "Apply fine centrality recentering, stage 3"}; + Configurable finecent4{"finecent4", false, "Apply fine centrality recentering, stage 4"}; + Configurable finecent5{"finecent5", false, "Apply fine centrality recentering, stage 5"}; + + Configurable finecentvx1{"finecentvx1", false, "Apply fine (cent,Vx) recentering, stage 1"}; + Configurable finecentvx2{"finecentvx2", false, "Apply fine (cent,Vx) recentering, stage 2"}; + Configurable finecentvx3{"finecentvx3", false, "Apply fine (cent,Vx) recentering, stage 3"}; + Configurable finecentvx4{"finecentvx4", false, "Apply fine (cent,Vx) recentering, stage 4"}; + Configurable finecentvx5{"finecentvx5", false, "Apply fine (cent,Vx) recentering, stage 5"}; + + Configurable finecentvy1{"finecentvy1", false, "Apply fine (cent,Vy) recentering, stage 1"}; + Configurable finecentvy2{"finecentvy2", false, "Apply fine (cent,Vy) recentering, stage 2"}; + Configurable finecentvy3{"finecentvy3", false, "Apply fine (cent,Vy) recentering, stage 3"}; + Configurable finecentvy4{"finecentvy4", false, "Apply fine (cent,Vy) recentering, stage 4"}; + Configurable finecentvy5{"finecentvy5", false, "Apply fine (cent,Vy) recentering, stage 5"}; + + Configurable finecentvz1{"finecentvz1", false, "Apply fine (cent,Vz) recentering, stage 1"}; + Configurable finecentvz2{"finecentvz2", false, "Apply fine (cent,Vz) recentering, stage 2"}; + Configurable finecentvz3{"finecentvz3", false, "Apply fine (cent,Vz) recentering, stage 3"}; + Configurable finecentvz4{"finecentvz4", false, "Apply fine (cent,Vz) recentering, stage 4"}; + Configurable finecentvz5{"finecentvz5", false, "Apply fine (cent,Vz) recentering, stage 5"}; + Configurable useRecenterefinecentSp{"useRecenterefinecentSp", false, "use finecent Recentering with THn"}; + Configurable useRecenterefinecentvxvyvzSp{"useRecenterefinecentvxvyvzSp", false, "use finecentvxvyvz Recentering with THn"}; + + Configurable confRecentereCentSp{"confRecentereCentSp", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for cent recentering"}; + Configurable confRecentereCentSp2{"confRecentereCentSp2", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for cent recentering 2"}; + Configurable confRecentereCentSp3{"confRecentereCentSp3", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for cent recentering 3"}; + Configurable confRecentereCentSp4{"confRecentereCentSp4", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for cent recentering 4"}; + Configurable confRecentereCentSp5{"confRecentereCentSp5", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for cent recentering 5"}; + Configurable confRecentereCentVxSp{"confRecentereCentVxSp", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvx recentering"}; + Configurable confRecentereCentVySp{"confRecentereCentVySp", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvy recentering"}; + Configurable confRecentereCentVzSp{"confRecentereCentVzSp", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvz recentering"}; + Configurable confRecentereCentVxSp2{"confRecentereCentVxSp2", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvx2 recentering"}; + Configurable confRecentereCentVySp2{"confRecentereCentVySp2", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvy2 recentering"}; + Configurable confRecentereCentVzSp2{"confRecentereCentVzSp2", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvz2 recentering"}; + Configurable confRecentereCentVxSp3{"confRecentereCentVxSp3", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvx3 recentering"}; + Configurable confRecentereCentVySp3{"confRecentereCentVySp3", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvy3 recentering"}; + Configurable confRecentereCentVzSp3{"confRecentereCentVzSp3", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvz3 recentering"}; + Configurable confRecentereCentVxSp4{"confRecentereCentVxSp4", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvx4 recentering"}; + Configurable confRecentereCentVySp4{"confRecentereCentVySp4", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvy4 recentering"}; + Configurable confRecentereCentVzSp4{"confRecentereCentVzSp4", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvz4 recentering"}; + Configurable confRecentereCentVxSp5{"confRecentereCentVxSp5", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvx5 recentering"}; + Configurable confRecentereCentVySp5{"confRecentereCentVySp5", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvy5 recentering"}; + Configurable confRecentereCentVzSp5{"confRecentereCentVzSp5", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvz5 recentering"}; + } confignewpro; struct : ConfigurableGroup { Configurable requireRCTFlagChecker{"requireRCTFlagChecker", true, "Check event quality in run condition table"}; @@ -266,6 +296,102 @@ struct spvector { histos.add("htimeQyZDCA", "htimeQyZDCA", kTH2F, {{timefineAxis}, {qxZDCAxis}}); histos.add("htimeQxZDCC", "htimeQxZDCC", kTH2F, {{timefineAxis}, {qxZDCAxis}}); histos.add("htimeQyZDCC", "htimeQyZDCC", kTH2F, {{timefineAxis}, {qxZDCAxis}}); + + histos.add("pQxZDCAvsCentVzAfter", + " after recentering;" + "centrality (%);V_{z} (cm);", + kTProfile2D, + {centfineAxis, vzfineAxis}); + + histos.add("pQyZDCAvsCentVzAfter", + " after recentering;" + "centrality (%);V_{z} (cm);", + kTProfile2D, + {centfineAxis, vzfineAxis}); + + histos.add("pQxZDCCvsCentVzAfter", + " after recentering;" + "centrality (%);V_{z} (cm);", + kTProfile2D, + {centfineAxis, vzfineAxis}); + + histos.add("pQyZDCCvsCentVzAfter", + " after recentering;" + "centrality (%);V_{z} (cm);", + kTProfile2D, + {centfineAxis, vzfineAxis}); + + histos.add("pQxZDCAvsCentVyAfter", + " after recentering;" + "centrality (%);V_{y} (cm);", + kTProfile2D, + {centfineAxis, vyfineAxis}); + + histos.add("pQyZDCAvsCentVyAfter", + " after recentering;" + "centrality (%);V_{y} (cm);", + kTProfile2D, + {centfineAxis, vyfineAxis}); + + histos.add("pQxZDCCvsCentVyAfter", + " after recentering;" + "centrality (%);V_{y} (cm);", + kTProfile2D, + {centfineAxis, vyfineAxis}); + + histos.add("pQyZDCCvsCentVyAfter", + " after recentering;" + "centrality (%);V_{y} (cm);", + kTProfile2D, + {centfineAxis, vyfineAxis}); + + histos.add("pQxZDCAvsCentVxAfter", + " after recentering;" + "centrality (%);V_{x} (cm);", + kTProfile2D, + {centfineAxis, vxfineAxis}); + + histos.add("pQyZDCAvsCentVxAfter", + " after recentering;" + "centrality (%);V_{x} (cm);", + kTProfile2D, + {centfineAxis, vxfineAxis}); + + histos.add("pQxZDCCvsCentVxAfter", + " after recentering;" + "centrality (%);V_{x} (cm);", + kTProfile2D, + {centfineAxis, vxfineAxis}); + + histos.add("pQyZDCCvsCentVxAfter", + " after recentering;" + "centrality (%);V_{x} (cm);", + kTProfile2D, + {centfineAxis, vxfineAxis}); + + histos.add("pQxZDCAvsVyVxAfter", + " after recentering;" + "V_{y};V_{x} (cm);", + kTProfile2D, + {vyfineAxis, vxfineAxis}); + + histos.add("pQyZDCAvsVyVxAfter", + " after recentering;" + "V_{y};V_{x} (cm);", + kTProfile2D, + {vyfineAxis, vxfineAxis}); + + histos.add("pQxZDCCvsVyVxAfter", + " after recentering;" + "V_{y};V_{x} (cm);", + kTProfile2D, + {vyfineAxis, vxfineAxis}); + + histos.add("pQyZDCCvsVyVxAfter", + " after recentering;" + "V_{y};V_{x} (cm);", + kTProfile2D, + {vyfineAxis, vxfineAxis}); } histos.add("PsiZDCC", "PsiZDCC", kTH2F, {centfineAxis, phiAxis}); @@ -282,19 +408,6 @@ struct spvector { histos.add("hpQyZDCAvstime", "hpQyZDCAvstime", kTProfile, {{timefineAxis}}); histos.add("hpQyZDCCvstime", "hpQyZDCCvstime", kTProfile, {{timefineAxis}}); - // Event selection cut additional - Alex - /* - fMultPVCutLow = new TF1("fMultPVCutLow", "[0]+[1]*x+[2]*x*x+[3]*x*x*x - 2.5*([4]+[5]*x+[6]*x*x+[7]*x*x*x+[8]*x*x*x*x)", 0, 100); - fMultPVCutLow->SetParameters(2834.66, -87.0127, 0.915126, -0.00330136, 332.513, -12.3476, 0.251663, -0.00272819, 1.12242e-05); - fMultPVCutHigh = new TF1("fMultPVCutHigh", "[0]+[1]*x+[2]*x*x+[3]*x*x*x + 2.5*([4]+[5]*x+[6]*x*x+[7]*x*x*x+[8]*x*x*x*x)", 0, 100); - fMultPVCutHigh->SetParameters(2834.66, -87.0127, 0.915126, -0.00330136, 332.513, -12.3476, 0.251663, -0.00272819, 1.12242e-05); - fMultCutLow = new TF1("fMultCutLow", "[0]+[1]*x+[2]*x*x+[3]*x*x*x - 2.5*([4]+[5]*x)", 0, 100); - fMultCutLow->SetParameters(1893.94, -53.86, 0.502913, -0.0015122, 109.625, -1.19253); - fMultCutHigh = new TF1("fMultCutHigh", "[0]+[1]*x+[2]*x*x+[3]*x*x*x + 3.*([4]+[5]*x)", 0, 100); - fMultCutHigh->SetParameters(1893.94, -53.86, 0.502913, -0.0015122, 109.625, -1.19253); - fMultMultPVCut = new TF1("fMultMultPVCut", "[0]+[1]*x+[2]*x*x", 0, 5000); - fMultMultPVCut->SetParameters(-0.1, 0.785, -4.7e-05); - */ ccdb->setURL(cfgCcdbParam.cfgURL); ccdb->setCaching(true); ccdb->setLocalObjectValidityChecking(); @@ -303,18 +416,137 @@ struct spvector { int currentRunNumber = -999; int lastRunNumber = -999; - TH2D* gainprofile; - TProfile* gainprofilevxy; + TH2D* gainprofile = nullptr; + TProfile* gainprofilevxy = nullptr; std::array hrecentereSpA; // Array of 6 histograms std::array hrecenterecentSpA; // Array of 5 histograms std::array hrecenterevxSpA; // Array of 5 histograms std::array hrecenterevySpA; // Array of 5 histograms std::array hrecenterevzSpA; // Array of 5 histograms - TProfile3D* shiftprofileA; - TProfile3D* shiftprofileC; + TProfile3D* shiftprofileA = nullptr; + TProfile3D* shiftprofileC = nullptr; TH2F* hrecentereTimeSp1 = nullptr; TH2F* hrecentereTimeSp2 = nullptr; TH2F* hrecentereTimeSp3 = nullptr; + // One payload for each of the five iterations. + std::array hrecenterecentvxSpA{}; + std::array hrecenterecentvySpA{}; + std::array hrecenterecentvzSpA{}; + + bool CorrectfineCent(TH2F* hrecenterecentSp, + auto centrality, + auto& qxZDCA, + auto& qyZDCA, + auto& qxZDCC, + auto& qyZDCC) + { + if (!hrecenterecentSp) { + return false; + } + + const double meanxAcent = hrecenterecentSp->GetBinContent( + hrecenterecentSp->FindBin(centrality + 0.00001, 0.5)); + const double meanyAcent = hrecenterecentSp->GetBinContent( + hrecenterecentSp->FindBin(centrality + 0.00001, 1.5)); + const double meanxCcent = hrecenterecentSp->GetBinContent( + hrecenterecentSp->FindBin(centrality + 0.00001, 2.5)); + const double meanyCcent = hrecenterecentSp->GetBinContent( + hrecenterecentSp->FindBin(centrality + 0.00001, 3.5)); + + qxZDCA -= meanxAcent; + qyZDCA -= meanyAcent; + qxZDCC -= meanxCcent; + qyZDCC -= meanyCcent; + + return true; + } + + bool CorrectfineCentVx(TH3F* hrecenterecentvxSp, + auto centrality, + auto vx, + auto& qxZDCA, + auto& qyZDCA, + auto& qxZDCC, + auto& qyZDCC) + { + if (!hrecenterecentvxSp) { + return false; + } + + const double meanxAcentvx = hrecenterecentvxSp->GetBinContent( + hrecenterecentvxSp->FindBin(centrality + 0.00001, vx + 0.00001, 0.5)); + const double meanyAcentvx = hrecenterecentvxSp->GetBinContent( + hrecenterecentvxSp->FindBin(centrality + 0.00001, vx + 0.00001, 1.5)); + const double meanxCcentvx = hrecenterecentvxSp->GetBinContent( + hrecenterecentvxSp->FindBin(centrality + 0.00001, vx + 0.00001, 2.5)); + const double meanyCcentvx = hrecenterecentvxSp->GetBinContent( + hrecenterecentvxSp->FindBin(centrality + 0.00001, vx + 0.00001, 3.5)); + + qxZDCA -= meanxAcentvx; + qyZDCA -= meanyAcentvx; + qxZDCC -= meanxCcentvx; + qyZDCC -= meanyCcentvx; + + return true; + } + + bool CorrectfineCentVy(TH3F* hrecenterecentvySp, + auto centrality, + auto vy, + auto& qxZDCA, + auto& qyZDCA, + auto& qxZDCC, + auto& qyZDCC) + { + if (!hrecenterecentvySp) { + return false; + } + + const double meanxAcentvy = hrecenterecentvySp->GetBinContent( + hrecenterecentvySp->FindBin(centrality + 0.00001, vy + 0.00001, 0.5)); + const double meanyAcentvy = hrecenterecentvySp->GetBinContent( + hrecenterecentvySp->FindBin(centrality + 0.00001, vy + 0.00001, 1.5)); + const double meanxCcentvy = hrecenterecentvySp->GetBinContent( + hrecenterecentvySp->FindBin(centrality + 0.00001, vy + 0.00001, 2.5)); + const double meanyCcentvy = hrecenterecentvySp->GetBinContent( + hrecenterecentvySp->FindBin(centrality + 0.00001, vy + 0.00001, 3.5)); + + qxZDCA -= meanxAcentvy; + qyZDCA -= meanyAcentvy; + qxZDCC -= meanxCcentvy; + qyZDCC -= meanyCcentvy; + + return true; + } + + bool CorrectfineCentVz(TH3F* hrecenterecentvzSp, + auto centrality, + auto vz, + auto& qxZDCA, + auto& qyZDCA, + auto& qxZDCC, + auto& qyZDCC) + { + if (!hrecenterecentvzSp) { + return false; + } + + const double meanxAcentvz = hrecenterecentvzSp->GetBinContent( + hrecenterecentvzSp->FindBin(centrality + 0.00001, vz + 0.00001, 0.5)); + const double meanyAcentvz = hrecenterecentvzSp->GetBinContent( + hrecenterecentvzSp->FindBin(centrality + 0.00001, vz + 0.00001, 1.5)); + const double meanxCcentvz = hrecenterecentvzSp->GetBinContent( + hrecenterecentvzSp->FindBin(centrality + 0.00001, vz + 0.00001, 2.5)); + const double meanyCcentvz = hrecenterecentvzSp->GetBinContent( + hrecenterecentvzSp->FindBin(centrality + 0.00001, vz + 0.00001, 3.5)); + + qxZDCA -= meanxAcentvz; + qyZDCA -= meanyAcentvz; + qxZDCC -= meanxCcentvz; + qyZDCC -= meanyCcentvz; + + return true; + } bool Correctcoarse(const THnF* hrecentereSp, auto centrality, auto vx, auto vy, auto vz, auto& qxZDCA, auto& qyZDCA, auto& qxZDCC, auto& qyZDCC) { @@ -464,7 +696,8 @@ struct spvector { // Store first timestamp of run to calculate relative time static std::unordered_map runStartTime; if (runStartTime.find(currentRunNumber) == runStartTime.end()) { - runStartTime[currentRunNumber] = timestampzdc; + // runStartTime[currentRunNumber] = timestampzdc; + runStartTime.try_emplace(currentRunNumber, timestampzdc); } double timeMin = (timestampzdc - runStartTime[currentRunNumber]) / 60000.0; // ms -> minutes @@ -627,137 +860,350 @@ struct spvector { bool resfine = false; int check = 1; - if (coarse1) { - if (useRecentereSp && (currentRunNumber != lastRunNumber)) { - hrecentereSpA[0] = ccdb->getForTimeStamp(ConfRecentereSp.value, bc.timestamp()); + if (useoldrecentering) { + if (coarse1) { + if (useRecentereSp && (currentRunNumber != lastRunNumber)) { + hrecentereSpA[0] = ccdb->getForTimeStamp(ConfRecentereSp.value, bc.timestamp()); + } + res = Correctcoarse(hrecentereSpA[0], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); } - res = Correctcoarse(hrecentereSpA[0], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); - } - if (fine1) { + if (fine1) { - if (useRecenterefineSp && (currentRunNumber != lastRunNumber)) { - hrecenterecentSpA[0] = ccdb->getForTimeStamp(ConfRecenterecentSp.value, bc.timestamp()); - hrecenterevxSpA[0] = ccdb->getForTimeStamp(ConfRecenterevxSp.value, bc.timestamp()); - hrecenterevySpA[0] = ccdb->getForTimeStamp(ConfRecenterevySp.value, bc.timestamp()); - hrecenterevzSpA[0] = ccdb->getForTimeStamp(ConfRecenterevzSp.value, bc.timestamp()); + if (useRecenterefineSp && (currentRunNumber != lastRunNumber)) { + hrecenterecentSpA[0] = ccdb->getForTimeStamp(ConfRecenterecentSp.value, bc.timestamp()); + hrecenterevxSpA[0] = ccdb->getForTimeStamp(ConfRecenterevxSp.value, bc.timestamp()); + hrecenterevySpA[0] = ccdb->getForTimeStamp(ConfRecenterevySp.value, bc.timestamp()); + hrecenterevzSpA[0] = ccdb->getForTimeStamp(ConfRecenterevzSp.value, bc.timestamp()); + } + resfine = Correctfine(hrecenterecentSpA[0], hrecenterevxSpA[0], hrecenterevySpA[0], hrecenterevzSpA[0], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); } - resfine = Correctfine(hrecenterecentSpA[0], hrecenterevxSpA[0], hrecenterevySpA[0], hrecenterevzSpA[0], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); - } - if (finetime1 && (currentRunNumber != lastRunNumber)) { - hrecentereTimeSp1 = ccdb->getForTimeStamp(confRecentereTimeSp1.value, bc.timestamp()); - } - bool restime = false; - if (useTimeRecentering) { - restime = Correcttime(hrecentereTimeSp1, timeMin, qxZDCA, qyZDCA, qxZDCC, qyZDCC); - } + if (finetime1 && (currentRunNumber != lastRunNumber)) { + hrecentereTimeSp1 = ccdb->getForTimeStamp(confRecentereTimeSp1.value, bc.timestamp()); + } + bool restime = false; + if (useTimeRecentering) { + restime = Correcttime(hrecentereTimeSp1, timeMin, qxZDCA, qyZDCA, qxZDCC, qyZDCC); + } - if (coarse2) { - if (useRecentereSp && (currentRunNumber != lastRunNumber)) { - hrecentereSpA[1] = ccdb->getForTimeStamp(ConfRecentereSp2.value, bc.timestamp()); + if (coarse2) { + if (useRecentereSp && (currentRunNumber != lastRunNumber)) { + hrecentereSpA[1] = ccdb->getForTimeStamp(ConfRecentereSp2.value, bc.timestamp()); + } + res = Correctcoarse(hrecentereSpA[1], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); } - res = Correctcoarse(hrecentereSpA[1], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); - } - if (fine2) { - if (useRecenterefineSp && (currentRunNumber != lastRunNumber)) { - hrecenterecentSpA[1] = ccdb->getForTimeStamp(ConfRecenterecentSp2.value, bc.timestamp()); - hrecenterevxSpA[1] = ccdb->getForTimeStamp(ConfRecenterevxSp2.value, bc.timestamp()); - hrecenterevySpA[1] = ccdb->getForTimeStamp(ConfRecenterevySp2.value, bc.timestamp()); - hrecenterevzSpA[1] = ccdb->getForTimeStamp(ConfRecenterevzSp2.value, bc.timestamp()); + if (fine2) { + if (useRecenterefineSp && (currentRunNumber != lastRunNumber)) { + hrecenterecentSpA[1] = ccdb->getForTimeStamp(ConfRecenterecentSp2.value, bc.timestamp()); + hrecenterevxSpA[1] = ccdb->getForTimeStamp(ConfRecenterevxSp2.value, bc.timestamp()); + hrecenterevySpA[1] = ccdb->getForTimeStamp(ConfRecenterevySp2.value, bc.timestamp()); + hrecenterevzSpA[1] = ccdb->getForTimeStamp(ConfRecenterevzSp2.value, bc.timestamp()); + } + resfine = Correctfine(hrecenterecentSpA[1], hrecenterevxSpA[1], hrecenterevySpA[1], hrecenterevzSpA[1], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); } - resfine = Correctfine(hrecenterecentSpA[1], hrecenterevxSpA[1], hrecenterevySpA[1], hrecenterevzSpA[1], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); - } - if (finetime2 && (currentRunNumber != lastRunNumber)) { - hrecentereTimeSp2 = ccdb->getForTimeStamp(confRecentereTimeSp2.value, bc.timestamp()); - } - if (useTimeRecentering) { - restime = Correcttime(hrecentereTimeSp2, timeMin, qxZDCA, qyZDCA, qxZDCC, qyZDCC); - } + if (finetime2 && (currentRunNumber != lastRunNumber)) { + hrecentereTimeSp2 = ccdb->getForTimeStamp(confRecentereTimeSp2.value, bc.timestamp()); + } + if (useTimeRecentering) { + restime = Correcttime(hrecentereTimeSp2, timeMin, qxZDCA, qyZDCA, qxZDCC, qyZDCC); + } - if (coarse3) { - if (useRecentereSp && (currentRunNumber != lastRunNumber)) { - hrecentereSpA[2] = ccdb->getForTimeStamp(ConfRecentereSp3.value, bc.timestamp()); + if (coarse3) { + if (useRecentereSp && (currentRunNumber != lastRunNumber)) { + hrecentereSpA[2] = ccdb->getForTimeStamp(ConfRecentereSp3.value, bc.timestamp()); + } + res = Correctcoarse(hrecentereSpA[2], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); } - res = Correctcoarse(hrecentereSpA[2], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); - } - if (fine3) { - if (useRecenterefineSp && (currentRunNumber != lastRunNumber)) { - hrecenterecentSpA[2] = ccdb->getForTimeStamp(ConfRecenterecentSp3.value, bc.timestamp()); - hrecenterevxSpA[2] = ccdb->getForTimeStamp(ConfRecenterevxSp3.value, bc.timestamp()); - hrecenterevySpA[2] = ccdb->getForTimeStamp(ConfRecenterevySp3.value, bc.timestamp()); - hrecenterevzSpA[2] = ccdb->getForTimeStamp(ConfRecenterevzSp3.value, bc.timestamp()); + if (fine3) { + if (useRecenterefineSp && (currentRunNumber != lastRunNumber)) { + hrecenterecentSpA[2] = ccdb->getForTimeStamp(ConfRecenterecentSp3.value, bc.timestamp()); + hrecenterevxSpA[2] = ccdb->getForTimeStamp(ConfRecenterevxSp3.value, bc.timestamp()); + hrecenterevySpA[2] = ccdb->getForTimeStamp(ConfRecenterevySp3.value, bc.timestamp()); + hrecenterevzSpA[2] = ccdb->getForTimeStamp(ConfRecenterevzSp3.value, bc.timestamp()); + } + resfine = Correctfine(hrecenterecentSpA[2], hrecenterevxSpA[2], hrecenterevySpA[2], hrecenterevzSpA[2], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); } - resfine = Correctfine(hrecenterecentSpA[2], hrecenterevxSpA[2], hrecenterevySpA[2], hrecenterevzSpA[2], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); - } - if (finetime3 && (currentRunNumber != lastRunNumber)) { - hrecentereTimeSp3 = ccdb->getForTimeStamp(confRecentereTimeSp3.value, bc.timestamp()); - } - if (useTimeRecentering) { - restime = Correcttime(hrecentereTimeSp3, timeMin, qxZDCA, qyZDCA, qxZDCC, qyZDCC); - } + if (finetime3 && (currentRunNumber != lastRunNumber)) { + hrecentereTimeSp3 = ccdb->getForTimeStamp(confRecentereTimeSp3.value, bc.timestamp()); + } + if (useTimeRecentering) { + restime = Correcttime(hrecentereTimeSp3, timeMin, qxZDCA, qyZDCA, qxZDCC, qyZDCC); + } - if (coarse4) { - if (useRecentereSp && (currentRunNumber != lastRunNumber)) { - hrecentereSpA[3] = ccdb->getForTimeStamp(ConfRecentereSp4.value, bc.timestamp()); + if (coarse4) { + if (useRecentereSp && (currentRunNumber != lastRunNumber)) { + hrecentereSpA[3] = ccdb->getForTimeStamp(ConfRecentereSp4.value, bc.timestamp()); + } + res = Correctcoarse(hrecentereSpA[3], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); } - res = Correctcoarse(hrecentereSpA[3], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); - } - if (fine4) { - if (useRecenterefineSp && (currentRunNumber != lastRunNumber)) { - hrecenterecentSpA[3] = ccdb->getForTimeStamp(ConfRecenterecentSp4.value, bc.timestamp()); - hrecenterevxSpA[3] = ccdb->getForTimeStamp(ConfRecenterevxSp4.value, bc.timestamp()); - hrecenterevySpA[3] = ccdb->getForTimeStamp(ConfRecenterevySp4.value, bc.timestamp()); - hrecenterevzSpA[3] = ccdb->getForTimeStamp(ConfRecenterevzSp4.value, bc.timestamp()); + if (fine4) { + if (useRecenterefineSp && (currentRunNumber != lastRunNumber)) { + hrecenterecentSpA[3] = ccdb->getForTimeStamp(ConfRecenterecentSp4.value, bc.timestamp()); + hrecenterevxSpA[3] = ccdb->getForTimeStamp(ConfRecenterevxSp4.value, bc.timestamp()); + hrecenterevySpA[3] = ccdb->getForTimeStamp(ConfRecenterevySp4.value, bc.timestamp()); + hrecenterevzSpA[3] = ccdb->getForTimeStamp(ConfRecenterevzSp4.value, bc.timestamp()); + } + resfine = Correctfine(hrecenterecentSpA[3], hrecenterevxSpA[3], hrecenterevySpA[3], hrecenterevzSpA[3], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); } - resfine = Correctfine(hrecenterecentSpA[3], hrecenterevxSpA[3], hrecenterevySpA[3], hrecenterevzSpA[3], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); - } - if (coarse5) { - if (useRecentereSp && (currentRunNumber != lastRunNumber)) { - hrecentereSpA[4] = ccdb->getForTimeStamp(ConfRecentereSp5.value, bc.timestamp()); + if (coarse5) { + if (useRecentereSp && (currentRunNumber != lastRunNumber)) { + hrecentereSpA[4] = ccdb->getForTimeStamp(ConfRecentereSp5.value, bc.timestamp()); + } + res = Correctcoarse(hrecentereSpA[4], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); } - res = Correctcoarse(hrecentereSpA[4], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); - } - if (fine5) { - if (useRecenterefineSp && (currentRunNumber != lastRunNumber)) { - hrecenterecentSpA[4] = ccdb->getForTimeStamp(ConfRecenterecentSp5.value, bc.timestamp()); - hrecenterevxSpA[4] = ccdb->getForTimeStamp(ConfRecenterevxSp5.value, bc.timestamp()); - hrecenterevySpA[4] = ccdb->getForTimeStamp(ConfRecenterevySp5.value, bc.timestamp()); - hrecenterevzSpA[4] = ccdb->getForTimeStamp(ConfRecenterevzSp5.value, bc.timestamp()); + if (fine5) { + if (useRecenterefineSp && (currentRunNumber != lastRunNumber)) { + hrecenterecentSpA[4] = ccdb->getForTimeStamp(ConfRecenterecentSp5.value, bc.timestamp()); + hrecenterevxSpA[4] = ccdb->getForTimeStamp(ConfRecenterevxSp5.value, bc.timestamp()); + hrecenterevySpA[4] = ccdb->getForTimeStamp(ConfRecenterevySp5.value, bc.timestamp()); + hrecenterevzSpA[4] = ccdb->getForTimeStamp(ConfRecenterevzSp5.value, bc.timestamp()); + } + resfine = Correctfine(hrecenterecentSpA[4], hrecenterevxSpA[4], hrecenterevySpA[4], hrecenterevzSpA[4], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); } - resfine = Correctfine(hrecenterecentSpA[4], hrecenterevxSpA[4], hrecenterevySpA[4], hrecenterevzSpA[4], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); - } - if (coarse6) { - if (useRecentereSp && (currentRunNumber != lastRunNumber)) { - hrecentereSpA[5] = ccdb->getForTimeStamp(ConfRecentereSp6.value, bc.timestamp()); + if (coarse6) { + if (useRecentereSp && (currentRunNumber != lastRunNumber)) { + hrecentereSpA[5] = ccdb->getForTimeStamp(ConfRecentereSp6.value, bc.timestamp()); + } + res = Correctcoarse(hrecentereSpA[5], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); } - res = Correctcoarse(hrecentereSpA[5], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); - } - if (fine6) { - if (useRecenterefineSp && (currentRunNumber != lastRunNumber)) { - hrecenterecentSpA[5] = ccdb->getForTimeStamp(ConfRecenterecentSp6.value, bc.timestamp()); - hrecenterevxSpA[5] = ccdb->getForTimeStamp(ConfRecenterevxSp6.value, bc.timestamp()); - hrecenterevySpA[5] = ccdb->getForTimeStamp(ConfRecenterevySp6.value, bc.timestamp()); - hrecenterevzSpA[5] = ccdb->getForTimeStamp(ConfRecenterevzSp6.value, bc.timestamp()); + if (fine6) { + if (useRecenterefineSp && (currentRunNumber != lastRunNumber)) { + hrecenterecentSpA[5] = ccdb->getForTimeStamp(ConfRecenterecentSp6.value, bc.timestamp()); + hrecenterevxSpA[5] = ccdb->getForTimeStamp(ConfRecenterevxSp6.value, bc.timestamp()); + hrecenterevySpA[5] = ccdb->getForTimeStamp(ConfRecenterevySp6.value, bc.timestamp()); + hrecenterevzSpA[5] = ccdb->getForTimeStamp(ConfRecenterevzSp6.value, bc.timestamp()); + } + resfine = Correctfine(hrecenterecentSpA[5], hrecenterevxSpA[5], hrecenterevySpA[5], hrecenterevzSpA[5], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); } - resfine = Correctfine(hrecenterecentSpA[5], hrecenterevxSpA[5], hrecenterevySpA[5], hrecenterevzSpA[5], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); - } - if (res == 0 && resfine == 0 && check == 0) { - LOG(info) << "Histograms are null"; - } + if (res == 0 && resfine == 0 && check == 0) { + LOG(info) << "Histograms are null"; + } + + if (useTimeRecentering && restime == 0 && check == 0) { + LOG(info) << "Histograms are null"; + } + } else { + + // Each stage must preserve this order: + // centrality -> (centrality,Vx) -> (centrality,Vy) -> (centrality,Vz). + // Keeping the switches separate allows the residual maps to be made + // in the same order in separate calibration passes. + + // -------------------- Stage 1 -------------------- + if (confignewpro.finecent1) { + if (confignewpro.useRecenterefinecentSp && + (currentRunNumber != lastRunNumber || !hrecenterecentSpA[0])) { + hrecenterecentSpA[0] = ccdb->getForTimeStamp(confignewpro.confRecentereCentSp.value, bc.timestamp()); + } + if (!CorrectfineCent(hrecenterecentSpA[0], centrality, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) { + LOGF(fatal, "Cannot apply fine centrality recentering, stage 1"); + } + } + + if (confignewpro.finecentvx1) { + if (confignewpro.useRecenterefinecentvxvyvzSp && + (currentRunNumber != lastRunNumber || !hrecenterecentvxSpA[0])) { + hrecenterecentvxSpA[0] = ccdb->getForTimeStamp(confignewpro.confRecentereCentVxSp.value, bc.timestamp()); + } + if (!CorrectfineCentVx(hrecenterecentvxSpA[0], centrality, vx, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) { + LOGF(fatal, "Cannot apply fine (cent,Vx) recentering, stage 1"); + } + } - if (useTimeRecentering && restime == 0 && check == 0) { - LOG(info) << "Histograms are null"; + if (confignewpro.finecentvy1) { + if (confignewpro.useRecenterefinecentvxvyvzSp && + (currentRunNumber != lastRunNumber || !hrecenterecentvySpA[0])) { + hrecenterecentvySpA[0] = ccdb->getForTimeStamp(confignewpro.confRecentereCentVySp.value, bc.timestamp()); + } + if (!CorrectfineCentVy(hrecenterecentvySpA[0], centrality, vy, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) { + LOGF(fatal, "Cannot apply fine (cent,Vy) recentering, stage 1"); + } + } + + if (confignewpro.finecentvz1) { + if (confignewpro.useRecenterefinecentvxvyvzSp && + (currentRunNumber != lastRunNumber || !hrecenterecentvzSpA[0])) { + hrecenterecentvzSpA[0] = ccdb->getForTimeStamp(confignewpro.confRecentereCentVzSp.value, bc.timestamp()); + } + if (!CorrectfineCentVz(hrecenterecentvzSpA[0], centrality, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) { + LOGF(fatal, "Cannot apply fine (cent,Vz) recentering, stage 1"); + } + } + + // -------------------- Stage 2 -------------------- + if (confignewpro.finecent2) { + if (confignewpro.useRecenterefinecentSp && + (currentRunNumber != lastRunNumber || !hrecenterecentSpA[1])) { + hrecenterecentSpA[1] = ccdb->getForTimeStamp(confignewpro.confRecentereCentSp2.value, bc.timestamp()); + } + if (!CorrectfineCent(hrecenterecentSpA[1], centrality, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) { + LOGF(fatal, "Cannot apply fine centrality recentering, stage 2"); + } + } + + if (confignewpro.finecentvx2) { + if (confignewpro.useRecenterefinecentvxvyvzSp && + (currentRunNumber != lastRunNumber || !hrecenterecentvxSpA[1])) { + hrecenterecentvxSpA[1] = ccdb->getForTimeStamp(confignewpro.confRecentereCentVxSp2.value, bc.timestamp()); + } + if (!CorrectfineCentVx(hrecenterecentvxSpA[1], centrality, vx, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) { + LOGF(fatal, "Cannot apply fine (cent,Vx) recentering, stage 2"); + } + } + + if (confignewpro.finecentvy2) { + if (confignewpro.useRecenterefinecentvxvyvzSp && + (currentRunNumber != lastRunNumber || !hrecenterecentvySpA[1])) { + hrecenterecentvySpA[1] = ccdb->getForTimeStamp(confignewpro.confRecentereCentVySp2.value, bc.timestamp()); + } + if (!CorrectfineCentVy(hrecenterecentvySpA[1], centrality, vy, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) { + LOGF(fatal, "Cannot apply fine (cent,Vy) recentering, stage 2"); + } + } + + if (confignewpro.finecentvz2) { + if (confignewpro.useRecenterefinecentvxvyvzSp && + (currentRunNumber != lastRunNumber || !hrecenterecentvzSpA[1])) { + hrecenterecentvzSpA[1] = ccdb->getForTimeStamp(confignewpro.confRecentereCentVzSp2.value, bc.timestamp()); + } + if (!CorrectfineCentVz(hrecenterecentvzSpA[1], centrality, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) { + LOGF(fatal, "Cannot apply fine (cent,Vz) recentering, stage 2"); + } + } + + // -------------------- Stage 3 -------------------- + if (confignewpro.finecent3) { + if (confignewpro.useRecenterefinecentSp && + (currentRunNumber != lastRunNumber || !hrecenterecentSpA[2])) { + hrecenterecentSpA[2] = ccdb->getForTimeStamp(confignewpro.confRecentereCentSp3.value, bc.timestamp()); + } + if (!CorrectfineCent(hrecenterecentSpA[2], centrality, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) { + LOGF(fatal, "Cannot apply fine centrality recentering, stage 3"); + } + } + + if (confignewpro.finecentvx3) { + if (confignewpro.useRecenterefinecentvxvyvzSp && + (currentRunNumber != lastRunNumber || !hrecenterecentvxSpA[2])) { + hrecenterecentvxSpA[2] = ccdb->getForTimeStamp(confignewpro.confRecentereCentVxSp3.value, bc.timestamp()); + } + if (!CorrectfineCentVx(hrecenterecentvxSpA[2], centrality, vx, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) { + LOGF(fatal, "Cannot apply fine (cent,Vx) recentering, stage 3"); + } + } + + if (confignewpro.finecentvy3) { + if (confignewpro.useRecenterefinecentvxvyvzSp && + (currentRunNumber != lastRunNumber || !hrecenterecentvySpA[2])) { + hrecenterecentvySpA[2] = ccdb->getForTimeStamp(confignewpro.confRecentereCentVySp3.value, bc.timestamp()); + } + if (!CorrectfineCentVy(hrecenterecentvySpA[2], centrality, vy, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) { + LOGF(fatal, "Cannot apply fine (cent,Vy) recentering, stage 3"); + } + } + + if (confignewpro.finecentvz3) { + if (confignewpro.useRecenterefinecentvxvyvzSp && + (currentRunNumber != lastRunNumber || !hrecenterecentvzSpA[2])) { + hrecenterecentvzSpA[2] = ccdb->getForTimeStamp(confignewpro.confRecentereCentVzSp3.value, bc.timestamp()); + } + if (!CorrectfineCentVz(hrecenterecentvzSpA[2], centrality, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) { + LOGF(fatal, "Cannot apply fine (cent,Vz) recentering, stage 3"); + } + } + + // -------------------- Stage 4 -------------------- + if (confignewpro.finecent4) { + if (confignewpro.useRecenterefinecentSp && + (currentRunNumber != lastRunNumber || !hrecenterecentSpA[3])) { + hrecenterecentSpA[3] = ccdb->getForTimeStamp(confignewpro.confRecentereCentSp4.value, bc.timestamp()); + } + if (!CorrectfineCent(hrecenterecentSpA[3], centrality, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) { + LOGF(fatal, "Cannot apply fine centrality recentering, stage 4"); + } + } + + if (confignewpro.finecentvx4) { + if (confignewpro.useRecenterefinecentvxvyvzSp && + (currentRunNumber != lastRunNumber || !hrecenterecentvxSpA[3])) { + hrecenterecentvxSpA[3] = ccdb->getForTimeStamp(confignewpro.confRecentereCentVxSp4.value, bc.timestamp()); + } + if (!CorrectfineCentVx(hrecenterecentvxSpA[3], centrality, vx, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) { + LOGF(fatal, "Cannot apply fine (cent,Vx) recentering, stage 4"); + } + } + + if (confignewpro.finecentvy4) { + if (confignewpro.useRecenterefinecentvxvyvzSp && + (currentRunNumber != lastRunNumber || !hrecenterecentvySpA[3])) { + hrecenterecentvySpA[3] = ccdb->getForTimeStamp(confignewpro.confRecentereCentVySp4.value, bc.timestamp()); + } + if (!CorrectfineCentVy(hrecenterecentvySpA[3], centrality, vy, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) { + LOGF(fatal, "Cannot apply fine (cent,Vy) recentering, stage 4"); + } + } + + if (confignewpro.finecentvz4) { + if (confignewpro.useRecenterefinecentvxvyvzSp && + (currentRunNumber != lastRunNumber || !hrecenterecentvzSpA[3])) { + hrecenterecentvzSpA[3] = ccdb->getForTimeStamp(confignewpro.confRecentereCentVzSp4.value, bc.timestamp()); + } + if (!CorrectfineCentVz(hrecenterecentvzSpA[3], centrality, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) { + LOGF(fatal, "Cannot apply fine (cent,Vz) recentering, stage 4"); + } + } + + // -------------------- Stage 5 -------------------- + if (confignewpro.finecent5) { + if (confignewpro.useRecenterefinecentSp && + (currentRunNumber != lastRunNumber || !hrecenterecentSpA[4])) { + hrecenterecentSpA[4] = ccdb->getForTimeStamp(confignewpro.confRecentereCentSp5.value, bc.timestamp()); + } + if (!CorrectfineCent(hrecenterecentSpA[4], centrality, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) { + LOGF(fatal, "Cannot apply fine centrality recentering, stage 5"); + } + } + + if (confignewpro.finecentvx5) { + if (confignewpro.useRecenterefinecentvxvyvzSp && + (currentRunNumber != lastRunNumber || !hrecenterecentvxSpA[4])) { + hrecenterecentvxSpA[4] = ccdb->getForTimeStamp(confignewpro.confRecentereCentVxSp5.value, bc.timestamp()); + } + if (!CorrectfineCentVx(hrecenterecentvxSpA[4], centrality, vx, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) { + LOGF(fatal, "Cannot apply fine (cent,Vx) recentering, stage 5"); + } + } + + if (confignewpro.finecentvy5) { + if (confignewpro.useRecenterefinecentvxvyvzSp && + (currentRunNumber != lastRunNumber || !hrecenterecentvySpA[4])) { + hrecenterecentvySpA[4] = ccdb->getForTimeStamp(confignewpro.confRecentereCentVySp5.value, bc.timestamp()); + } + if (!CorrectfineCentVy(hrecenterecentvySpA[4], centrality, vy, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) { + LOGF(fatal, "Cannot apply fine (cent,Vy) recentering, stage 5"); + } + } + + if (confignewpro.finecentvz5) { + if (confignewpro.useRecenterefinecentvxvyvzSp && + (currentRunNumber != lastRunNumber || !hrecenterecentvzSpA[4])) { + hrecenterecentvzSpA[4] = ccdb->getForTimeStamp(confignewpro.confRecentereCentVzSp5.value, bc.timestamp()); + } + if (!CorrectfineCentVz(hrecenterecentvzSpA[4], centrality, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) { + LOGF(fatal, "Cannot apply fine (cent,Vz) recentering, stage 5"); + } + } } histos.fill(HIST("hpQxZDCAvstime"), timeMin, qxZDCA); @@ -827,6 +1273,54 @@ struct spvector { histos.fill(HIST("hvzQyZDCA"), vz, qyZDCA); histos.fill(HIST("hvzQxZDCC"), vz, qxZDCC); histos.fill(HIST("hvzQyZDCC"), vz, qyZDCC); + + histos.fill(HIST("pQxZDCAvsCentVzAfter"), + centrality, vz, qxZDCA); + + histos.fill(HIST("pQyZDCAvsCentVzAfter"), + centrality, vz, qyZDCA); + + histos.fill(HIST("pQxZDCCvsCentVzAfter"), + centrality, vz, qxZDCC); + + histos.fill(HIST("pQyZDCCvsCentVzAfter"), + centrality, vz, qyZDCC); + + histos.fill(HIST("pQxZDCAvsCentVyAfter"), + centrality, vy, qxZDCA); + + histos.fill(HIST("pQyZDCAvsCentVyAfter"), + centrality, vy, qyZDCA); + + histos.fill(HIST("pQxZDCCvsCentVyAfter"), + centrality, vy, qxZDCC); + + histos.fill(HIST("pQyZDCCvsCentVyAfter"), + centrality, vy, qyZDCC); + + histos.fill(HIST("pQxZDCAvsCentVxAfter"), + centrality, vx, qxZDCA); + + histos.fill(HIST("pQyZDCAvsCentVxAfter"), + centrality, vx, qyZDCA); + + histos.fill(HIST("pQxZDCCvsCentVxAfter"), + centrality, vx, qxZDCC); + + histos.fill(HIST("pQyZDCCvsCentVxAfter"), + centrality, vx, qyZDCC); + + histos.fill(HIST("pQxZDCAvsVyVxAfter"), + vy, vx, qxZDCA); + + histos.fill(HIST("pQyZDCAvsVyVxAfter"), + vy, vx, qyZDCA); + + histos.fill(HIST("pQxZDCCvsVyVxAfter"), + vy, vx, qxZDCC); + + histos.fill(HIST("pQyZDCCvsVyVxAfter"), + vy, vx, qyZDCC); } histos.fill(HIST("hpCosPsiAPsiC"), centrality, (TMath::Cos(psiZDCA - psiZDCC)));