spvector.cxx

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
//
// \author: prottay das 23/12/2024
// \email: prottay.das@cern.ch

#include "PWGLF/DataModel/SPCalibrationTables.h"

#include "Common/CCDB/EventSelectionParams.h"
#include "Common/CCDB/RCTSelectionFlags.h"
#include "Common/DataModel/Centrality.h"
#include "Common/DataModel/EventSelection.h"
#include "Common/DataModel/FT0Corrected.h"
#include "Common/DataModel/Multiplicity.h"

#include <CCDB/BasicCCDBManager.h>
#include <Framework/AnalysisDataModel.h>
#include <Framework/AnalysisHelpers.h>
#include <Framework/AnalysisTask.h>
#include <Framework/Configurable.h>
#include <Framework/HistogramRegistry.h>
#include <Framework/HistogramSpec.h>
#include <Framework/InitContext.h>
#include <Framework/OutputObjHeader.h>
#include <Framework/runDataProcessing.h>

#include <TF1.h>
#include <TH2.h>
#include <TH3.h>
#include <THn.h>
#include <TMath.h>
#include <TMathBase.h>
#include <TProfile.h>
#include <TProfile3D.h>
#include <TRandom3.h>

#include <RtypesCore.h>

#include <array>
#include <chrono>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>

using namespace o2;
using namespace o2::framework;
using namespace o2::framework::expressions;
using namespace o2::constants::physics;
using namespace o2::aod::rctsel;

struct spvector {

  Produces<aod::SPCalibrationTables> spcalibrationtable;

  // Configurables.
  struct : ConfigurableGroup {
    Configurable<std::string> cfgURL{"cfgURL", "http://alice-ccdb.cern.ch", "Address of the CCDB to browse"};
    Configurable<int64_t> nolaterthan{"ccdb-no-later-than", std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count(), "Latest acceptable timestamp of creation for the object"};
  } cfgCcdbParam;

  // Enable access to the CCDB for the offset and correction constants and save them in dedicated variables.
  Service<o2::ccdb::BasicCCDBManager> ccdb;
  HistogramRegistry histos{"histos", {}, OutputObjHandlingPolicy::AnalysisObject};

  Configurable<float> cfgCutVertex{"cfgCutVertex", 10.0f, "Accepted z-vertex range"};
  Configurable<float> cfgCutCentralityMax{"cfgCutCentralityMax", 80.0f, "Centrality cut Max"};
  Configurable<float> cfgCutCentralityMin{"cfgCutCentralityMin", 0.0f, "Centrality cut Min"};
  Configurable<bool> additionalEvSel{"additionalEvSel", false, "additionalEvSel"};
  Configurable<bool> usemem{"usemem", true, "usemem"};
  Configurable<bool> usecfactor{"usecfactor", false, "use c factor"};

  struct : ConfigurableGroup {
    Configurable<int> QxyNbins{"QxyNbins", 100, "Number of bins in QxQy histograms"};
    Configurable<int> PhiNbins{"PhiNbins", 100, "Number of bins in phi histogram"};
    Configurable<float> lbinQxy{"lbinQxy", -5.0, "lower bin value in QxQy histograms"};
    Configurable<float> hbinQxy{"hbinQxy", 5.0, "higher bin value in QxQy histograms"};
    Configurable<int> VxNbins{"VxNbins", 25, "Number of bins in Vx histograms"};
    Configurable<float> lbinVx{"lbinVx", -0.05, "lower bin value in Vx histograms"};
    Configurable<float> hbinVx{"hbinVx", 0.0, "higher bin value in Vx histograms"};
    Configurable<int> VyNbins{"VyNbins", 25, "Number of bins in Vy histograms"};
    Configurable<float> lbinVy{"lbinVy", -0.02, "lower bin value in Vy histograms"};
    Configurable<float> hbinVy{"hbinVy", 0.02, "higher bin value in Vy histograms"};
    Configurable<int> VzNbins{"VzNbins", 20, "Number of bins in Vz histograms"};
    Configurable<float> lbinVz{"lbinVz", -10.0, "lower bin value in Vz histograms"};
    Configurable<float> hbinVz{"hbinVz", 10.0, "higher bin value in Vz histograms"};
    Configurable<int> CentNbins{"CentNbins", 16, "Number of bins in cent histograms"};
    Configurable<float> lbinCent{"lbinCent", 0.0, "lower bin value in cent histograms"};
    Configurable<float> hbinCent{"hbinCent", 80.0, "higher bin value in cent histograms"};
    Configurable<int> VxfineNbins{"VxfineNbins", 25, "Number of bins in Vx fine histograms"};
    Configurable<float> lfinebinVx{"lfinebinVx", -0.05, "lower bin value in Vx fine histograms"};
    Configurable<float> hfinebinVx{"hfinebinVx", 0.0, "higher bin value in Vx fine histograms"};
    Configurable<int> VyfineNbins{"VyfineNbins", 25, "Number of bins in Vy fine histograms"};
    Configurable<float> lfinebinVy{"lfinebinVy", -0.02, "lower bin value in Vy fine histograms"};
    Configurable<float> hfinebinVy{"hfinebinVy", 0.02, "higher bin value in Vy fine histograms"};
    Configurable<int> VzfineNbins{"VzfineNbins", 20, "Number of bins in Vz fine histograms"};
    Configurable<float> lfinebinVz{"lfinebinVz", -10.0, "lower bin value in Vz fine histograms"};
    Configurable<float> hfinebinVz{"hfinebinVz", 10.0, "higher bin value in Vz fine histograms"};
    Configurable<int> CentfineNbins{"CentfineNbins", 16, "Number of bins in cent fine histograms"};
    Configurable<float> lfinebinCent{"lfinebinCent", 0.0, "lower bin value in cent fine histograms"};
    Configurable<float> hfinebinCent{"hfinebinCent", 80.0, "higher bin value in cent fine histograms"};
    Configurable<int> TimefineNbins{"TimefineNbins", 120, "Number of bins in Time fine histograms"};
    Configurable<float> lfinebinTime{"lfinebinTime", 0, "lower bin value in Time fine histograms"};
    Configurable<float> hfinebinTime{"hfinebinTime", 120, "higher bin value in Time fine histograms"};
  } configbins;

  Configurable<bool> useoldrecentering{"useoldrecentering", true, "flag to perform old vs new recentering"};
  Configurable<bool> useShift{"useShift", false, "shift histograms"};
  Configurable<bool> ispolarization{"ispolarization", false, "Flag to check polarization"};
  Configurable<bool> followpub{"followpub", true, "flag to use alphaZDC"};
  Configurable<bool> useGainCallib{"useGainCallib", false, "use gain calibration"};
  Configurable<bool> useCallibvertex{"useCallibvertex", false, "use calibration for vxy"};
  Configurable<bool> coarse1{"coarse1", false, "RE1"};
  Configurable<bool> fine1{"fine1", false, "REfine1"};
  Configurable<bool> finetime1{"finetime1", false, "REfinetime1"};
  Configurable<bool> coarse2{"coarse2", false, "RE2"};
  Configurable<bool> fine2{"fine2", false, "REfine2"};
  Configurable<bool> finetime2{"finetime2", false, "REfinetime2"};
  Configurable<bool> coarse3{"coarse3", false, "RE3"};
  Configurable<bool> fine3{"fine3", false, "REfine3"};
  Configurable<bool> finetime3{"finetime3", false, "REfinetime3"};
  Configurable<bool> coarse4{"coarse4", false, "RE4"};
  Configurable<bool> fine4{"fine4", false, "REfine4"};
  Configurable<bool> coarse5{"coarse5", false, "RE5"};
  Configurable<bool> fine5{"fine5", false, "REfine5"};
  Configurable<bool> coarse6{"coarse6", false, "RE6"};
  Configurable<bool> fine6{"fine6", false, "REfine6"};
  Configurable<bool> useRecentereSp{"useRecentereSp", false, "use Recentering with Sparse or THn"};
  Configurable<bool> useRecenterefineSp{"useRecenterefineSp", false, "use fine Recentering with THn"};
  Configurable<bool> useTimeRecentering{"useTimeRecentering", false, "Use residual time recentering"};
  Configurable<std::string> ConfGainPath{"ConfGainPath", "Users/p/prottay/My/Object/NewPbPbpass4_10092024/gaincallib", "Path to gain calibration"};
  Configurable<std::string> ConfGainPathvxy{"ConfGainPathvxy", "Users/p/prottay/My/Object/swapcoords/PbPbpass4_20112024/recentervert", "Path to gain calibration for vxy"};
  Configurable<std::string> ConfRecentereSp{"ConfRecentereSp", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for recentere"};
  Configurable<std::string> ConfRecentereSp2{"ConfRecentereSp2", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for recentere2"};
  Configurable<std::string> ConfRecentereSp3{"ConfRecentereSp3", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for recentere3"};
  Configurable<std::string> ConfRecentereSp4{"ConfRecentereSp4", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for recentere4"};
  Configurable<std::string> ConfRecentereSp5{"ConfRecentereSp5", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for recentere5"};
  Configurable<std::string> ConfRecentereSp6{"ConfRecentereSp6", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for recentere6"};
  Configurable<std::string> ConfRecenterecentSp{"ConfRecenterecentSp", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for cent recentere"};
  Configurable<std::string> ConfRecenterevxSp{"ConfRecenterevxSp", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for vx recentere"};
  Configurable<std::string> ConfRecenterevySp{"ConfRecenterevySp", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for vy recentere"};
  Configurable<std::string> ConfRecenterevzSp{"ConfRecenterevzSp", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for vz recentere"};
  Configurable<std::string> ConfRecenterecentSp2{"ConfRecenterecentSp2", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for cent recentere2"};
  Configurable<std::string> ConfRecenterevxSp2{"ConfRecenterevxSp2", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for vx recentere2"};
  Configurable<std::string> ConfRecenterevySp2{"ConfRecenterevySp2", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for vy recentere2"};
  Configurable<std::string> ConfRecenterevzSp2{"ConfRecenterevzSp2", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for vz recentere2"};
  Configurable<std::string> ConfRecenterecentSp3{"ConfRecenterecentSp3", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for cent recentere3"};
  Configurable<std::string> ConfRecenterevxSp3{"ConfRecenterevxSp3", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for vx recentere3"};
  Configurable<std::string> ConfRecenterevySp3{"ConfRecenterevySp3", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for vy recentere3"};
  Configurable<std::string> ConfRecenterevzSp3{"ConfRecenterevzSp3", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for vz recentere3"};
  Configurable<std::string> ConfRecenterecentSp4{"ConfRecenterecentSp4", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for cent recentere4"};
  Configurable<std::string> ConfRecenterevxSp4{"ConfRecenterevxSp4", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for vx recentere4"};
  Configurable<std::string> ConfRecenterevySp4{"ConfRecenterevySp4", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for vy recentere4"};
  Configurable<std::string> ConfRecenterevzSp4{"ConfRecenterevzSp4", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for vz recentere4"};
  Configurable<std::string> ConfRecenterecentSp5{"ConfRecenterecentSp5", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for cent recentere5"};
  Configurable<std::string> ConfRecenterevxSp5{"ConfRecenterevxSp5", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for vx recentere5"};
  Configurable<std::string> ConfRecenterevySp5{"ConfRecenterevySp5", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for vy recentere5"};
  Configurable<std::string> ConfRecenterevzSp5{"ConfRecenterevzSp5", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for vz recentere5"};
  Configurable<std::string> ConfRecenterecentSp6{"ConfRecenterecentSp6", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for cent recentere6"};
  Configurable<std::string> ConfRecenterevxSp6{"ConfRecenterevxSp6", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for vx recentere6"};
  Configurable<std::string> ConfRecenterevySp6{"ConfRecenterevySp6", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for vy recentere6"};
  Configurable<std::string> ConfRecenterevzSp6{"ConfRecenterevzSp6", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for vz recentere6"};
  Configurable<std::string> ConfShiftC{"ConfShiftC", "Users/p/prottay/My/Object/Testinglocaltree/shiftcallib2", "Path to shift C"};
  Configurable<std::string> ConfShiftA{"ConfShiftA", "Users/p/prottay/My/Object/Testinglocaltree/shiftcallib2", "Path to shift A"};
  Configurable<std::string> confRecentereTimeSp1{"confRecentereTimeSp1", "Users/p/prottay/My/Object/GCwithoutcfactorgoodVztimedep/From676541/TestDDlocal/2024PbPbpass3_23062026/recenterlast2", "Path to time recentering map 1"};
  Configurable<std::string> confRecentereTimeSp2{"confRecentereTimeSp2", "Users/p/prottay/My/Object/GCwithoutcfactorgoodVztimedep/From676541/TestDDlocal/2024PbPbpass3_23062026/recenterlast2", "Path to time recentering map 2"};
  Configurable<std::string> confRecentereTimeSp3{"confRecentereTimeSp3", "Users/p/prottay/My/Object/GCwithoutcfactorgoodVztimedep/From676541/TestDDlocal/2024PbPbpass3_23062026/recenterlast3", "Path to time recentering map 3"};

  struct : ConfigurableGroup {
    // Five recentering stages. Each stage is applied in the strict order:
    // cent -> (cent,Vx) -> (cent,Vy) -> (cent,Vz).
    Configurable<bool> finecent1{"finecent1", false, "Apply fine centrality recentering, stage 1"};
    Configurable<bool> finecent2{"finecent2", false, "Apply fine centrality recentering, stage 2"};
    Configurable<bool> finecent3{"finecent3", false, "Apply fine centrality recentering, stage 3"};
    Configurable<bool> finecent4{"finecent4", false, "Apply fine centrality recentering, stage 4"};
    Configurable<bool> finecent5{"finecent5", false, "Apply fine centrality recentering, stage 5"};
    Configurable<bool> finecent6{"finecent6", false, "Apply fine centrality recentering, stage 6"};

    Configurable<bool> finecentvx1{"finecentvx1", false, "Apply fine (cent,Vx) recentering, stage 1"};
    Configurable<bool> finecentvx2{"finecentvx2", false, "Apply fine (cent,Vx) recentering, stage 2"};
    Configurable<bool> finecentvx3{"finecentvx3", false, "Apply fine (cent,Vx) recentering, stage 3"};
    Configurable<bool> finecentvx4{"finecentvx4", false, "Apply fine (cent,Vx) recentering, stage 4"};
    Configurable<bool> finecentvx5{"finecentvx5", false, "Apply fine (cent,Vx) recentering, stage 5"};
    Configurable<bool> finecentvx6{"finecentvx6", false, "Apply fine (cent,Vx) recentering, stage 6"};

    Configurable<bool> finecentvy1{"finecentvy1", false, "Apply fine (cent,Vy) recentering, stage 1"};
    Configurable<bool> finecentvy2{"finecentvy2", false, "Apply fine (cent,Vy) recentering, stage 2"};
    Configurable<bool> finecentvy3{"finecentvy3", false, "Apply fine (cent,Vy) recentering, stage 3"};
    Configurable<bool> finecentvy4{"finecentvy4", false, "Apply fine (cent,Vy) recentering, stage 4"};
    Configurable<bool> finecentvy5{"finecentvy5", false, "Apply fine (cent,Vy) recentering, stage 5"};
    Configurable<bool> finecentvy6{"finecentvy6", false, "Apply fine (cent,Vy) recentering, stage 6"};

    Configurable<bool> finecentvz1{"finecentvz1", false, "Apply fine (cent,Vz) recentering, stage 1"};
    Configurable<bool> finecentvz2{"finecentvz2", false, "Apply fine (cent,Vz) recentering, stage 2"};
    Configurable<bool> finecentvz3{"finecentvz3", false, "Apply fine (cent,Vz) recentering, stage 3"};
    Configurable<bool> finecentvz4{"finecentvz4", false, "Apply fine (cent,Vz) recentering, stage 4"};
    Configurable<bool> finecentvz5{"finecentvz5", false, "Apply fine (cent,Vz) recentering, stage 5"};
    Configurable<bool> finecentvz6{"finecentvz6", false, "Apply fine (cent,Vz) recentering, cycle 6"};

    Configurable<bool> finevztime1{"finevztime1", false, "Apply fine (Vz,time) recentering, cycle 1"};
    Configurable<bool> finevztime2{"finevztime2", false, "Apply fine (Vz,time) recentering, cycle 2"};
    Configurable<bool> finevztime3{"finevztime3", false, "Apply fine (Vz,time) recentering, cycle 3"};
    Configurable<bool> finevztime4{"finevztime4", false, "Apply fine (Vz,time) recentering, cycle 4"};
    Configurable<bool> finevztime5{"finevztime5", false, "Apply fine (Vz,time) recentering, cycle 5"};

    Configurable<bool> useRecenterefinecentSp{"useRecenterefinecentSp", false, "use finecent Recentering with THn"};
    Configurable<bool> useRecenterefinecentvxvyvzSp{"useRecenterefinecentvxvyvzSp", false, "use finecentvxvyvz Recentering with THn"};
    Configurable<bool> useRecenterefinevztimeSp{"useRecenterefinevztimeSp", false, "use fine (Vz,time) recentering with TH3F"};

    Configurable<std::string> confRecentereCentSp{"confRecentereCentSp", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for cent recentering"};
    Configurable<std::string> confRecentereCentSp2{"confRecentereCentSp2", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for cent recentering 2"};
    Configurable<std::string> confRecentereCentSp3{"confRecentereCentSp3", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for cent recentering 3"};
    Configurable<std::string> confRecentereCentSp4{"confRecentereCentSp4", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for cent recentering 4"};
    Configurable<std::string> confRecentereCentSp5{"confRecentereCentSp5", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for cent recentering 5"};
    Configurable<std::string> confRecentereCentSp6{"confRecentereCentSp6", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for cent recentering 6"};
    Configurable<std::string> confRecentereCentVxSp{"confRecentereCentVxSp", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvx recentering"};
    Configurable<std::string> confRecentereCentVySp{"confRecentereCentVySp", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvy recentering"};
    Configurable<std::string> confRecentereCentVzSp{"confRecentereCentVzSp", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvz recentering"};
    Configurable<std::string> confRecentereCentVxSp2{"confRecentereCentVxSp2", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvx2 recentering"};
    Configurable<std::string> confRecentereCentVySp2{"confRecentereCentVySp2", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvy2 recentering"};
    Configurable<std::string> confRecentereCentVzSp2{"confRecentereCentVzSp2", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvz2 recentering"};
    Configurable<std::string> confRecentereCentVxSp3{"confRecentereCentVxSp3", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvx3 recentering"};
    Configurable<std::string> confRecentereCentVySp3{"confRecentereCentVySp3", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvy3 recentering"};
    Configurable<std::string> confRecentereCentVzSp3{"confRecentereCentVzSp3", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvz3 recentering"};
    Configurable<std::string> confRecentereCentVxSp4{"confRecentereCentVxSp4", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvx4 recentering"};
    Configurable<std::string> confRecentereCentVySp4{"confRecentereCentVySp4", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvy4 recentering"};
    Configurable<std::string> confRecentereCentVzSp4{"confRecentereCentVzSp4", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvz4 recentering"};
    Configurable<std::string> confRecentereCentVxSp5{"confRecentereCentVxSp5", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvx5 recentering"};
    Configurable<std::string> confRecentereCentVySp5{"confRecentereCentVySp5", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvy5 recentering"};
    Configurable<std::string> confRecentereCentVzSp5{"confRecentereCentVzSp5", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvz5 recentering"};
    Configurable<std::string> confRecentereCentVxSp6{"confRecentereCentVxSp6", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvx6 recentering"};
    Configurable<std::string> confRecentereCentVySp6{"confRecentereCentVySp6", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvy6 recentering"};
    Configurable<std::string> confRecentereCentVzSp6{"confRecentereCentVzSp6", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn path for centvz6 recentering"};
    Configurable<std::string> confRecentereVzTimeSp{"confRecentereVzTimeSp", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "TH3F path for (Vz,time) recentering, cycle 1"};
    Configurable<std::string> confRecentereVzTimeSp2{"confRecentereVzTimeSp2", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "TH3F path for (Vz,time) recentering, cycle 2"};
    Configurable<std::string> confRecentereVzTimeSp3{"confRecentereVzTimeSp3", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "TH3F path for (Vz,time) recentering, cycle 3"};
    Configurable<std::string> confRecentereVzTimeSp4{"confRecentereVzTimeSp4", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "TH3F path for (Vz,time) recentering, cycle 4"};
    Configurable<std::string> confRecentereVzTimeSp5{"confRecentereVzTimeSp5", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "TH3F path for (Vz,time) recentering, cycle 5"};
  } confignewpro;

  struct : ConfigurableGroup {
    Configurable<bool> requireRCTFlagChecker{"requireRCTFlagChecker", true, "Check event quality in run condition table"};
    Configurable<std::string> cfgEvtRCTFlagCheckerLabel{"cfgEvtRCTFlagCheckerLabel", "CBT_hadronPID", "Evt sel: RCT flag checker label"};
    Configurable<bool> cfgEvtRCTFlagCheckerZDCCheck{"cfgEvtRCTFlagCheckerZDCCheck", true, "Evt sel: RCT flag checker ZDC check"};
    Configurable<bool> cfgEvtRCTFlagCheckerLimitAcceptAsBad{"cfgEvtRCTFlagCheckerLimitAcceptAsBad", false, "Evt sel: RCT flag checker treat Limited Acceptance As Bad"};
  } rctCut;

  RCTFlagsChecker rctChecker;

  void init(o2::framework::InitContext&)
  {

    rctChecker.init(rctCut.cfgEvtRCTFlagCheckerLabel, rctCut.cfgEvtRCTFlagCheckerZDCCheck, rctCut.cfgEvtRCTFlagCheckerLimitAcceptAsBad);

    AxisSpec channelZDCAxis = {8, 0.0, 8.0, "ZDC tower"};
    AxisSpec qxZDCAxis = {configbins.QxyNbins, configbins.lbinQxy, configbins.hbinQxy, "Qx"};
    AxisSpec phiAxis = {configbins.PhiNbins, -6.28, 6.28, "phi"};
    AxisSpec vzAxis = {configbins.VzNbins, configbins.lbinVz, configbins.hbinVz, "vz"};
    AxisSpec vxAxis = {configbins.VxNbins, configbins.lbinVx, configbins.hbinVx, "vx"};
    AxisSpec vyAxis = {configbins.VyNbins, configbins.lbinVy, configbins.hbinVy, "vy"};
    AxisSpec centAxis = {configbins.CentNbins, configbins.lbinCent, configbins.hbinCent, "V0M (%)"};
    AxisSpec vzfineAxis = {configbins.VzfineNbins, configbins.lfinebinVz, configbins.hfinebinVz, "vzfine"};
    AxisSpec vxfineAxis = {configbins.VxfineNbins, configbins.lfinebinVx, configbins.hfinebinVx, "vxfine"};
    AxisSpec vyfineAxis = {configbins.VyfineNbins, configbins.lfinebinVy, configbins.hfinebinVy, "vyfine"};
    AxisSpec centfineAxis = {configbins.CentfineNbins, configbins.lfinebinCent, configbins.hfinebinCent, "V0M (%) fine"};
    AxisSpec timefineAxis = {configbins.TimefineNbins, configbins.lfinebinTime, configbins.hfinebinTime, "timefine"};
    AxisSpec shiftAxis = {10, 0, 10, "shift"};
    AxisSpec basisAxis = {2, 0, 2, "basis"};
    AxisSpec VxyAxis = {2, 0, 2, "Vxy"};

    histos.add("htpcnsigmapi", "htpcnsigmapi", kTH1F, {{50, -10, 10.0}});
    histos.add("hEvtSelInfo", "hEvtSelInfo", kTH1F, {{10, 0, 10.0}});
    histos.add("hCentrality", "hCentrality", kTH1F, {{centfineAxis}});
    histos.add("Vz", "Vz", kTH1F, {vzfineAxis});
    histos.add("hpQxZDCAC", "hpQxZDCAC", kTProfile, {centfineAxis});
    histos.add("hpQyZDCAC", "hpQyZDCAC", kTProfile, {centfineAxis});
    histos.add("hpQxZDCAQyZDCC", "hpQxZDCAQyZDCC", kTProfile, {centfineAxis});
    histos.add("hpQxZDCCQyZDCA", "hpQxZDCCQyZDCA", kTProfile, {centfineAxis});

    if (!ispolarization) {
      histos.add("hnQxZDCA", "hnQxZDCA", kTHnF, {{centAxis}, {vxAxis}, {vyAxis}, {vzAxis}, {qxZDCAxis}});
      histos.add("hnQyZDCA", "hnQyZDCA", kTHnF, {{centAxis}, {vxAxis}, {vyAxis}, {vzAxis}, {qxZDCAxis}});
      histos.add("hnQxZDCC", "hnQxZDCC", kTHnF, {{centAxis}, {vxAxis}, {vyAxis}, {vzAxis}, {qxZDCAxis}});
      histos.add("hnQyZDCC", "hnQyZDCC", kTHnF, {{centAxis}, {vxAxis}, {vyAxis}, {vzAxis}, {qxZDCAxis}});

      histos.add("hcentQxZDCA", "hcentQxZDCA", kTH2F, {{centfineAxis}, {qxZDCAxis}});
      histos.add("hcentQyZDCA", "hcentQyZDCA", kTH2F, {{centfineAxis}, {qxZDCAxis}});
      histos.add("hcentQxZDCC", "hcentQxZDCC", kTH2F, {{centfineAxis}, {qxZDCAxis}});
      histos.add("hcentQyZDCC", "hcentQyZDCC", kTH2F, {{centfineAxis}, {qxZDCAxis}});

      histos.add("hvxQxZDCA", "hvxQxZDCA", kTH2F, {{vxfineAxis}, {qxZDCAxis}});
      histos.add("hvxQyZDCA", "hvxQyZDCA", kTH2F, {{vxfineAxis}, {qxZDCAxis}});
      histos.add("hvxQxZDCC", "hvxQxZDCC", kTH2F, {{vxfineAxis}, {qxZDCAxis}});
      histos.add("hvxQyZDCC", "hvxQyZDCC", kTH2F, {{vxfineAxis}, {qxZDCAxis}});

      histos.add("hvyQxZDCA", "hvyQxZDCA", kTH2F, {{vyfineAxis}, {qxZDCAxis}});
      histos.add("hvyQyZDCA", "hvyQyZDCA", kTH2F, {{vyfineAxis}, {qxZDCAxis}});
      histos.add("hvyQxZDCC", "hvyQxZDCC", kTH2F, {{vyfineAxis}, {qxZDCAxis}});
      histos.add("hvyQyZDCC", "hvyQyZDCC", kTH2F, {{vyfineAxis}, {qxZDCAxis}});

      histos.add("hvzQxZDCA", "hvzQxZDCA", kTH2F, {{vzfineAxis}, {qxZDCAxis}});
      histos.add("hvzQyZDCA", "hvzQyZDCA", kTH2F, {{vzfineAxis}, {qxZDCAxis}});
      histos.add("hvzQxZDCC", "hvzQxZDCC", kTH2F, {{vzfineAxis}, {qxZDCAxis}});
      histos.add("hvzQyZDCC", "hvzQyZDCC", kTH2F, {{vzfineAxis}, {qxZDCAxis}});

      histos.add("htimeQxZDCA", "htimeQxZDCA", kTH2F, {{timefineAxis}, {qxZDCAxis}});
      histos.add("htimeQyZDCA", "htimeQyZDCA", kTH2F, {{timefineAxis}, {qxZDCAxis}});
      histos.add("htimeQxZDCC", "htimeQxZDCC", kTH2F, {{timefineAxis}, {qxZDCAxis}});
      histos.add("htimeQyZDCC", "htimeQyZDCC", kTH2F, {{timefineAxis}, {qxZDCAxis}});

      histos.add("pQxZDCAvsCentVzAfter",
                 "<Q_{x}^{ZNA}> after recentering;"
                 "centrality (%);V_{z} (cm);<Q_{x}^{ZNA}>",
                 kTProfile2D,
                 {centfineAxis, vzfineAxis});

      histos.add("pQyZDCAvsCentVzAfter",
                 "<Q_{y}^{ZNA}> after recentering;"
                 "centrality (%);V_{z} (cm);<Q_{y}^{ZNA}>",
                 kTProfile2D,
                 {centfineAxis, vzfineAxis});

      histos.add("pQxZDCCvsCentVzAfter",
                 "<Q_{x}^{ZNC}> after recentering;"
                 "centrality (%);V_{z} (cm);<Q_{x}^{ZNC}>",
                 kTProfile2D,
                 {centfineAxis, vzfineAxis});

      histos.add("pQyZDCCvsCentVzAfter",
                 "<Q_{y}^{ZNC}> after recentering;"
                 "centrality (%);V_{z} (cm);<Q_{y}^{ZNC}>",
                 kTProfile2D,
                 {centfineAxis, vzfineAxis});

      histos.add("pQxZDCAvsCentVyAfter",
                 "<Q_{x}^{ZNA}> after recentering;"
                 "centrality (%);V_{y} (cm);<Q_{x}^{ZNA}>",
                 kTProfile2D,
                 {centfineAxis, vyfineAxis});

      histos.add("pQyZDCAvsCentVyAfter",
                 "<Q_{y}^{ZNA}> after recentering;"
                 "centrality (%);V_{y} (cm);<Q_{y}^{ZNA}>",
                 kTProfile2D,
                 {centfineAxis, vyfineAxis});

      histos.add("pQxZDCCvsCentVyAfter",
                 "<Q_{x}^{ZNC}> after recentering;"
                 "centrality (%);V_{y} (cm);<Q_{x}^{ZNC}>",
                 kTProfile2D,
                 {centfineAxis, vyfineAxis});

      histos.add("pQyZDCCvsCentVyAfter",
                 "<Q_{y}^{ZNC}> after recentering;"
                 "centrality (%);V_{y} (cm);<Q_{y}^{ZNC}>",
                 kTProfile2D,
                 {centfineAxis, vyfineAxis});

      histos.add("pQxZDCAvsCentVxAfter",
                 "<Q_{x}^{ZNA}> after recentering;"
                 "centrality (%);V_{x} (cm);<Q_{x}^{ZNA}>",
                 kTProfile2D,
                 {centfineAxis, vxfineAxis});

      histos.add("pQyZDCAvsCentVxAfter",
                 "<Q_{y}^{ZNA}> after recentering;"
                 "centrality (%);V_{x} (cm);<Q_{y}^{ZNA}>",
                 kTProfile2D,
                 {centfineAxis, vxfineAxis});

      histos.add("pQxZDCCvsCentVxAfter",
                 "<Q_{x}^{ZNC}> after recentering;"
                 "centrality (%);V_{x} (cm);<Q_{x}^{ZNC}>",
                 kTProfile2D,
                 {centfineAxis, vxfineAxis});

      histos.add("pQyZDCCvsCentVxAfter",
                 "<Q_{y}^{ZNC}> after recentering;"
                 "centrality (%);V_{x} (cm);<Q_{y}^{ZNC}>",
                 kTProfile2D,
                 {centfineAxis, vxfineAxis});

      histos.add("pQxZDCAvsVyVxAfter",
                 "<Q_{x}^{ZNA}> after recentering;"
                 "V_{y};V_{x} (cm);<Q_{x}^{ZNA}>",
                 kTProfile2D,
                 {vyfineAxis, vxfineAxis});

      histos.add("pQyZDCAvsVyVxAfter",
                 "<Q_{y}^{ZNA}> after recentering;"
                 "V_{y};V_{x} (cm);<Q_{y}^{ZNA}>",
                 kTProfile2D,
                 {vyfineAxis, vxfineAxis});

      histos.add("pQxZDCCvsVyVxAfter",
                 "<Q_{x}^{ZNC}> after recentering;"
                 "V_{y};V_{x} (cm);<Q_{x}^{ZNC}>",
                 kTProfile2D,
                 {vyfineAxis, vxfineAxis});

      histos.add("pQyZDCCvsVyVxAfter",
                 "<Q_{y}^{ZNC}> after recentering;"
                 "V_{y};V_{x} (cm);<Q_{y}^{ZNC}>",
                 kTProfile2D,
                 {vyfineAxis, vxfineAxis});

      histos.add("pQxZDCAvsCentTimeAfter",
                 "<Q_{x}^{ZNA}> after recentering;"
                 "centrality (%);Time (min);<Q_{x}^{ZNA}>",
                 kTProfile2D,
                 {centfineAxis, timefineAxis});

      histos.add("pQyZDCAvsCentTimeAfter",
                 "<Q_{y}^{ZNA}> after recentering;"
                 "centrality (%);Time (min);<Q_{y}^{ZNA}>",
                 kTProfile2D,
                 {centfineAxis, timefineAxis});

      histos.add("pQxZDCCvsCentTimeAfter",
                 "<Q_{x}^{ZNC}> after recentering;"
                 "centrality (%);Time (min);<Q_{x}^{ZNC}>",
                 kTProfile2D,
                 {centfineAxis, timefineAxis});

      histos.add("pQyZDCCvsCentTimeAfter",
                 "<Q_{y}^{ZNC}> after recentering;"
                 "centrality (%);Time (min);<Q_{y}^{ZNC}>",
                 kTProfile2D,
                 {centfineAxis, timefineAxis});

      histos.add("pQxZDCAvsVzTimeAfter",
                 "<Q_{x}^{ZNA}> after recentering;"
                 "vz (cm);Time (min);<Q_{x}^{ZNA}>",
                 kTProfile2D,
                 {vzfineAxis, timefineAxis});

      histos.add("pQyZDCAvsVzTimeAfter",
                 "<Q_{y}^{ZNA}> after recentering;"
                 "vz (cm);Time (min);<Q_{y}^{ZNA}>",
                 kTProfile2D,
                 {vzfineAxis, timefineAxis});

      histos.add("pQxZDCCvsVzTimeAfter",
                 "<Q_{x}^{ZNC}> after recentering;"
                 "vz (cm);Time (min);<Q_{x}^{ZNC}>",
                 kTProfile2D,
                 {vzfineAxis, timefineAxis});

      histos.add("pQyZDCCvsVzTimeAfter",
                 "<Q_{y}^{ZNC}> after recentering;"
                 "vz (cm);Time (min);<Q_{y}^{ZNC}>",
                 kTProfile2D,
                 {vzfineAxis, timefineAxis});
    }

    histos.add("PsiZDCC", "PsiZDCC", kTH2F, {centfineAxis, phiAxis});
    histos.add("PsiZDCA", "PsiZDCA", kTH2F, {centfineAxis, phiAxis});
    histos.add("ZDCAmp", "ZDCAmp", kTProfile2D, {channelZDCAxis, vzfineAxis});
    histos.add("ZDCAmpCommon", "ZDCAmpCommon", kTProfile2D, {{2, 0.0, 2.0}, vzfineAxis});
    histos.add("ShiftZDCC", "ShiftZDCC", kTProfile3D, {centfineAxis, basisAxis, shiftAxis});
    histos.add("ShiftZDCA", "ShiftZDCA", kTProfile3D, {centfineAxis, basisAxis, shiftAxis});
    histos.add("hpCosPsiAPsiC", "hpCosPsiAPsiC", kTProfile, {centfineAxis});
    histos.add("hpSinPsiAPsiC", "hpSinPsiAPsiC", kTProfile, {centfineAxis});
    histos.add("AvgVxy", "AvgVxy", kTProfile, {VxyAxis});
    histos.add("hpQxZDCAvstime", "hpQxZDCAvstime", kTProfile, {{timefineAxis}});
    histos.add("hpQxZDCCvstime", "hpQxZDCCvstime", kTProfile, {{timefineAxis}});
    histos.add("hpQyZDCAvstime", "hpQyZDCAvstime", kTProfile, {{timefineAxis}});
    histos.add("hpQyZDCCvstime", "hpQyZDCCvstime", kTProfile, {{timefineAxis}});

    ccdb->setURL(cfgCcdbParam.cfgURL);
    ccdb->setCaching(true);
    ccdb->setLocalObjectValidityChecking();
    ccdb->setCreatedNotAfter(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count());
  }

  int currentRunNumber = -999;
  int lastRunNumber = -999;
  TH2D* gainprofile = nullptr;
  TProfile* gainprofilevxy = nullptr;
  std::array<THnF*, 6> hrecentereSpA;     // Array of 6 histograms
  std::array<TH2F*, 6> hrecenterecentSpA; // Array of 5 histograms
  std::array<TH2F*, 6> hrecenterevxSpA;   // Array of 5 histograms
  std::array<TH2F*, 6> hrecenterevySpA;   // Array of 5 histograms
  std::array<TH2F*, 6> hrecenterevzSpA;   // Array of 5 histograms
  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<TH3F*, 6> hrecenterecentvxSpA{};
  std::array<TH3F*, 6> hrecenterecentvySpA{};
  std::array<TH3F*, 6> hrecenterecentvzSpA{};
  std::array<TH3F*, 5> hrecenterevztimeSpA{};

  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)
  {

    int binCoords[5];

    // Get axes of the THnSparse
    TAxis* centralityAxis = hrecentereSp->GetAxis(0); // Axis 0: centrality
    TAxis* vxAxis = hrecentereSp->GetAxis(1);         // Axis 1: vx
    TAxis* vyAxis = hrecentereSp->GetAxis(2);         // Axis 2: vy
    TAxis* vzAxis = hrecentereSp->GetAxis(3);         // Axis 3: vz
    TAxis* channelAxis = hrecentereSp->GetAxis(4);    // Axis 4: channel

    // Find bin indices for centrality, vx, vy, vz, and channel (for meanxA, 0.5)
    binCoords[0] = centralityAxis->FindBin(centrality + 0.00001); // Centrality
    binCoords[1] = vxAxis->FindBin(vx + 0.00001);                 // vx
    binCoords[2] = vyAxis->FindBin(vy + 0.00001);                 // vy
    binCoords[3] = vzAxis->FindBin(vz + 0.00001);                 // vz
    binCoords[4] = channelAxis->FindBin(0.5);                     // Channel for meanxA

    // Get the global bin for meanxA
    int globalBinMeanxA = hrecentereSp->GetBin(binCoords);
    float meanxA = hrecentereSp->GetBinContent(globalBinMeanxA);

    // Repeat for other channels (meanyA, meanxC, meanyC)
    binCoords[4] = channelAxis->FindBin(1.5); // Channel for meanyA
    int globalBinMeanyA = hrecentereSp->GetBin(binCoords);
    float meanyA = hrecentereSp->GetBinContent(globalBinMeanyA);

    binCoords[4] = channelAxis->FindBin(2.5); // Channel for meanxC
    int globalBinMeanxC = hrecentereSp->GetBin(binCoords);
    float meanxC = hrecentereSp->GetBinContent(globalBinMeanxC);

    binCoords[4] = channelAxis->FindBin(3.5); // Channel for meanyC
    int globalBinMeanyC = hrecentereSp->GetBin(binCoords);
    float meanyC = hrecentereSp->GetBinContent(globalBinMeanyC);

    qxZDCA = qxZDCA - meanxA;
    qyZDCA = qyZDCA - meanyA;
    qxZDCC = qxZDCC - meanxC;
    qyZDCC = qyZDCC - meanyC;

    return kTRUE;
  }

  bool Correctfine(TH2F* hrecenterecentSp, TH2F* hrecenterevxSp, TH2F* hrecenterevySp, TH2F* hrecenterevzSp, auto centrality, auto vx, auto vy, auto vz, auto& qxZDCA, auto& qyZDCA, auto& qxZDCC, auto& qyZDCC)
  {

    if (!hrecenterecentSp || !hrecenterevxSp || !hrecenterevySp || !hrecenterevzSp) {
      std::cerr << "Error: One or more histograms are null." << std::endl;
      return false;
    }

    double meanxAcent = hrecenterecentSp->GetBinContent(hrecenterecentSp->FindBin(centrality + 0.00001, 0.5));
    double meanyAcent = hrecenterecentSp->GetBinContent(hrecenterecentSp->FindBin(centrality + 0.00001, 1.5));
    double meanxCcent = hrecenterecentSp->GetBinContent(hrecenterecentSp->FindBin(centrality + 0.00001, 2.5));
    double meanyCcent = hrecenterecentSp->GetBinContent(hrecenterecentSp->FindBin(centrality + 0.00001, 3.5));

    double meanxAvx = hrecenterevxSp->GetBinContent(hrecenterevxSp->FindBin(vx + 0.00001, 0.5));
    double meanyAvx = hrecenterevxSp->GetBinContent(hrecenterevxSp->FindBin(vx + 0.00001, 1.5));
    double meanxCvx = hrecenterevxSp->GetBinContent(hrecenterevxSp->FindBin(vx + 0.00001, 2.5));
    double meanyCvx = hrecenterevxSp->GetBinContent(hrecenterevxSp->FindBin(vx + 0.00001, 3.5));

    double meanxAvy = hrecenterevySp->GetBinContent(hrecenterevySp->FindBin(vy + 0.00001, 0.5));
    double meanyAvy = hrecenterevySp->GetBinContent(hrecenterevySp->FindBin(vy + 0.00001, 1.5));
    double meanxCvy = hrecenterevySp->GetBinContent(hrecenterevySp->FindBin(vy + 0.00001, 2.5));
    double meanyCvy = hrecenterevySp->GetBinContent(hrecenterevySp->FindBin(vy + 0.00001, 3.5));

    double meanxAvz = hrecenterevzSp->GetBinContent(hrecenterevzSp->FindBin(vz + 0.00001, 0.5));
    double meanyAvz = hrecenterevzSp->GetBinContent(hrecenterevzSp->FindBin(vz + 0.00001, 1.5));
    double meanxCvz = hrecenterevzSp->GetBinContent(hrecenterevzSp->FindBin(vz + 0.00001, 2.5));
    double meanyCvz = hrecenterevzSp->GetBinContent(hrecenterevzSp->FindBin(vz + 0.00001, 3.5));

    qxZDCA = qxZDCA - meanxAcent - meanxAvx - meanxAvy - meanxAvz;
    qyZDCA = qyZDCA - meanyAcent - meanyAvx - meanyAvy - meanyAvz;
    qxZDCC = qxZDCC - meanxCcent - meanxCvx - meanxCvy - meanxCvz;
    qyZDCC = qyZDCC - meanyCcent - meanyCvx - meanyCvy - meanyCvz;

    return kTRUE;
  }

  bool Correcttime(TH2F* hrecentereTimeSp,
                   auto timeMin,
                   auto& qxZDCA,
                   auto& qyZDCA,
                   auto& qxZDCC,
                   auto& qyZDCC)
  {
    if (!hrecentereTimeSp) {
      return false;
    }

    double meanxA = hrecentereTimeSp->GetBinContent(hrecentereTimeSp->FindBin(timeMin + 1.e-7, 0.5));
    double meanyA = hrecentereTimeSp->GetBinContent(hrecentereTimeSp->FindBin(timeMin + 1.e-7, 1.5));
    double meanxC = hrecentereTimeSp->GetBinContent(hrecentereTimeSp->FindBin(timeMin + 1.e-7, 2.5));
    double meanyC = hrecentereTimeSp->GetBinContent(hrecentereTimeSp->FindBin(timeMin + 1.e-7, 3.5));

    qxZDCA -= meanxA;
    qyZDCA -= meanyA;
    qxZDCC -= meanxC;
    qyZDCC -= meanyC;

    return true;
  }

  bool CorrectfineVzTime(TH3F* hrecenterevstimeSp,
                         auto vz,
                         auto timeMin,
                         auto& qxZDCA,
                         auto& qyZDCA,
                         auto& qxZDCC,
                         auto& qyZDCC)
  {
    if (!hrecenterevstimeSp) {
      return false;
    }

    // Payload axes:
    //   X = Vz
    //   Y = time from run start
    //   Z = component
    // component channels:
    //   0.5 = Qx ZNA
    //   1.5 = Qy ZNA
    //   2.5 = Qx ZNC
    //   3.5 = Qy ZNC
    const double meanxAvstime = hrecenterevstimeSp->GetBinContent(
      hrecenterevstimeSp->FindBin(vz + 0.00001, timeMin + 0.00001, 0.5));
    const double meanyAvstime = hrecenterevstimeSp->GetBinContent(
      hrecenterevstimeSp->FindBin(vz + 0.00001, timeMin + 0.00001, 1.5));
    const double meanxCvstime = hrecenterevstimeSp->GetBinContent(
      hrecenterevstimeSp->FindBin(vz + 0.00001, timeMin + 0.00001, 2.5));
    const double meanyCvstime = hrecenterevstimeSp->GetBinContent(
      hrecenterevstimeSp->FindBin(vz + 0.00001, timeMin + 0.00001, 3.5));

    qxZDCA -= meanxAvstime;
    qyZDCA -= meanyAvstime;
    qxZDCC -= meanxCvstime;
    qyZDCC -= meanyCvstime;

    return true;
  }

  using BCsRun3 = soa::Join<aod::BCsWithTimestamps, aod::Run3MatchedToBCSparse>;
  using MyCollisions = soa::Join<aod::Collisions, aod::EvSels, aod::Mults, aod::FT0sCorrected, aod::CentFT0Cs>;
  Preslice<aod::Zdcs> zdcPerCollision = aod::collision::bcId;

  void process(MyCollisions::iterator const& collision, aod::FT0s const& /*ft0s*/, aod::FV0As const& /*fv0s*/, BCsRun3 const& bcs, aod::Zdcs const&)
  {
    histos.fill(HIST("hEvtSelInfo"), 0.5);
    auto centrality = collision.centFT0C();
    bool triggerevent = false;

    if (bcs.size() != 0) {
      gRandom->SetSeed(bcs.iteratorAt(0).globalBC());
    }

    currentRunNumber = collision.foundBC_as<BCsRun3>().runNumber();
    auto vz = collision.posZ();
    auto vx = collision.posX();
    auto vy = collision.posY();

    double psiZDCC = -99;
    double psiZDCA = -99;
    auto qxZDCA = 0.0;
    auto qxZDCC = 0.0;
    auto qyZDCA = 0.0;
    auto qyZDCC = 0.0;
    auto sumA = 0.0;
    auto sumC = 0.0;

    auto bc = collision.foundBC_as<BCsRun3>();

    if (!bc.has_zdc()) {
      triggerevent = false;
      spcalibrationtable(triggerevent, currentRunNumber, centrality, vx, vy, vz, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, qxZDCA, qxZDCC, qyZDCA, qyZDCC, psiZDCC, psiZDCA);
      return;
    }

    histos.fill(HIST("hEvtSelInfo"), 1.5);

    const uint64_t timestampzdc = bc.timestamp(); // in milliseconds

    // Convert timestamp to hours from run start (approximate)
    // Store first timestamp of run to calculate relative time
    static std::unordered_map<int, uint64_t> runStartTime;
    if (runStartTime.find(currentRunNumber) == runStartTime.end()) {
      // runStartTime[currentRunNumber] = timestampzdc;
      runStartTime.try_emplace(currentRunNumber, timestampzdc);
    }

    double timeMin = (timestampzdc - runStartTime[currentRunNumber]) / 60000.0; // ms -> minutes

    auto zdc = bc.zdc();
    auto zncEnergy = zdc.energySectorZNC();
    auto znaEnergy = zdc.energySectorZNA();
    auto zncEnergycommon = zdc.energyCommonZNC();
    auto znaEnergycommon = zdc.energyCommonZNA();
    auto beamEne = 5.36 * 0.5;

    if (znaEnergycommon <= 0.0 || zncEnergycommon <= 0.0) {
      triggerevent = false;
      spcalibrationtable(triggerevent, currentRunNumber, centrality, vx, vy, vz, znaEnergycommon, zncEnergycommon, znaEnergy[0], znaEnergy[1], znaEnergy[2], znaEnergy[3], zncEnergy[0], zncEnergy[1], zncEnergy[2], zncEnergy[3], qxZDCA, qxZDCC, qyZDCA, qyZDCC, psiZDCC, psiZDCA);
      return;
    }

    histos.fill(HIST("hEvtSelInfo"), 2.5);

    if (znaEnergy[0] <= 0.0 || znaEnergy[1] <= 0.0 || znaEnergy[2] <= 0.0 || znaEnergy[3] <= 0.0) {
      triggerevent = false;
      spcalibrationtable(triggerevent, currentRunNumber, centrality, vx, vy, vz, znaEnergycommon, zncEnergycommon, znaEnergy[0], znaEnergy[1], znaEnergy[2], znaEnergy[3], zncEnergy[0], zncEnergy[1], zncEnergy[2], zncEnergy[3], qxZDCA, qxZDCC, qyZDCA, qyZDCC, psiZDCC, psiZDCA);
      return;
    }
    histos.fill(HIST("hEvtSelInfo"), 3.5);

    if (zncEnergy[0] <= 0.0 || zncEnergy[1] <= 0.0 || zncEnergy[2] <= 0.0 || zncEnergy[3] <= 0.0) {
      triggerevent = false;
      spcalibrationtable(triggerevent, currentRunNumber, centrality, vx, vy, vz, znaEnergycommon, zncEnergycommon, znaEnergy[0], znaEnergy[1], znaEnergy[2], znaEnergy[3], zncEnergy[0], zncEnergy[1], zncEnergy[2], zncEnergy[3], qxZDCA, qxZDCC, qyZDCA, qyZDCC, psiZDCC, psiZDCA);
      return;
    }

    histos.fill(HIST("hEvtSelInfo"), 4.5);

    if (rctCut.requireRCTFlagChecker && !rctChecker(collision)) {
      triggerevent = false;
      spcalibrationtable(triggerevent, currentRunNumber, centrality, vx, vy, vz, znaEnergycommon, zncEnergycommon, znaEnergy[0], znaEnergy[1], znaEnergy[2], znaEnergy[3], zncEnergy[0], zncEnergy[1], zncEnergy[2], zncEnergy[3], qxZDCA, qxZDCC, qyZDCA, qyZDCC, psiZDCC, psiZDCA);
      return;
    }

    histos.fill(HIST("hEvtSelInfo"), 5.5);

    if (additionalEvSel && (!collision.selection_bit(aod::evsel::kIsGoodZvtxFT0vsPV))) {
      triggerevent = false;
      spcalibrationtable(triggerevent, currentRunNumber, centrality, vx, vy, vz, znaEnergycommon, zncEnergycommon, znaEnergy[0], znaEnergy[1], znaEnergy[2], znaEnergy[3], zncEnergy[0], zncEnergy[1], zncEnergy[2], zncEnergy[3], qxZDCA, qxZDCC, qyZDCA, qyZDCC, psiZDCC, psiZDCA);
      return;
    }

    histos.fill(HIST("hEvtSelInfo"), 6.5);

    if (collision.sel8() && centrality > cfgCutCentralityMin && centrality < cfgCutCentralityMax && TMath::Abs(vz) < cfgCutVertex && collision.has_foundFT0() && collision.selection_bit(aod::evsel::kNoTimeFrameBorder) && collision.selection_bit(aod::evsel::kNoITSROFrameBorder)) {
      triggerevent = true;
      if (useGainCallib && (currentRunNumber != lastRunNumber)) {
        gainprofile = ccdb->getForTimeStamp<TH2D>(ConfGainPath.value, bc.timestamp());
      }

      histos.fill(HIST("hEvtSelInfo"), 7.5);

      auto gainequal = 1.0;
      auto alphaZDC = 0.395;
      constexpr double x[4] = {-1.75, 1.75, -1.75, 1.75};
      constexpr double y[4] = {-1.75, -1.75, 1.75, 1.75};
      double zncEnergycommonsum = 0.0;
      double znaEnergycommonsum = 0.0;

      histos.fill(HIST("ZDCAmpCommon"), 0.5, vz, znaEnergycommon);
      histos.fill(HIST("ZDCAmpCommon"), 1.5, vz, zncEnergycommon);

      for (std::size_t iChA = 0; iChA < 8; iChA++) {
        auto chanelid = iChA;
        if (useGainCallib && gainprofile) {
          gainequal = gainprofile->GetBinContent(gainprofile->FindBin(vz + 0.00001, chanelid + 0.5));
        }

        if (iChA < 4) {

          if (znaEnergy[iChA] <= 0.0) {
            triggerevent = false;
            spcalibrationtable(triggerevent, currentRunNumber, centrality, vx, vy, vz, znaEnergycommon, zncEnergycommon, znaEnergy[0], znaEnergy[1], znaEnergy[2], znaEnergy[3], zncEnergy[0], zncEnergy[1], zncEnergy[2], zncEnergy[3], qxZDCA, qxZDCC, qyZDCA, qyZDCC, psiZDCC, psiZDCA);
            return;
          } else {
            double ampl = gainequal * znaEnergy[iChA];
            znaEnergycommonsum += ampl;
            if (followpub) {
              ampl = TMath::Power(ampl, alphaZDC);
            }
            qxZDCA = qxZDCA - ampl * x[iChA];
            qyZDCA = qyZDCA + ampl * y[iChA];
            sumA = sumA + ampl;
            histos.fill(HIST("ZDCAmp"), chanelid + 0.5, vz, ampl);
          }
        } else {
          if (zncEnergy[iChA - 4] <= 0.0) {
            triggerevent = false;
            spcalibrationtable(triggerevent, currentRunNumber, centrality, vx, vy, vz, znaEnergycommon, zncEnergycommon, znaEnergy[0], znaEnergy[1], znaEnergy[2], znaEnergy[3], zncEnergy[0], zncEnergy[1], zncEnergy[2], zncEnergy[3], qxZDCA, qxZDCC, qyZDCA, qyZDCC, psiZDCC, psiZDCA);
            return;
          } else {
            double ampl = gainequal * zncEnergy[iChA - 4];
            zncEnergycommonsum += ampl;
            if (followpub) {
              ampl = TMath::Power(ampl, alphaZDC);
            }
            qxZDCC = qxZDCC + ampl * x[iChA - 4];
            qyZDCC = qyZDCC + ampl * y[iChA - 4];
            sumC = sumC + ampl;
            histos.fill(HIST("ZDCAmp"), chanelid + 0.5, vz, ampl);
          }
        }
      }

      auto cZNC = 1.0;
      auto cZNA = 1.0;

      if (sumA > 0) {
        float nSpecnA = znaEnergycommonsum / beamEne;
        if (usecfactor)
          cZNA = 1.89358 - 0.71262 / (nSpecnA + 0.71789);
        else
          cZNA = 1.0;
        qxZDCA = cZNA * (qxZDCA / sumA);
        qyZDCA = cZNA * (qyZDCA / sumA);
      }
      if (sumC > 0) {
        float nSpecnC = zncEnergycommonsum / beamEne;
        if (usecfactor)
          cZNC = 1.89358 - 0.71262 / (nSpecnC + 0.71789);
        else
          cZNC = 1.0;
        qxZDCC = cZNC * (qxZDCC / sumC);
        qyZDCC = cZNC * (qyZDCC / sumC);
      }

      if (sumA <= 1e-4 || sumC <= 1e-4) {
        qxZDCA = 0.0;
        qxZDCC = 0.0;
        qyZDCA = 0.0;
        qyZDCC = 0.0;
        triggerevent = false;
        spcalibrationtable(triggerevent, currentRunNumber, centrality, vx, vy, vz, znaEnergycommon, zncEnergycommon, znaEnergy[0], znaEnergy[1], znaEnergy[2], znaEnergy[3], zncEnergy[0], zncEnergy[1], zncEnergy[2], zncEnergy[3], qxZDCA, qxZDCC, qyZDCA, qyZDCC, psiZDCC, psiZDCA);
        return;
      }

      histos.fill(HIST("hEvtSelInfo"), 8.5);
      histos.fill(HIST("hCentrality"), centrality);
      histos.fill(HIST("Vz"), vz);

      histos.fill(HIST("AvgVxy"), 0.5, vx);
      histos.fill(HIST("AvgVxy"), 1.5, vy);

      if (useCallibvertex && (currentRunNumber != lastRunNumber)) {
        gainprofilevxy = ccdb->getForTimeStamp<TProfile>(ConfGainPathvxy.value, bc.timestamp());
      }

      if (useCallibvertex) {
        vx = vx - gainprofilevxy->GetBinContent(1);
        vy = vy - gainprofilevxy->GetBinContent(2);
      }

      bool res = false;
      bool resfine = false;
      int check = 1;

      if (useoldrecentering) {
        if (coarse1) {
          if (useRecentereSp && (currentRunNumber != lastRunNumber)) {
            hrecentereSpA[0] = ccdb->getForTimeStamp<THnF>(ConfRecentereSp.value, bc.timestamp());
          }
          res = Correctcoarse(hrecentereSpA[0], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC);
        }

        if (fine1) {

          if (useRecenterefineSp && (currentRunNumber != lastRunNumber)) {
            hrecenterecentSpA[0] = ccdb->getForTimeStamp<TH2F>(ConfRecenterecentSp.value, bc.timestamp());
            hrecenterevxSpA[0] = ccdb->getForTimeStamp<TH2F>(ConfRecenterevxSp.value, bc.timestamp());
            hrecenterevySpA[0] = ccdb->getForTimeStamp<TH2F>(ConfRecenterevySp.value, bc.timestamp());
            hrecenterevzSpA[0] = ccdb->getForTimeStamp<TH2F>(ConfRecenterevzSp.value, bc.timestamp());
          }
          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<TH2F>(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<THnF>(ConfRecentereSp2.value, bc.timestamp());
          }
          res = Correctcoarse(hrecentereSpA[1], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC);
        }

        if (fine2) {
          if (useRecenterefineSp && (currentRunNumber != lastRunNumber)) {
            hrecenterecentSpA[1] = ccdb->getForTimeStamp<TH2F>(ConfRecenterecentSp2.value, bc.timestamp());
            hrecenterevxSpA[1] = ccdb->getForTimeStamp<TH2F>(ConfRecenterevxSp2.value, bc.timestamp());
            hrecenterevySpA[1] = ccdb->getForTimeStamp<TH2F>(ConfRecenterevySp2.value, bc.timestamp());
            hrecenterevzSpA[1] = ccdb->getForTimeStamp<TH2F>(ConfRecenterevzSp2.value, bc.timestamp());
          }
          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<TH2F>(confRecentereTimeSp2.value, bc.timestamp());
        }
        if (useTimeRecentering) {
          restime = Correcttime(hrecentereTimeSp2, timeMin, qxZDCA, qyZDCA, qxZDCC, qyZDCC);
        }

        if (coarse3) {
          if (useRecentereSp && (currentRunNumber != lastRunNumber)) {
            hrecentereSpA[2] = ccdb->getForTimeStamp<THnF>(ConfRecentereSp3.value, bc.timestamp());
          }
          res = Correctcoarse(hrecentereSpA[2], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC);
        }

        if (fine3) {
          if (useRecenterefineSp && (currentRunNumber != lastRunNumber)) {
            hrecenterecentSpA[2] = ccdb->getForTimeStamp<TH2F>(ConfRecenterecentSp3.value, bc.timestamp());
            hrecenterevxSpA[2] = ccdb->getForTimeStamp<TH2F>(ConfRecenterevxSp3.value, bc.timestamp());
            hrecenterevySpA[2] = ccdb->getForTimeStamp<TH2F>(ConfRecenterevySp3.value, bc.timestamp());
            hrecenterevzSpA[2] = ccdb->getForTimeStamp<TH2F>(ConfRecenterevzSp3.value, bc.timestamp());
          }
          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<TH2F>(confRecentereTimeSp3.value, bc.timestamp());
        }
        if (useTimeRecentering) {
          restime = Correcttime(hrecentereTimeSp3, timeMin, qxZDCA, qyZDCA, qxZDCC, qyZDCC);
        }

        if (coarse4) {
          if (useRecentereSp && (currentRunNumber != lastRunNumber)) {
            hrecentereSpA[3] = ccdb->getForTimeStamp<THnF>(ConfRecentereSp4.value, bc.timestamp());
          }
          res = Correctcoarse(hrecentereSpA[3], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC);
        }

        if (fine4) {
          if (useRecenterefineSp && (currentRunNumber != lastRunNumber)) {
            hrecenterecentSpA[3] = ccdb->getForTimeStamp<TH2F>(ConfRecenterecentSp4.value, bc.timestamp());
            hrecenterevxSpA[3] = ccdb->getForTimeStamp<TH2F>(ConfRecenterevxSp4.value, bc.timestamp());
            hrecenterevySpA[3] = ccdb->getForTimeStamp<TH2F>(ConfRecenterevySp4.value, bc.timestamp());
            hrecenterevzSpA[3] = ccdb->getForTimeStamp<TH2F>(ConfRecenterevzSp4.value, bc.timestamp());
          }
          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<THnF>(ConfRecentereSp5.value, bc.timestamp());
          }
          res = Correctcoarse(hrecentereSpA[4], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC);
        }

        if (fine5) {
          if (useRecenterefineSp && (currentRunNumber != lastRunNumber)) {
            hrecenterecentSpA[4] = ccdb->getForTimeStamp<TH2F>(ConfRecenterecentSp5.value, bc.timestamp());
            hrecenterevxSpA[4] = ccdb->getForTimeStamp<TH2F>(ConfRecenterevxSp5.value, bc.timestamp());
            hrecenterevySpA[4] = ccdb->getForTimeStamp<TH2F>(ConfRecenterevySp5.value, bc.timestamp());
            hrecenterevzSpA[4] = ccdb->getForTimeStamp<TH2F>(ConfRecenterevzSp5.value, bc.timestamp());
          }
          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<THnF>(ConfRecentereSp6.value, bc.timestamp());
          }
          res = Correctcoarse(hrecentereSpA[5], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC);
        }

        if (fine6) {
          if (useRecenterefineSp && (currentRunNumber != lastRunNumber)) {
            hrecenterecentSpA[5] = ccdb->getForTimeStamp<TH2F>(ConfRecenterecentSp6.value, bc.timestamp());
            hrecenterevxSpA[5] = ccdb->getForTimeStamp<TH2F>(ConfRecenterevxSp6.value, bc.timestamp());
            hrecenterevySpA[5] = ccdb->getForTimeStamp<TH2F>(ConfRecenterevySp6.value, bc.timestamp());
            hrecenterevzSpA[5] = ccdb->getForTimeStamp<TH2F>(ConfRecenterevzSp6.value, bc.timestamp());
          }
          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 (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<TH2F>(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<TH3F>(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 (confignewpro.finecentvy1) {
          if (confignewpro.useRecenterefinecentvxvyvzSp &&
              (currentRunNumber != lastRunNumber || !hrecenterecentvySpA[0])) {
            hrecenterecentvySpA[0] = ccdb->getForTimeStamp<TH3F>(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<TH3F>(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");
          }
        }

        if (confignewpro.finevztime1) {
          if (confignewpro.useRecenterefinevztimeSp &&
              (currentRunNumber != lastRunNumber || !hrecenterevztimeSpA[0])) {
            hrecenterevztimeSpA[0] = ccdb->getForTimeStamp<TH3F>(confignewpro.confRecentereVzTimeSp.value, bc.timestamp());
          }
          if (!CorrectfineVzTime(hrecenterevztimeSpA[0], vz, timeMin, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) {
            LOGF(fatal, "Cannot apply fine (Vz, time) recentering, stage 1");
          }
        }

        // -------------------- Stage 2 --------------------
        if (confignewpro.finecent2) {
          if (confignewpro.useRecenterefinecentSp &&
              (currentRunNumber != lastRunNumber || !hrecenterecentSpA[1])) {
            hrecenterecentSpA[1] = ccdb->getForTimeStamp<TH2F>(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<TH3F>(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<TH3F>(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<TH3F>(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");
          }
        }

        if (confignewpro.finevztime2) {
          if (confignewpro.useRecenterefinevztimeSp &&
              (currentRunNumber != lastRunNumber || !hrecenterevztimeSpA[1])) {
            hrecenterevztimeSpA[1] = ccdb->getForTimeStamp<TH3F>(confignewpro.confRecentereVzTimeSp2.value, bc.timestamp());
          }
          if (!CorrectfineVzTime(hrecenterevztimeSpA[1], vz, timeMin, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) {
            LOGF(fatal, "Cannot apply fine (Vz, time) recentering, stage 2");
          }
        }

        // -------------------- Stage 3 --------------------
        if (confignewpro.finecent3) {
          if (confignewpro.useRecenterefinecentSp &&
              (currentRunNumber != lastRunNumber || !hrecenterecentSpA[2])) {
            hrecenterecentSpA[2] = ccdb->getForTimeStamp<TH2F>(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<TH3F>(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<TH3F>(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<TH3F>(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");
          }
        }

        if (confignewpro.finevztime3) {
          if (confignewpro.useRecenterefinevztimeSp &&
              (currentRunNumber != lastRunNumber || !hrecenterevztimeSpA[2])) {
            hrecenterevztimeSpA[2] = ccdb->getForTimeStamp<TH3F>(confignewpro.confRecentereVzTimeSp3.value, bc.timestamp());
          }
          if (!CorrectfineVzTime(hrecenterevztimeSpA[2], vz, timeMin, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) {
            LOGF(fatal, "Cannot apply fine (Vz, time) recentering, stage 3");
          }
        }

        // -------------------- Stage 4 --------------------
        if (confignewpro.finecent4) {
          if (confignewpro.useRecenterefinecentSp &&
              (currentRunNumber != lastRunNumber || !hrecenterecentSpA[3])) {
            hrecenterecentSpA[3] = ccdb->getForTimeStamp<TH2F>(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<TH3F>(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<TH3F>(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<TH3F>(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");
          }
        }

        if (confignewpro.finevztime4) {
          if (confignewpro.useRecenterefinevztimeSp &&
              (currentRunNumber != lastRunNumber || !hrecenterevztimeSpA[3])) {
            hrecenterevztimeSpA[3] = ccdb->getForTimeStamp<TH3F>(confignewpro.confRecentereVzTimeSp4.value, bc.timestamp());
          }
          if (!CorrectfineVzTime(hrecenterevztimeSpA[3], vz, timeMin, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) {
            LOGF(fatal, "Cannot apply fine (Vz, time) recentering, stage 4");
          }
        }

        // -------------------- Stage 5 --------------------
        if (confignewpro.finecent5) {
          if (confignewpro.useRecenterefinecentSp &&
              (currentRunNumber != lastRunNumber || !hrecenterecentSpA[4])) {
            hrecenterecentSpA[4] = ccdb->getForTimeStamp<TH2F>(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<TH3F>(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<TH3F>(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<TH3F>(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");
          }
        }

        if (confignewpro.finevztime5) {
          if (confignewpro.useRecenterefinevztimeSp &&
              (currentRunNumber != lastRunNumber || !hrecenterevztimeSpA[4])) {
            hrecenterevztimeSpA[4] = ccdb->getForTimeStamp<TH3F>(confignewpro.confRecentereVzTimeSp5.value, bc.timestamp());
          }
          if (!CorrectfineVzTime(hrecenterevztimeSpA[4], vz, timeMin, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) {
            LOGF(fatal, "Cannot apply fine (Vz, time) recentering, stage 5");
          }
        }

        // -------------------- Stage 6 --------------------
        if (confignewpro.finecent6) {
          if (confignewpro.useRecenterefinecentSp &&
              (currentRunNumber != lastRunNumber || !hrecenterecentSpA[5])) {
            hrecenterecentSpA[5] = ccdb->getForTimeStamp<TH2F>(confignewpro.confRecentereCentSp6.value, bc.timestamp());
          }
          if (!CorrectfineCent(hrecenterecentSpA[5], centrality, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) {
            LOGF(fatal, "Cannot apply fine centrality recentering, stage 6");
          }
        }

        if (confignewpro.finecentvx6) {
          if (confignewpro.useRecenterefinecentvxvyvzSp &&
              (currentRunNumber != lastRunNumber || !hrecenterecentvxSpA[5])) {
            hrecenterecentvxSpA[5] = ccdb->getForTimeStamp<TH3F>(confignewpro.confRecentereCentVxSp6.value, bc.timestamp());
          }
          if (!CorrectfineCentVx(hrecenterecentvxSpA[5], centrality, vx, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) {
            LOGF(fatal, "Cannot apply fine (cent,Vx) recentering, stage 6");
          }
        }

        if (confignewpro.finecentvy6) {
          if (confignewpro.useRecenterefinecentvxvyvzSp &&
              (currentRunNumber != lastRunNumber || !hrecenterecentvySpA[5])) {
            hrecenterecentvySpA[5] = ccdb->getForTimeStamp<TH3F>(confignewpro.confRecentereCentVySp6.value, bc.timestamp());
          }
          if (!CorrectfineCentVy(hrecenterecentvySpA[5], centrality, vy, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) {
            LOGF(fatal, "Cannot apply fine (cent,Vy) recentering, stage 6");
          }
        }

        if (confignewpro.finecentvz6) {
          if (confignewpro.useRecenterefinecentvxvyvzSp &&
              (currentRunNumber != lastRunNumber || !hrecenterecentvzSpA[5])) {
            hrecenterecentvzSpA[5] = ccdb->getForTimeStamp<TH3F>(confignewpro.confRecentereCentVzSp6.value, bc.timestamp());
          }
          if (!CorrectfineCentVz(hrecenterecentvzSpA[5], centrality, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC)) {
            LOGF(fatal, "Cannot apply fine (cent,Vz) recentering, stage 6");
          }
        }
      }

      histos.fill(HIST("hpQxZDCAvstime"), timeMin, qxZDCA);
      histos.fill(HIST("hpQxZDCCvstime"), timeMin, qxZDCC);
      histos.fill(HIST("hpQyZDCAvstime"), timeMin, qyZDCA);
      histos.fill(HIST("hpQyZDCCvstime"), timeMin, qyZDCC);

      psiZDCC = 1.0 * TMath::ATan2(qyZDCC, qxZDCC);
      psiZDCA = 1.0 * TMath::ATan2(qyZDCA, qxZDCA);

      int nshift = 10; // no. of iterations

      if (useShift && (currentRunNumber != lastRunNumber)) {
        shiftprofileC = ccdb->getForTimeStamp<TProfile3D>(ConfShiftC.value, bc.timestamp());
        shiftprofileA = ccdb->getForTimeStamp<TProfile3D>(ConfShiftA.value, bc.timestamp());
      }

      if (useShift) {
        auto deltapsiZDCC = 0.0;
        auto deltapsiZDCA = 0.0;
        for (int ishift = 1; ishift <= nshift; ishift++) {
          auto coeffshiftxZDCC = shiftprofileC->GetBinContent(shiftprofileC->FindBin(centrality, 0.5, ishift - 0.5));
          auto coeffshiftyZDCC = shiftprofileC->GetBinContent(shiftprofileC->FindBin(centrality, 1.5, ishift - 0.5));
          auto coeffshiftxZDCA = shiftprofileA->GetBinContent(shiftprofileA->FindBin(centrality, 0.5, ishift - 0.5));
          auto coeffshiftyZDCA = shiftprofileA->GetBinContent(shiftprofileA->FindBin(centrality, 1.5, ishift - 0.5));
          deltapsiZDCC = deltapsiZDCC + ((2 / (1.0 * ishift)) * (-coeffshiftxZDCC * TMath::Cos(ishift * 1.0 * psiZDCC) + coeffshiftyZDCC * TMath::Sin(ishift * 1.0 * psiZDCC)));
          deltapsiZDCA = deltapsiZDCA + ((2 / (1.0 * ishift)) * (-coeffshiftxZDCA * TMath::Cos(ishift * 1.0 * psiZDCA) + coeffshiftyZDCA * TMath::Sin(ishift * 1.0 * psiZDCA)));
        }
        psiZDCC = psiZDCC + deltapsiZDCC;
        psiZDCA = psiZDCA + deltapsiZDCA;
      }

      for (int ishift = 1; ishift <= nshift; ishift++) {
        histos.fill(HIST("ShiftZDCC"), centrality, 0.5, ishift - 0.5, TMath::Sin(ishift * 1.0 * psiZDCC));
        histos.fill(HIST("ShiftZDCC"), centrality, 1.5, ishift - 0.5, TMath::Cos(ishift * 1.0 * psiZDCC));
        histos.fill(HIST("ShiftZDCA"), centrality, 0.5, ishift - 0.5, TMath::Sin(ishift * 1.0 * psiZDCA));
        histos.fill(HIST("ShiftZDCA"), centrality, 1.5, ishift - 0.5, TMath::Cos(ishift * 1.0 * psiZDCA));
      }

      histos.fill(HIST("hpQxZDCAC"), centrality, (qxZDCA * qxZDCC));
      histos.fill(HIST("hpQyZDCAC"), centrality, (qyZDCA * qyZDCC));
      histos.fill(HIST("hpQxZDCAQyZDCC"), centrality, (qxZDCA * qyZDCC));
      histos.fill(HIST("hpQxZDCCQyZDCA"), centrality, (qxZDCC * qyZDCA));

      if (!ispolarization) {
        histos.fill(HIST("hnQxZDCA"), centrality, vx, vy, vz, qxZDCA);
        histos.fill(HIST("hnQyZDCA"), centrality, vx, vy, vz, qyZDCA);
        histos.fill(HIST("hnQxZDCC"), centrality, vx, vy, vz, qxZDCC);
        histos.fill(HIST("hnQyZDCC"), centrality, vx, vy, vz, qyZDCC);

        histos.fill(HIST("hcentQxZDCA"), centrality, qxZDCA);
        histos.fill(HIST("hcentQyZDCA"), centrality, qyZDCA);
        histos.fill(HIST("hcentQxZDCC"), centrality, qxZDCC);
        histos.fill(HIST("hcentQyZDCC"), centrality, qyZDCC);

        histos.fill(HIST("hvxQxZDCA"), vx, qxZDCA);
        histos.fill(HIST("hvxQyZDCA"), vx, qyZDCA);
        histos.fill(HIST("hvxQxZDCC"), vx, qxZDCC);
        histos.fill(HIST("hvxQyZDCC"), vx, qyZDCC);

        histos.fill(HIST("hvyQxZDCA"), vy, qxZDCA);
        histos.fill(HIST("hvyQyZDCA"), vy, qyZDCA);
        histos.fill(HIST("hvyQxZDCC"), vy, qxZDCC);
        histos.fill(HIST("hvyQyZDCC"), vy, qyZDCC);

        histos.fill(HIST("hvzQxZDCA"), vz, qxZDCA);
        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)));
      histos.fill(HIST("hpSinPsiAPsiC"), centrality, (TMath::Sin(psiZDCA - psiZDCC)));
      histos.fill(HIST("PsiZDCA"), centrality, psiZDCA);
      histos.fill(HIST("PsiZDCC"), centrality, psiZDCC);

      lastRunNumber = currentRunNumber;
    }
    spcalibrationtable(triggerevent, currentRunNumber, centrality, vx, vy, vz, znaEnergycommon, zncEnergycommon, znaEnergy[0], znaEnergy[1], znaEnergy[2], znaEnergy[3], zncEnergy[0], zncEnergy[1], zncEnergy[2], zncEnergy[3], qxZDCA, qxZDCC, qyZDCA, qyZDCC, psiZDCC, psiZDCA);
  }
};

WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
{
  return WorkflowSpec{
    adaptAnalysisTask<spvector>(cfgc)};
}