diff --git a/CalibPPS/ESProducers/plugins/PPSAlignmentConfigurationESSource.cc b/CalibPPS/ESProducers/plugins/PPSAlignmentConfigurationESSource.cc
new file mode 100644
index 0000000000000..19c5157ad80e3
--- /dev/null
+++ b/CalibPPS/ESProducers/plugins/PPSAlignmentConfigurationESSource.cc
@@ -0,0 +1,702 @@
+/****************************************************************************
+* Authors: 
+*  Jan Kašpar (jan.kaspar@gmail.com) 
+*  Mateusz Kocot (mateuszkocot99@gmail.com)
+****************************************************************************/
+
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "FWCore/Framework/interface/SourceFactory.h"
+#include "FWCore/Framework/interface/ModuleFactory.h"
+
+#include "FWCore/Framework/interface/ESProducer.h"
+#include "FWCore/Framework/interface/ESProducts.h"
+#include "FWCore/Framework/interface/EventSetupRecordIntervalFinder.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+#include "FWCore/Utilities/interface/ESInputTag.h"
+
+#include "CondFormats/PPSObjects/interface/PPSAlignmentConfiguration.h"
+#include "CondFormats/DataRecord/interface/PPSAlignmentConfigurationRcd.h"
+
+#include <string>
+#include <vector>
+#include <map>
+#include <memory>
+#include <queue>
+
+#include "TF1.h"
+#include "TProfile.h"
+#include "TFile.h"
+#include "TKey.h"
+#include "TSystemFile.h"
+
+//---------------------------------------------------------------------------------------------
+
+class PPSAlignmentConfigurationESSource : public edm::ESProducer, public edm::EventSetupRecordIntervalFinder {
+public:
+  PPSAlignmentConfigurationESSource(const edm::ParameterSet& iConfig);
+
+  std::unique_ptr<PPSAlignmentConfiguration> produce(const PPSAlignmentConfigurationRcd&);
+  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
+
+private:
+  int fitProfile(TProfile* p, double x_mean, double x_rms, double& sl, double& sl_unc);
+  TDirectory* findDirectoryWithName(TDirectory* dir, std::string searchName);
+  std::vector<PPSAlignmentConfiguration::PointErrors> buildVectorFromDirectory(
+      TDirectory* dir, const PPSAlignmentConfiguration::RPConfig& rpd);
+
+  void setIntervalFor(const edm::eventsetup::EventSetupRecordKey& key,
+                      const edm::IOVSyncValue& iosv,
+                      edm::ValidityInterval& oValidity) override;
+
+  bool debug;
+
+  PPSAlignmentConfiguration::SectorConfig sectorConfig45, sectorConfig56;
+
+  double x_ali_sh_step;
+
+  double y_mode_sys_unc;
+  double chiSqThreshold;
+  double y_mode_unc_max_valid;
+  double y_mode_max_valid;
+
+  unsigned int minRPTracksSize;
+  unsigned int maxRPTracksSize;
+  double n_si;
+
+  std::map<unsigned int, std::vector<PPSAlignmentConfiguration::PointErrors>> matchingReferencePoints;
+  std::map<unsigned int, PPSAlignmentConfiguration::SelectionRange> matchingShiftRanges;
+
+  std::map<unsigned int, PPSAlignmentConfiguration::SelectionRange> alignment_x_meth_o_ranges;
+  unsigned int fitProfileMinBinEntries;
+  unsigned int fitProfileMinNReasonable;
+  unsigned int methOGraphMinN;
+  double methOUncFitRange;
+
+  std::map<unsigned int, PPSAlignmentConfiguration::SelectionRange> alignment_x_relative_ranges;
+  unsigned int nearFarMinEntries;
+
+  std::map<unsigned int, PPSAlignmentConfiguration::SelectionRange> alignment_y_ranges;
+  unsigned int modeGraphMinN;
+  unsigned int multSelProjYMinEntries;
+
+  PPSAlignmentConfiguration::Binning binning;
+
+  std::vector<double> extraParams;
+
+  std::string label;
+};
+
+//---------------------------------------------------------------------------------------------
+
+PPSAlignmentConfigurationESSource::PPSAlignmentConfigurationESSource(const edm::ParameterSet& iConfig) {
+  label = iConfig.getParameter<std::string>("label");
+
+  debug = iConfig.getParameter<bool>("debug");
+  TFile* debugFile = nullptr;
+  if (debug) {
+    debugFile = new TFile(("debug_producer_" + (label.empty() ? "test" : label) + ".root").c_str(), "recreate");
+  }
+
+  sectorConfig45.name_ = "sector 45";
+
+  sectorConfig45.rp_N_.position_ = "N";
+  sectorConfig45.rp_F_.position_ = "F";
+
+  sectorConfig56.name_ = "sector 56";
+
+  sectorConfig56.rp_N_.position_ = "N";
+  sectorConfig56.rp_F_.position_ = "F";
+
+  for (std::string sectorName : {"sector_45", "sector_56"}) {
+    const auto& sps = iConfig.getParameter<edm::ParameterSet>(sectorName);
+    PPSAlignmentConfiguration::SectorConfig* sc;
+    if (sectorName == "sector_45")
+      sc = &sectorConfig45;
+    else
+      sc = &sectorConfig56;
+
+    for (std::string rpName : {"rp_N", "rp_F"}) {
+      const auto& rpps = sps.getParameter<edm::ParameterSet>(rpName);
+      PPSAlignmentConfiguration::RPConfig* rc;
+      if (rpName == "rp_N")
+        rc = &sc->rp_N_;
+      else
+        rc = &sc->rp_F_;
+
+      rc->name_ = rpps.getParameter<std::string>("name");
+      rc->id_ = rpps.getParameter<int>("id");
+
+      rc->slope_ = rpps.getParameter<double>("slope");
+      rc->sh_x_ = rpps.getParameter<double>("sh_x");
+
+      rc->x_min_fit_mode_ = rpps.getParameter<double>("x_min_fit_mode");
+      rc->x_max_fit_mode_ = rpps.getParameter<double>("x_max_fit_mode");
+      rc->y_max_fit_mode_ = rpps.getParameter<double>("y_max_fit_mode");
+      rc->y_cen_add_ = rpps.getParameter<double>("y_cen_add");
+      rc->y_width_mult_ = rpps.getParameter<double>("y_width_mult");
+
+      rc->x_slice_min_ = rpps.getParameter<double>("x_slice_min");
+      rc->x_slice_w_ = rpps.getParameter<double>("x_slice_w");
+      rc->x_slice_n_ = std::ceil((rpps.getParameter<double>("x_slice_max") - rc->x_slice_min_) / rc->x_slice_w_);
+    }
+
+    sc->slope_ = sps.getParameter<double>("slope");
+
+    sc->cut_h_apply_ = sps.getParameter<bool>("cut_h_apply");
+    sc->cut_h_a_ = sps.getParameter<double>("cut_h_a");
+    sc->cut_h_c_ = sps.getParameter<double>("cut_h_c");
+    sc->cut_h_si_ = sps.getParameter<double>("cut_h_si");
+
+    sc->cut_v_apply_ = sps.getParameter<bool>("cut_v_apply");
+    sc->cut_v_a_ = sps.getParameter<double>("cut_v_a");
+    sc->cut_v_c_ = sps.getParameter<double>("cut_v_c");
+    sc->cut_v_si_ = sps.getParameter<double>("cut_v_si");
+  }
+
+  std::map<unsigned int, std::string> rpTags = {{sectorConfig45.rp_F_.id_, "rp_L_F"},
+                                                {sectorConfig45.rp_N_.id_, "rp_L_N"},
+                                                {sectorConfig56.rp_N_.id_, "rp_R_N"},
+                                                {sectorConfig56.rp_F_.id_, "rp_R_F"}};
+
+  std::map<unsigned int, std::string> sectorNames = {{sectorConfig45.rp_F_.id_, sectorConfig45.name_},
+                                                     {sectorConfig45.rp_N_.id_, sectorConfig45.name_},
+                                                     {sectorConfig56.rp_N_.id_, sectorConfig56.name_},
+                                                     {sectorConfig56.rp_F_.id_, sectorConfig56.name_}};
+
+  std::map<unsigned int, const PPSAlignmentConfiguration::RPConfig*> rpConfigs = {
+      {sectorConfig45.rp_F_.id_, &sectorConfig45.rp_F_},
+      {sectorConfig45.rp_N_.id_, &sectorConfig45.rp_N_},
+      {sectorConfig56.rp_N_.id_, &sectorConfig56.rp_N_},
+      {sectorConfig56.rp_F_.id_, &sectorConfig56.rp_F_}};
+
+  x_ali_sh_step = iConfig.getParameter<double>("x_ali_sh_step");
+
+  y_mode_sys_unc = iConfig.getParameter<double>("y_mode_sys_unc");
+  chiSqThreshold = iConfig.getParameter<double>("chiSqThreshold");
+  y_mode_unc_max_valid = iConfig.getParameter<double>("y_mode_unc_max_valid");
+  y_mode_max_valid = iConfig.getParameter<double>("y_mode_max_valid");
+
+  minRPTracksSize = iConfig.getParameter<unsigned int>("min_RP_tracks_size");
+  maxRPTracksSize = iConfig.getParameter<unsigned int>("max_RP_tracks_size");
+  n_si = iConfig.getParameter<double>("n_si");
+
+  const auto& c_axo = iConfig.getParameter<edm::ParameterSet>("x_alignment_meth_o");
+  for (const auto& p : rpTags) {
+    const auto& ps = c_axo.getParameter<edm::ParameterSet>(p.second);
+    alignment_x_meth_o_ranges[p.first] = {ps.getParameter<double>("x_min"), ps.getParameter<double>("x_max")};
+  }
+  fitProfileMinBinEntries = c_axo.getParameter<unsigned int>("fit_profile_min_bin_entries");
+  fitProfileMinNReasonable = c_axo.getParameter<unsigned int>("fit_profile_min_N_reasonable");
+  methOGraphMinN = c_axo.getParameter<unsigned int>("meth_o_graph_min_N");
+  methOUncFitRange = c_axo.getParameter<double>("meth_o_unc_fit_range");
+
+  const auto& c_m = iConfig.getParameter<edm::ParameterSet>("matching");
+  const auto& referenceDataset = c_m.getParameter<std::string>("reference_dataset");
+
+  // constructing vectors with reference data
+  if (!referenceDataset.empty()) {
+    TFile* f_ref = TFile::Open(referenceDataset.c_str());
+    if (!f_ref->IsOpen()) {
+      edm::LogWarning("PPS") << "[ESSource] could not find reference dataset file: " << referenceDataset;
+    } else {
+      TDirectory* ad_ref = findDirectoryWithName((TDirectory*)f_ref, sectorConfig45.name_);
+      if (ad_ref == nullptr) {
+        edm::LogWarning("PPS") << "[ESSource] could not find reference dataset in " << referenceDataset;
+      } else {
+        edm::LogInfo("PPS") << "[ESSource] loading reference dataset from " << ad_ref->GetPath();
+
+        for (const auto& p : rpTags) {
+          if (debug)
+            gDirectory = debugFile->mkdir(rpConfigs[p.first]->name_.c_str())->mkdir("fits_ref");
+
+          auto* d_ref = (TDirectory*)ad_ref->Get(
+              (sectorNames[p.first] + "/near_far/x slices, " + rpConfigs[p.first]->position_).c_str());
+          if (d_ref == nullptr) {
+            edm::LogWarning("PPS") << "[ESSource] could not load d_ref";
+          } else {
+            matchingReferencePoints[p.first] = buildVectorFromDirectory(d_ref, *rpConfigs[p.first]);
+          }
+        }
+      }
+    }
+    delete f_ref;
+  }
+
+  for (const auto& p : rpTags) {
+    const auto& ps = c_m.getParameter<edm::ParameterSet>(p.second);
+    matchingShiftRanges[p.first] = {ps.getParameter<double>("sh_min"), ps.getParameter<double>("sh_max")};
+  }
+
+  const auto& c_axr = iConfig.getParameter<edm::ParameterSet>("x_alignment_relative");
+  for (const auto& p : rpTags) {
+    if (p.second.back() == 'N') {  // only near RPs
+      const auto& ps = c_axr.getParameter<edm::ParameterSet>(p.second);
+      alignment_x_relative_ranges[p.first] = {ps.getParameter<double>("x_min"), ps.getParameter<double>("x_max")};
+    }
+  }
+  nearFarMinEntries = c_axr.getParameter<unsigned int>("near_far_min_entries");
+
+  const auto& c_ay = iConfig.getParameter<edm::ParameterSet>("y_alignment");
+  for (const auto& p : rpTags) {
+    const auto& ps = c_ay.getParameter<edm::ParameterSet>(p.second);
+    alignment_y_ranges[p.first] = {ps.getParameter<double>("x_min"), ps.getParameter<double>("x_max")};
+  }
+  modeGraphMinN = c_ay.getParameter<unsigned int>("mode_graph_min_N");
+  multSelProjYMinEntries = c_ay.getParameter<unsigned int>("mult_sel_proj_y_min_entries");
+
+  const auto& bps = iConfig.getParameter<edm::ParameterSet>("binning");
+  binning.bin_size_x_ = bps.getParameter<double>("bin_size_x");
+  binning.n_bins_x_ = bps.getParameter<unsigned int>("n_bins_x");
+  binning.pixel_x_offset_ = bps.getParameter<double>("pixel_x_offset");
+  binning.n_bins_y_ = bps.getParameter<unsigned int>("n_bins_y");
+  binning.y_min_ = bps.getParameter<double>("y_min");
+  binning.y_max_ = bps.getParameter<double>("y_max");
+
+  binning.diffFN_n_bins_x_ = bps.getParameter<unsigned int>("diffFN_n_bins_x");
+  binning.diffFN_x_min_ = bps.getParameter<double>("diffFN_x_min");
+  binning.diffFN_x_max_ = bps.getParameter<double>("diffFN_x_max");
+
+  binning.slice_n_bins_x_ = bps.getParameter<unsigned int>("slice_n_bins_x");
+  binning.slice_x_min_ = bps.getParameter<double>("slice_x_min");
+  binning.slice_x_max_ = bps.getParameter<double>("slice_x_max");
+  binning.slice_n_bins_y_ = bps.getParameter<unsigned int>("slice_n_bins_y");
+  binning.slice_y_min_ = bps.getParameter<double>("slice_y_min");
+  binning.slice_y_max_ = bps.getParameter<double>("slice_y_max");
+
+  extraParams = iConfig.getParameter<std::vector<double>>("extra_params");
+
+  setWhatProduced(this, label);
+  findingRecord<PPSAlignmentConfigurationRcd>();
+
+  if (debug)
+    delete debugFile;
+}
+
+//---------------------------------------------------------------------------------------------
+
+std::unique_ptr<PPSAlignmentConfiguration> PPSAlignmentConfigurationESSource::produce(
+    const PPSAlignmentConfigurationRcd&) {
+  auto p = std::make_unique<PPSAlignmentConfiguration>();
+
+  p->setSectorConfig45(sectorConfig45);
+  p->setSectorConfig56(sectorConfig56);
+
+  p->setX_ali_sh_step(x_ali_sh_step);
+
+  p->setY_mode_sys_unc(y_mode_sys_unc);
+  p->setChiSqThreshold(chiSqThreshold);
+  p->setY_mode_unc_max_valid(y_mode_unc_max_valid);
+  p->setY_mode_max_valid(y_mode_max_valid);
+
+  p->setMinRPTracksSize(minRPTracksSize);
+  p->setMaxRPTracksSize(maxRPTracksSize);
+  p->setN_si(n_si);
+
+  p->setMatchingReferencePoints(matchingReferencePoints);
+  p->setMatchingShiftRanges(matchingShiftRanges);
+
+  p->setAlignment_x_meth_o_ranges(alignment_x_meth_o_ranges);
+  p->setFitProfileMinBinEntries(fitProfileMinBinEntries);
+  p->setFitProfileMinNReasonable(fitProfileMinNReasonable);
+  p->setMethOGraphMinN(methOGraphMinN);
+  p->setMethOUncFitRange(methOUncFitRange);
+
+  p->setAlignment_x_relative_ranges(alignment_x_relative_ranges);
+  p->setNearFarMinEntries(nearFarMinEntries);
+
+  p->setAlignment_y_ranges(alignment_y_ranges);
+  p->setModeGraphMinN(modeGraphMinN);
+  p->setMultSelProjYMinEntries(multSelProjYMinEntries);
+
+  p->setBinning(binning);
+
+  p->setExtraParams(extraParams);
+
+  edm::LogInfo("PPS") << "\n"
+                      << "[ESSource] " << (label.empty() ? "empty label" : "label = " + label) << ":\n\n"
+                      << (*p);
+
+  return p;
+}
+
+//---------------------------------------------------------------------------------------------
+
+// most default values come from 2018 period
+void PPSAlignmentConfigurationESSource::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
+  edm::ParameterSetDescription desc;
+
+  desc.add<bool>("debug", false);
+
+  desc.add<std::string>("label", "");
+
+  // sector_45
+  {
+    edm::ParameterSetDescription sector45;
+
+    edm::ParameterSetDescription rp_N;
+    rp_N.add<std::string>("name", "L_1_F");
+    rp_N.add<int>("id", 3);
+
+    rp_N.add<double>("slope", 0.19);
+    rp_N.add<double>("sh_x", -3.6);
+
+    rp_N.add<double>("x_min_fit_mode", 2.);
+    rp_N.add<double>("x_max_fit_mode", 7.0);
+    rp_N.add<double>("y_max_fit_mode", 7.0);
+    rp_N.add<double>("y_cen_add", -0.3);
+    rp_N.add<double>("y_width_mult", 1.1);
+
+    rp_N.add<double>("x_slice_min", 7.);
+    rp_N.add<double>("x_slice_max", 19.);
+    rp_N.add<double>("x_slice_w", 0.2);
+    sector45.add<edm::ParameterSetDescription>("rp_N", rp_N);
+
+    edm::ParameterSetDescription rp_F;
+    rp_F.add<std::string>("name", "L_2_F");
+    rp_F.add<int>("id", 23);
+
+    rp_F.add<double>("slope", 0.19);
+    rp_F.add<double>("sh_x", -42.);
+
+    rp_F.add<double>("x_min_fit_mode", 2.);
+    rp_F.add<double>("x_max_fit_mode", 7.5);
+    rp_F.add<double>("y_max_fit_mode", 7.5);
+    rp_F.add<double>("y_cen_add", -0.3);
+    rp_F.add<double>("y_width_mult", 1.1);
+
+    rp_F.add<double>("x_slice_min", 46.);
+    rp_F.add<double>("x_slice_max", 58.);
+    rp_F.add<double>("x_slice_w", 0.2);
+    sector45.add<edm::ParameterSetDescription>("rp_F", rp_F);
+
+    sector45.add<double>("slope", 0.006);
+    sector45.add<bool>("cut_h_apply", true);
+    sector45.add<double>("cut_h_a", -1.);
+    sector45.add<double>("cut_h_c", -38.55);
+    sector45.add<double>("cut_h_si", 0.2);
+    sector45.add<bool>("cut_v_apply", true);
+    sector45.add<double>("cut_v_a", -1.07);
+    sector45.add<double>("cut_v_c", 1.63);
+    sector45.add<double>("cut_v_si", 0.15);
+
+    desc.add<edm::ParameterSetDescription>("sector_45", sector45);
+  }
+
+  // sector_56
+  {
+    edm::ParameterSetDescription sector56;
+
+    edm::ParameterSetDescription rp_N;
+    rp_N.add<std::string>("name", "R_1_F");
+    rp_N.add<int>("id", 103);
+
+    rp_N.add<double>("slope", 0.40);
+    rp_N.add<double>("sh_x", -2.8);
+
+    rp_N.add<double>("x_min_fit_mode", 2.);
+    rp_N.add<double>("x_max_fit_mode", 7.4);
+    rp_N.add<double>("y_max_fit_mode", 7.4);
+    rp_N.add<double>("y_cen_add", -0.8);
+    rp_N.add<double>("y_width_mult", 1.0);
+
+    rp_N.add<double>("x_slice_min", 6.);
+    rp_N.add<double>("x_slice_max", 17.);
+    rp_N.add<double>("x_slice_w", 0.2);
+    sector56.add<edm::ParameterSetDescription>("rp_N", rp_N);
+
+    edm::ParameterSetDescription rp_F;
+    rp_F.add<std::string>("name", "R_2_F");
+    rp_F.add<int>("id", 123);
+
+    rp_F.add<double>("slope", 0.39);
+    rp_F.add<double>("sh_x", -41.9);
+
+    rp_F.add<double>("x_min_fit_mode", 2.);
+    rp_F.add<double>("x_max_fit_mode", 8.0);
+    rp_F.add<double>("y_max_fit_mode", 8.0);
+    rp_F.add<double>("y_cen_add", -0.8);
+    rp_F.add<double>("y_width_mult", 1.0);
+
+    rp_F.add<double>("x_slice_min", 45.);
+    rp_F.add<double>("x_slice_max", 57.);
+    rp_F.add<double>("x_slice_w", 0.2);
+    sector56.add<edm::ParameterSetDescription>("rp_F", rp_F);
+
+    sector56.add<double>("slope", -0.015);
+    sector56.add<bool>("cut_h_apply", true);
+    sector56.add<double>("cut_h_a", -1.);
+    sector56.add<double>("cut_h_c", -39.26);
+    sector56.add<double>("cut_h_si", 0.2);
+    sector56.add<bool>("cut_v_apply", true);
+    sector56.add<double>("cut_v_a", -1.07);
+    sector56.add<double>("cut_v_c", 1.49);
+    sector56.add<double>("cut_v_si", 0.15);
+
+    desc.add<edm::ParameterSetDescription>("sector_56", sector56);
+  }
+
+  desc.add<double>("x_ali_sh_step", 0.01);
+
+  desc.add<double>("y_mode_sys_unc", 0.03);
+  desc.add<double>("chiSqThreshold", 50.);
+  desc.add<double>("y_mode_unc_max_valid", 5.);
+  desc.add<double>("y_mode_max_valid", 20.);
+
+  desc.add<unsigned int>("min_RP_tracks_size", 1);
+  desc.add<unsigned int>("max_RP_tracks_size", 1);
+  desc.add<double>("n_si", 4.);
+
+  // matching
+  {
+    edm::ParameterSetDescription matching;
+    matching.add<std::string>("reference_dataset", "");
+
+    edm::ParameterSetDescription rpLF;
+    rpLF.add<double>("sh_min", -43.);
+    rpLF.add<double>("sh_max", -41.);
+    matching.add<edm::ParameterSetDescription>("rp_L_F", rpLF);
+
+    edm::ParameterSetDescription rpLN;
+    rpLN.add<double>("sh_min", -4.2);
+    rpLN.add<double>("sh_max", -2.4);
+    matching.add<edm::ParameterSetDescription>("rp_L_N", rpLN);
+
+    edm::ParameterSetDescription rpRN;
+    rpRN.add<double>("sh_min", -3.6);
+    rpRN.add<double>("sh_max", -1.8);
+    matching.add<edm::ParameterSetDescription>("rp_R_N", rpRN);
+
+    edm::ParameterSetDescription rpRF;
+    rpRF.add<double>("sh_min", -43.2);
+    rpRF.add<double>("sh_max", -41.2);
+    matching.add<edm::ParameterSetDescription>("rp_R_F", rpRF);
+
+    desc.add<edm::ParameterSetDescription>("matching", matching);
+  }
+
+  // x alignment meth o
+  {
+    edm::ParameterSetDescription x_alignment_meth_o;
+
+    edm::ParameterSetDescription rpLF;
+    rpLF.add<double>("x_min", 47.);
+    rpLF.add<double>("x_max", 56.5);
+    x_alignment_meth_o.add<edm::ParameterSetDescription>("rp_L_F", rpLF);
+
+    edm::ParameterSetDescription rpLN;
+    rpLN.add<double>("x_min", 9.);
+    rpLN.add<double>("x_max", 18.5);
+    x_alignment_meth_o.add<edm::ParameterSetDescription>("rp_L_N", rpLN);
+
+    edm::ParameterSetDescription rpRN;
+    rpRN.add<double>("x_min", 7.);
+    rpRN.add<double>("x_max", 15.);
+    x_alignment_meth_o.add<edm::ParameterSetDescription>("rp_R_N", rpRN);
+
+    edm::ParameterSetDescription rpRF;
+    rpRF.add<double>("x_min", 46.);
+    rpRF.add<double>("x_max", 54.);
+    x_alignment_meth_o.add<edm::ParameterSetDescription>("rp_R_F", rpRF);
+
+    x_alignment_meth_o.add<unsigned int>("fit_profile_min_bin_entries", 5);
+    x_alignment_meth_o.add<unsigned int>("fit_profile_min_N_reasonable", 10);
+    x_alignment_meth_o.add<unsigned int>("meth_o_graph_min_N", 5);
+    x_alignment_meth_o.add<double>("meth_o_unc_fit_range", 0.5);
+
+    desc.add<edm::ParameterSetDescription>("x_alignment_meth_o", x_alignment_meth_o);
+  }
+
+  // x alignment relative
+  {
+    edm::ParameterSetDescription x_alignment_relative;
+
+    edm::ParameterSetDescription rpLN;
+    rpLN.add<double>("x_min", 7.5);
+    rpLN.add<double>("x_max", 12.);
+    x_alignment_relative.add<edm::ParameterSetDescription>("rp_L_N", rpLN);
+
+    edm::ParameterSetDescription rpRN;
+    rpRN.add<double>("x_min", 6.);
+    rpRN.add<double>("x_max", 10.);
+    x_alignment_relative.add<edm::ParameterSetDescription>("rp_R_N", rpRN);
+
+    x_alignment_relative.add<unsigned int>("near_far_min_entries", 100);
+
+    desc.add<edm::ParameterSetDescription>("x_alignment_relative", x_alignment_relative);
+  }
+
+  // y alignment
+  {
+    edm::ParameterSetDescription y_alignment;
+
+    edm::ParameterSetDescription rpLF;
+    rpLF.add<double>("x_min", 44.5);
+    rpLF.add<double>("x_max", 49.);
+    y_alignment.add<edm::ParameterSetDescription>("rp_L_F", rpLF);
+
+    edm::ParameterSetDescription rpLN;
+    rpLN.add<double>("x_min", 6.7);
+    rpLN.add<double>("x_max", 11.);
+    y_alignment.add<edm::ParameterSetDescription>("rp_L_N", rpLN);
+
+    edm::ParameterSetDescription rpRN;
+    rpRN.add<double>("x_min", 5.9);
+    rpRN.add<double>("x_max", 10.);
+    y_alignment.add<edm::ParameterSetDescription>("rp_R_N", rpRN);
+
+    edm::ParameterSetDescription rpRF;
+    rpRF.add<double>("x_min", 44.5);
+    rpRF.add<double>("x_max", 49.);
+    y_alignment.add<edm::ParameterSetDescription>("rp_R_F", rpRF);
+
+    y_alignment.add<unsigned int>("mode_graph_min_N", 5);
+    y_alignment.add<unsigned int>("mult_sel_proj_y_min_entries", 300);
+
+    desc.add<edm::ParameterSetDescription>("y_alignment", y_alignment);
+  }
+
+  // binning
+  {
+    edm::ParameterSetDescription binning;
+
+    binning.add<double>("bin_size_x", 142.3314E-3);
+    binning.add<unsigned int>("n_bins_x", 210);
+    binning.add<double>("pixel_x_offset", 40.);
+    binning.add<unsigned int>("n_bins_y", 400);
+    binning.add<double>("y_min", -20.);
+    binning.add<double>("y_max", 20.);
+
+    binning.add<unsigned int>("diffFN_n_bins_x", 100);
+    binning.add<double>("diffFN_x_min", 0.);
+    binning.add<double>("diffFN_x_max", 20.);
+
+    binning.add<unsigned int>("slice_n_bins_x", 100);
+    binning.add<double>("slice_x_min", -10.);
+    binning.add<double>("slice_x_max", 10.);
+    binning.add<unsigned int>("slice_n_bins_y", 100);
+    binning.add<double>("slice_y_min", -2.);
+    binning.add<double>("slice_y_max", 2.);
+
+    desc.add<edm::ParameterSetDescription>("binning", binning);
+  }
+
+  desc.add<std::vector<double>>("extra_params", {});
+
+  descriptions.add("ppsAlignmentConfigurationESSource", desc);
+}
+
+//---------------------------------------------------------------------------------------------
+
+// Fits a linear function to a TProfile (similar method in PPSAlignmentHarvester).
+int PPSAlignmentConfigurationESSource::fitProfile(TProfile* p, double x_mean, double x_rms, double& sl, double& sl_unc) {
+  unsigned int n_reasonable = 0;
+  for (int bi = 1; bi <= p->GetNbinsX(); bi++) {
+    if (p->GetBinEntries(bi) < fitProfileMinBinEntries) {
+      p->SetBinContent(bi, 0.);
+      p->SetBinError(bi, 0.);
+    } else {
+      n_reasonable++;
+    }
+  }
+
+  if (n_reasonable < fitProfileMinNReasonable)
+    return 1;
+
+  double x_min = x_mean - x_rms, x_max = x_mean + x_rms;
+
+  TF1* ff_pol1 = new TF1("ff_pol1", "[0] + [1]*x");
+
+  ff_pol1->SetParameter(0., 0.);
+  p->Fit(ff_pol1, "Q", "", x_min, x_max);
+
+  sl = ff_pol1->GetParameter(1);
+  sl_unc = ff_pol1->GetParError(1);
+
+  return 0;
+}
+
+//---------------------------------------------------------------------------------------------
+
+// Performs a breadth first search on dir. If found, returns the directory with object
+// named searchName inside. Otherwise, returns nullptr.
+TDirectory* PPSAlignmentConfigurationESSource::findDirectoryWithName(TDirectory* dir, std::string searchName) {
+  TIter next(dir->GetListOfKeys());
+  std::queue<TDirectory*> dirQueue;
+  TObject* o;
+  while ((o = next())) {
+    TKey* k = (TKey*)o;
+
+    std::string name = k->GetName();
+    if (name == searchName)
+      return dir;
+
+    if (((TSystemFile*)k)->IsDirectory())
+      dirQueue.push((TDirectory*)k->ReadObj());
+  }
+
+  while (!dirQueue.empty()) {
+    TDirectory* resultDir = findDirectoryWithName(dirQueue.front(), searchName);
+    dirQueue.pop();
+    if (resultDir != nullptr)
+      return resultDir;
+  }
+
+  return nullptr;
+}
+
+//---------------------------------------------------------------------------------------------
+
+// Builds vector of PointErrors instances from slice plots in dir.
+std::vector<PPSAlignmentConfiguration::PointErrors> PPSAlignmentConfigurationESSource::buildVectorFromDirectory(
+    TDirectory* dir, const PPSAlignmentConfiguration::RPConfig& rpd) {
+  std::vector<PPSAlignmentConfiguration::PointErrors> pv;
+
+  TIter next(dir->GetListOfKeys());
+  TObject* o;
+  while ((o = next())) {
+    TKey* k = (TKey*)o;
+
+    std::string name = k->GetName();
+    size_t d = name.find('-');
+    const double x_min = std::stod(name.substr(0, d));
+    const double x_max = std::stod(name.substr(d + 1));
+
+    TDirectory* d_slice = (TDirectory*)k->ReadObj();
+
+    TH1D* h_y = (TH1D*)d_slice->Get("h_y");
+    TProfile* p_y_diffFN_vs_y = (TProfile*)d_slice->Get("p_y_diffFN_vs_y");
+
+    double y_cen = h_y->GetMean();
+    double y_width = h_y->GetRMS();
+
+    y_cen += rpd.y_cen_add_;
+    y_width *= rpd.y_width_mult_;
+
+    double sl = 0., sl_unc = 0.;
+    int fr = fitProfile(p_y_diffFN_vs_y, y_cen, y_width, sl, sl_unc);
+    if (fr != 0)
+      continue;
+
+    if (debug)
+      p_y_diffFN_vs_y->Write(name.c_str());
+
+    pv.push_back({(x_max + x_min) / 2., sl, (x_max - x_min) / 2., sl_unc});
+  }
+
+  return pv;
+}
+
+//---------------------------------------------------------------------------------------------
+
+void PPSAlignmentConfigurationESSource::setIntervalFor(const edm::eventsetup::EventSetupRecordKey& key,
+                                                       const edm::IOVSyncValue& iosv,
+                                                       edm::ValidityInterval& oValidity) {
+  edm::LogInfo("PPS") << ">> PPSAlignmentConfigurationESSource::setIntervalFor(" << key.name() << ")\n"
+                      << "    run=" << iosv.eventID().run() << ", event=" << iosv.eventID().event();
+
+  edm::ValidityInterval infinity(iosv.beginOfTime(), iosv.endOfTime());
+  oValidity = infinity;
+}
+
+DEFINE_FWK_EVENTSETUP_SOURCE(PPSAlignmentConfigurationESSource);
diff --git a/CondCore/CTPPSPlugins/src/plugin.cc b/CondCore/CTPPSPlugins/src/plugin.cc
index 7f9f109e123f1..603d0d02862f8 100644
--- a/CondCore/CTPPSPlugins/src/plugin.cc
+++ b/CondCore/CTPPSPlugins/src/plugin.cc
@@ -21,6 +21,8 @@
 #include "CondFormats/DataRecord/interface/PPSPixelTopologyRcd.h"
 #include "CondFormats/PPSObjects/interface/PPSAlignmentConfig.h"
 #include "CondFormats/DataRecord/interface/PPSAlignmentConfigRcd.h"
+#include "CondFormats/PPSObjects/interface/PPSAlignmentConfiguration.h"
+#include "CondFormats/DataRecord/interface/PPSAlignmentConfigurationRcd.h"
 
 REGISTER_PLUGIN(CTPPSBeamParametersRcd, CTPPSBeamParameters);
 REGISTER_PLUGIN(CTPPSPixelDAQMappingRcd, CTPPSPixelDAQMapping);
@@ -34,3 +36,4 @@ REGISTER_PLUGIN(CTPPSOpticsRcd, LHCOpticalFunctionsSetCollection);
 REGISTER_PLUGIN(PPSDirectSimulationDataRcd, PPSDirectSimulationData);
 REGISTER_PLUGIN(PPSPixelTopologyRcd, PPSPixelTopology);
 REGISTER_PLUGIN(PPSAlignmentConfigRcd, PPSAlignmentConfig);
+REGISTER_PLUGIN(PPSAlignmentConfigurationRcd, PPSAlignmentConfiguration);
diff --git a/CondCore/Utilities/plugins/Module_2XML.cc b/CondCore/Utilities/plugins/Module_2XML.cc
index ad1e52c5724d5..639ffe22fe632 100644
--- a/CondCore/Utilities/plugins/Module_2XML.cc
+++ b/CondCore/Utilities/plugins/Module_2XML.cc
@@ -31,6 +31,7 @@ PAYLOAD_2XML_MODULE(pluginUtilities_payload2xml) {
   PAYLOAD_2XML_CLASS(CTPPSPixelDAQMapping);
   PAYLOAD_2XML_CLASS(CTPPSPixelGainCalibrations);
   PAYLOAD_2XML_CLASS(PPSAlignmentConfig)
+  PAYLOAD_2XML_CLASS(PPSAlignmentConfiguration)
   PAYLOAD_2XML_CLASS(CastorChannelQuality);
   PAYLOAD_2XML_CLASS(CastorElectronicsMap);
   PAYLOAD_2XML_CLASS(CastorGainWidths);
diff --git a/CondCore/Utilities/src/CondDBFetch.cc b/CondCore/Utilities/src/CondDBFetch.cc
index a0c6657cd3b79..5ed3a51877948 100644
--- a/CondCore/Utilities/src/CondDBFetch.cc
+++ b/CondCore/Utilities/src/CondDBFetch.cc
@@ -57,6 +57,7 @@ namespace cond {
       FETCH_PAYLOAD_CASE(CTPPSPixelGainCalibrations)
       FETCH_PAYLOAD_CASE(CTPPSRPAlignmentCorrectionsData)
       FETCH_PAYLOAD_CASE(PPSAlignmentConfig)
+      FETCH_PAYLOAD_CASE(PPSAlignmentConfiguration)
       FETCH_PAYLOAD_CASE(LHCOpticalFunctionsSetCollection)
       FETCH_PAYLOAD_CASE(CastorChannelQuality)
       FETCH_PAYLOAD_CASE(CastorElectronicsMap)
diff --git a/CondCore/Utilities/src/CondDBImport.cc b/CondCore/Utilities/src/CondDBImport.cc
index 0a93d0b0346b4..3d68b71a3e9de 100644
--- a/CondCore/Utilities/src/CondDBImport.cc
+++ b/CondCore/Utilities/src/CondDBImport.cc
@@ -77,6 +77,7 @@ namespace cond {
         IMPORT_PAYLOAD_CASE(CTPPSPixelGainCalibrations)
         IMPORT_PAYLOAD_CASE(CTPPSRPAlignmentCorrectionsData)
         IMPORT_PAYLOAD_CASE(PPSAlignmentConfig)
+        IMPORT_PAYLOAD_CASE(PPSAlignmentConfiguration)
         IMPORT_PAYLOAD_CASE(LHCOpticalFunctionsSetCollection)
         IMPORT_PAYLOAD_CASE(CastorChannelQuality)
         IMPORT_PAYLOAD_CASE(CastorElectronicsMap)
diff --git a/CondCore/Utilities/src/CondFormats.h b/CondCore/Utilities/src/CondFormats.h
index 48fe8f23f996b..8fb8a6358cd47 100644
--- a/CondCore/Utilities/src/CondFormats.h
+++ b/CondCore/Utilities/src/CondFormats.h
@@ -33,6 +33,7 @@
 #include "CondFormats/PPSObjects/interface/CTPPSPixelGainCalibrations.h"
 #include "CondFormats/PPSObjects/interface/CTPPSRPAlignmentCorrectionsData.h"
 #include "CondFormats/PPSObjects/interface/PPSTimingCalibration.h"
+#include "CondFormats/PPSObjects/interface/PPSAlignmentConfiguration.h"
 #include "CondFormats/PPSObjects/interface/LHCOpticalFunctionsSetCollection.h"
 #include "CondFormats/PPSObjects/interface/PPSAlignmentConfig.h"
 #include "CondFormats/DTObjects/interface/DTCCBConfig.h"
diff --git a/CondFormats/DataRecord/interface/PPSAlignmentConfigurationRcd.h b/CondFormats/DataRecord/interface/PPSAlignmentConfigurationRcd.h
new file mode 100644
index 0000000000000..159b1873f7e00
--- /dev/null
+++ b/CondFormats/DataRecord/interface/PPSAlignmentConfigurationRcd.h
@@ -0,0 +1,15 @@
+/****************************************************************************
+* Authors: 
+*  Jan Kašpar (jan.kaspar@gmail.com) 
+*  Mateusz Kocot (mateuszkocot99@gmail.com)
+****************************************************************************/
+
+#ifndef CondFormats_DataRecord_PPSAlignmentConfigurationRcd_h
+#define CondFormats_DataRecord_PPSAlignmentConfigurationRcd_h
+
+#include "FWCore/Framework/interface/EventSetupRecordImplementation.h"
+
+class PPSAlignmentConfigurationRcd
+    : public edm::eventsetup::EventSetupRecordImplementation<PPSAlignmentConfigurationRcd> {};
+
+#endif
diff --git a/CondFormats/DataRecord/src/PPSAlignmentConfigurationRcd.cc b/CondFormats/DataRecord/src/PPSAlignmentConfigurationRcd.cc
new file mode 100644
index 0000000000000..4c952462c6597
--- /dev/null
+++ b/CondFormats/DataRecord/src/PPSAlignmentConfigurationRcd.cc
@@ -0,0 +1,10 @@
+/****************************************************************************
+* Authors: 
+*  Jan Kašpar (jan.kaspar@gmail.com) 
+*  Mateusz Kocot (mateuszkocot99@gmail.com)
+****************************************************************************/
+
+#include "CondFormats/DataRecord/interface/PPSAlignmentConfigurationRcd.h"
+#include "FWCore/Framework/interface/eventsetuprecord_registration_macro.h"
+
+EVENTSETUP_RECORD_REG(PPSAlignmentConfigurationRcd);
diff --git a/CondFormats/PPSObjects/interface/PPSAlignmentConfiguration.h b/CondFormats/PPSObjects/interface/PPSAlignmentConfiguration.h
new file mode 100644
index 0000000000000..f514fa1c9bbd2
--- /dev/null
+++ b/CondFormats/PPSObjects/interface/PPSAlignmentConfiguration.h
@@ -0,0 +1,199 @@
+/****************************************************************************
+* Authors: 
+*  Jan Kašpar (jan.kaspar@gmail.com) 
+*  Mateusz Kocot (mateuszkocot99@gmail.com)
+****************************************************************************/
+
+#ifndef CondFormats_PPSObjects_PPSAlignmentConfiguration_h
+#define CondFormats_PPSObjects_PPSAlignmentConfiguration_h
+
+#include "CondFormats/Serialization/interface/Serializable.h"
+
+#include <vector>
+#include <string>
+#include <map>
+
+class PPSAlignmentConfiguration {
+public:
+  // Auxiliary structures
+  struct PointErrors {
+    double x_;
+    double y_;
+    double ex_;  // error x
+    double ey_;  // error y
+
+    COND_SERIALIZABLE;
+  };
+
+  struct SelectionRange {
+    double x_min_;
+    double x_max_;
+
+    COND_SERIALIZABLE;
+  };
+
+  struct RPConfig {
+    std::string name_;
+    unsigned int id_;
+    std::string position_;
+    double slope_;
+    double sh_x_;
+
+    double x_min_fit_mode_, x_max_fit_mode_;
+    double y_max_fit_mode_;
+    double y_cen_add_;
+    double y_width_mult_;
+
+    int x_slice_n_;
+    double x_slice_min_, x_slice_w_;
+
+    COND_SERIALIZABLE;
+  };
+
+  struct SectorConfig {
+    std::string name_;
+    RPConfig rp_N_, rp_F_;
+    double slope_;
+
+    bool cut_h_apply_;
+    double cut_h_a_, cut_h_c_, cut_h_si_;
+
+    bool cut_v_apply_;
+    double cut_v_a_, cut_v_c_, cut_v_si_;
+
+    COND_SERIALIZABLE;
+  };
+
+  struct Binning {
+    double bin_size_x_;  // mm
+    unsigned int n_bins_x_;
+
+    double pixel_x_offset_;
+
+    unsigned int n_bins_y_;
+    double y_min_, y_max_;
+
+    unsigned int diffFN_n_bins_x_;
+    double diffFN_x_min_, diffFN_x_max_;
+
+    unsigned int slice_n_bins_x_, slice_n_bins_y_;
+    double slice_x_min_, slice_x_max_, slice_y_min_, slice_y_max_;
+
+    COND_SERIALIZABLE;
+  };
+
+  // Getters
+  const SectorConfig& sectorConfig45() const;
+  const SectorConfig& sectorConfig56() const;
+
+  double x_ali_sh_step() const;
+
+  double y_mode_sys_unc() const;
+  double chiSqThreshold() const;
+  double y_mode_unc_max_valid() const;
+  double y_mode_max_valid() const;
+
+  double minRPTracksSize() const;
+  double maxRPTracksSize() const;
+  double n_si() const;
+
+  const std::map<unsigned int, std::vector<PointErrors>>& matchingReferencePoints() const;
+  const std::map<unsigned int, SelectionRange>& matchingShiftRanges() const;
+
+  const std::map<unsigned int, SelectionRange>& alignment_x_meth_o_ranges() const;
+  unsigned int fitProfileMinBinEntries() const;
+  unsigned int fitProfileMinNReasonable() const;
+  unsigned int methOGraphMinN() const;
+  double methOUncFitRange() const;
+
+  const std::map<unsigned int, SelectionRange>& alignment_x_relative_ranges() const;
+  unsigned int nearFarMinEntries() const;
+
+  const std::map<unsigned int, SelectionRange>& alignment_y_ranges() const;
+  unsigned int modeGraphMinN() const;
+  unsigned int multSelProjYMinEntries() const;
+
+  const Binning& binning() const;
+
+  const std::vector<double>& extraParams() const;
+
+  // Setters
+  void setSectorConfig45(SectorConfig& sectorConfig45);
+  void setSectorConfig56(SectorConfig& sectorConfig56);
+
+  void setX_ali_sh_step(double x_ali_sh_step);
+
+  void setY_mode_sys_unc(double y_mode_sys_unc);
+  void setChiSqThreshold(double chiSqThreshold);
+  void setY_mode_unc_max_valid(double y_mode_unc_max_valid);
+  void setY_mode_max_valid(double y_mode_max_valid);
+
+  void setMinRPTracksSize(unsigned int minRPTracksSize);
+  void setMaxRPTracksSize(unsigned int maxRPTracksSize);
+  void setN_si(double n_si);
+
+  void setMatchingReferencePoints(std::map<unsigned int, std::vector<PointErrors>>& matchingReferencePoints);
+  void setMatchingShiftRanges(std::map<unsigned int, SelectionRange>& matchingShiftRanges);
+
+  void setAlignment_x_meth_o_ranges(std::map<unsigned int, SelectionRange>& alignment_x_meth_o_ranges);
+  void setFitProfileMinBinEntries(unsigned int fitProfileMinBinEntries);
+  void setFitProfileMinNReasonable(unsigned int fitProfileMinNReasonable);
+  void setMethOGraphMinN(unsigned int methOGraphMinN);
+  void setMethOUncFitRange(double methOUncFitRange);
+
+  void setAlignment_x_relative_ranges(std::map<unsigned int, SelectionRange>& alignment_x_relative_ranges);
+  void setNearFarMinEntries(unsigned int nearFarMinEntries);
+
+  void setAlignment_y_ranges(std::map<unsigned int, SelectionRange>& alignment_y_ranges);
+  void setModeGraphMinN(unsigned int modeGraphMinN);
+  void setMultSelProjYMinEntries(unsigned int multSelProjYMinEntries);
+
+  void setBinning(Binning& binning);
+
+  void setExtraParams(std::vector<double>& extraParams);
+
+  // << operator
+  friend std::ostream& operator<<(std::ostream& os, const PPSAlignmentConfiguration& c);
+
+private:
+  SectorConfig sectorConfig45_, sectorConfig56_;
+
+  double x_ali_sh_step_;  // mm
+
+  double y_mode_sys_unc_;
+  double chiSqThreshold_;
+  double y_mode_unc_max_valid_;
+  double y_mode_max_valid_;
+
+  unsigned int minRPTracksSize_;
+  unsigned int maxRPTracksSize_;
+  double n_si_;
+
+  std::map<unsigned int, std::vector<PointErrors>> matchingReferencePoints_;
+  std::map<unsigned int, SelectionRange> matchingShiftRanges_;
+
+  std::map<unsigned int, SelectionRange> alignment_x_meth_o_ranges_;
+  unsigned int fitProfileMinBinEntries_;
+  unsigned int fitProfileMinNReasonable_;
+  unsigned int methOGraphMinN_;
+  double methOUncFitRange_;  // mm
+
+  std::map<unsigned int, SelectionRange> alignment_x_relative_ranges_;
+  unsigned int nearFarMinEntries_;
+
+  std::map<unsigned int, SelectionRange> alignment_y_ranges_;
+  unsigned int modeGraphMinN_;
+  unsigned int multSelProjYMinEntries_;
+
+  Binning binning_;
+
+  std::vector<double> extraParams_;
+
+  COND_SERIALIZABLE;
+};
+
+std::ostream& operator<<(std::ostream& os, const PPSAlignmentConfiguration::RPConfig& rc);
+std::ostream& operator<<(std::ostream& os, const PPSAlignmentConfiguration::SectorConfig& sc);
+std::ostream& operator<<(std::ostream& os, const PPSAlignmentConfiguration::Binning& b);
+
+#endif
diff --git a/CondFormats/PPSObjects/src/PPSAlignmentConfiguration.cc b/CondFormats/PPSObjects/src/PPSAlignmentConfiguration.cc
new file mode 100644
index 0000000000000..1e3db71078b63
--- /dev/null
+++ b/CondFormats/PPSObjects/src/PPSAlignmentConfiguration.cc
@@ -0,0 +1,263 @@
+/****************************************************************************
+* Authors: 
+*  Jan Kašpar (jan.kaspar@gmail.com) 
+*  Mateusz Kocot (mateuszkocot99@gmail.com)
+****************************************************************************/
+
+#include "CondFormats/PPSObjects/interface/PPSAlignmentConfiguration.h"
+
+#include <iostream>
+#include <cmath>
+#include <iomanip>
+
+// -------------------------------- PPSAlignmentConfiguration getters --------------------------------
+
+const PPSAlignmentConfiguration::SectorConfig& PPSAlignmentConfiguration::sectorConfig45() const {
+  return sectorConfig45_;
+}
+const PPSAlignmentConfiguration::SectorConfig& PPSAlignmentConfiguration::sectorConfig56() const {
+  return sectorConfig56_;
+}
+
+double PPSAlignmentConfiguration::x_ali_sh_step() const { return x_ali_sh_step_; }
+
+double PPSAlignmentConfiguration::y_mode_sys_unc() const { return y_mode_sys_unc_; }
+double PPSAlignmentConfiguration::chiSqThreshold() const { return chiSqThreshold_; }
+double PPSAlignmentConfiguration::y_mode_unc_max_valid() const { return y_mode_unc_max_valid_; }
+double PPSAlignmentConfiguration::y_mode_max_valid() const { return y_mode_max_valid_; }
+
+double PPSAlignmentConfiguration::minRPTracksSize() const { return minRPTracksSize_; }
+double PPSAlignmentConfiguration::maxRPTracksSize() const { return maxRPTracksSize_; }
+double PPSAlignmentConfiguration::n_si() const { return n_si_; }
+
+const std::map<unsigned int, std::vector<PPSAlignmentConfiguration::PointErrors>>&
+PPSAlignmentConfiguration::matchingReferencePoints() const {
+  return matchingReferencePoints_;
+}
+const std::map<unsigned int, PPSAlignmentConfiguration::SelectionRange>&
+PPSAlignmentConfiguration::matchingShiftRanges() const {
+  return matchingShiftRanges_;
+}
+
+const std::map<unsigned int, PPSAlignmentConfiguration::SelectionRange>&
+PPSAlignmentConfiguration::alignment_x_meth_o_ranges() const {
+  return alignment_x_meth_o_ranges_;
+}
+unsigned int PPSAlignmentConfiguration::fitProfileMinBinEntries() const { return fitProfileMinBinEntries_; }
+unsigned int PPSAlignmentConfiguration::fitProfileMinNReasonable() const { return fitProfileMinNReasonable_; }
+unsigned int PPSAlignmentConfiguration::methOGraphMinN() const { return methOGraphMinN_; }
+double PPSAlignmentConfiguration::methOUncFitRange() const { return methOUncFitRange_; }
+
+const std::map<unsigned int, PPSAlignmentConfiguration::SelectionRange>&
+PPSAlignmentConfiguration::alignment_x_relative_ranges() const {
+  return alignment_x_relative_ranges_;
+}
+unsigned int PPSAlignmentConfiguration::nearFarMinEntries() const { return nearFarMinEntries_; }
+
+const std::map<unsigned int, PPSAlignmentConfiguration::SelectionRange>& PPSAlignmentConfiguration::alignment_y_ranges()
+    const {
+  return alignment_y_ranges_;
+}
+unsigned int PPSAlignmentConfiguration::modeGraphMinN() const { return modeGraphMinN_; }
+unsigned int PPSAlignmentConfiguration::multSelProjYMinEntries() const { return multSelProjYMinEntries_; }
+
+const PPSAlignmentConfiguration::Binning& PPSAlignmentConfiguration::binning() const { return binning_; }
+
+const std::vector<double>& PPSAlignmentConfiguration::extraParams() const { return extraParams_; }
+
+// -------------------------------- PPSAlignmentConfiguration setters --------------------------------
+
+void PPSAlignmentConfiguration::setSectorConfig45(PPSAlignmentConfiguration::SectorConfig& sectorConfig45) {
+  sectorConfig45_ = sectorConfig45;
+}
+void PPSAlignmentConfiguration::setSectorConfig56(PPSAlignmentConfiguration::SectorConfig& sectorConfig56) {
+  sectorConfig56_ = sectorConfig56;
+}
+
+void PPSAlignmentConfiguration::setX_ali_sh_step(double x_ali_sh_step) { x_ali_sh_step_ = x_ali_sh_step; }
+
+void PPSAlignmentConfiguration::setY_mode_sys_unc(double y_mode_sys_unc) { y_mode_sys_unc_ = y_mode_sys_unc; }
+void PPSAlignmentConfiguration::setChiSqThreshold(double chiSqThreshold) { chiSqThreshold_ = chiSqThreshold; }
+void PPSAlignmentConfiguration::setY_mode_unc_max_valid(double y_mode_unc_max_valid) {
+  y_mode_unc_max_valid_ = y_mode_unc_max_valid;
+}
+void PPSAlignmentConfiguration::setY_mode_max_valid(double y_mode_max_valid) { y_mode_max_valid_ = y_mode_max_valid; }
+
+void PPSAlignmentConfiguration::setMinRPTracksSize(unsigned int minRPTracksSize) { minRPTracksSize_ = minRPTracksSize; }
+void PPSAlignmentConfiguration::setMaxRPTracksSize(unsigned int maxRPTracksSize) { maxRPTracksSize_ = maxRPTracksSize; }
+void PPSAlignmentConfiguration::setN_si(double n_si) { n_si_ = n_si; }
+
+void PPSAlignmentConfiguration::setMatchingReferencePoints(
+    std::map<unsigned int, std::vector<PPSAlignmentConfiguration::PointErrors>>& matchingReferencePoints) {
+  matchingReferencePoints_ = matchingReferencePoints;
+}
+void PPSAlignmentConfiguration::setMatchingShiftRanges(
+    std::map<unsigned int, PPSAlignmentConfiguration::SelectionRange>& matchingShiftRanges) {
+  matchingShiftRanges_ = matchingShiftRanges;
+}
+
+void PPSAlignmentConfiguration::setAlignment_x_meth_o_ranges(
+    std::map<unsigned int, PPSAlignmentConfiguration::SelectionRange>& alignment_x_meth_o_ranges) {
+  alignment_x_meth_o_ranges_ = alignment_x_meth_o_ranges;
+}
+void PPSAlignmentConfiguration::setFitProfileMinBinEntries(unsigned int fitProfileMinBinEntries) {
+  fitProfileMinBinEntries_ = fitProfileMinBinEntries;
+}
+void PPSAlignmentConfiguration::setFitProfileMinNReasonable(unsigned int fitProfileMinNReasonable) {
+  fitProfileMinNReasonable_ = fitProfileMinNReasonable;
+}
+void PPSAlignmentConfiguration::setMethOGraphMinN(unsigned int methOGraphMinN) { methOGraphMinN_ = methOGraphMinN; }
+void PPSAlignmentConfiguration::setMethOUncFitRange(double methOUncFitRange) { methOUncFitRange_ = methOUncFitRange; }
+
+void PPSAlignmentConfiguration::setAlignment_x_relative_ranges(
+    std::map<unsigned int, PPSAlignmentConfiguration::SelectionRange>& alignment_x_relative_ranges) {
+  alignment_x_relative_ranges_ = alignment_x_relative_ranges;
+}
+void PPSAlignmentConfiguration::setNearFarMinEntries(unsigned int nearFarMinEntries) {
+  nearFarMinEntries_ = nearFarMinEntries;
+}
+
+void PPSAlignmentConfiguration::setAlignment_y_ranges(
+    std::map<unsigned int, PPSAlignmentConfiguration::SelectionRange>& alignment_y_ranges) {
+  alignment_y_ranges_ = alignment_y_ranges;
+}
+void PPSAlignmentConfiguration::setModeGraphMinN(unsigned int modeGraphMinN) { modeGraphMinN_ = modeGraphMinN; }
+void PPSAlignmentConfiguration::setMultSelProjYMinEntries(unsigned int multSelProjYMinEntries) {
+  multSelProjYMinEntries_ = multSelProjYMinEntries;
+}
+
+void PPSAlignmentConfiguration::setBinning(PPSAlignmentConfiguration::Binning& binning) { binning_ = binning; }
+
+void PPSAlignmentConfiguration::setExtraParams(std::vector<double>& extraParams) { extraParams_ = extraParams; }
+
+// -------------------------------- << operators --------------------------------
+
+std::ostream& operator<<(std::ostream& os, const PPSAlignmentConfiguration::RPConfig& rc) {
+  os << std::fixed << std::setprecision(3);
+  os << "    " << rc.name_ << ", id = " << rc.id_ << ", position = " << rc.position_ << ":\n";
+  os << "        slope = " << rc.slope_ << ", sh_x = " << rc.sh_x_ << "\n";
+  os << "        x_min_fit_mode = " << rc.x_min_fit_mode_ << ", x_max_fit_mode = " << rc.x_max_fit_mode_ << "\n";
+  os << "        y_max_fit_mode = " << rc.y_max_fit_mode_ << "\n";
+  os << "        y_cen_add = " << rc.y_cen_add_ << ", y_width_mult = " << rc.y_width_mult_ << "\n";
+  os << std::setprecision(2);
+  os << "        x slices: min = " << rc.x_slice_min_ << ", w = " << rc.x_slice_w_ << ", n = " << rc.x_slice_n_;
+
+  return os;
+}
+
+std::ostream& operator<<(std::ostream& os, const PPSAlignmentConfiguration::SectorConfig& sc) {
+  os << std::fixed << std::setprecision(3);
+  os << sc.name_ << ":\n";
+  os << sc.rp_N_ << "\n" << sc.rp_F_ << "\n";
+  os << std::setprecision(3);
+  os << "    slope = " << sc.slope_ << "\n";
+  os << "    cut_h: apply = " << std::boolalpha << sc.cut_h_apply_ << ", a = " << sc.cut_h_a_ << ", c = " << sc.cut_h_c_
+     << ", si = " << sc.cut_h_si_ << "\n";
+  os << "    cut_v: apply = " << std::boolalpha << sc.cut_v_apply_ << ", a = " << sc.cut_v_a_ << ", c = " << sc.cut_v_c_
+     << ", si = " << sc.cut_v_si_ << "\n";
+
+  return os;
+}
+
+std::ostream& operator<<(std::ostream& os, const PPSAlignmentConfiguration::Binning& b) {
+  os << "    bin_size_x = " << b.bin_size_x_ << ", n_bins_x = " << b.n_bins_x_ << "\n";
+  os << "    pixel_x_offset = " << b.pixel_x_offset_ << "\n";
+  os << "    n_bins_y = " << b.n_bins_y_ << ", y_min = " << b.y_min_ << ", y_max = " << b.y_max_ << "\n";
+  os << "    diff far-near:"
+     << "\n";
+  os << "        n_bins_x = " << b.diffFN_n_bins_x_ << ", x_min = " << b.diffFN_x_min_
+     << ", x_max = " << b.diffFN_x_max_ << "\n";
+  os << "    slice plots:"
+     << "\n";
+  os << "        n_bins_x = " << b.slice_n_bins_x_ << ", x_min = " << b.slice_x_min_ << ", x_max = " << b.slice_x_max_
+     << "\n";
+  os << "        n_bins_y = " << b.slice_n_bins_y_ << ", y_min = " << b.slice_y_min_ << ", y_max = " << b.slice_y_max_;
+
+  return os;
+}
+
+std::ostream& operator<<(std::ostream& os, const PPSAlignmentConfiguration& c) {
+  os << "* " << c.sectorConfig45_ << "\n\n";
+  os << "* " << c.sectorConfig56_ << "\n\n";
+
+  std::map<unsigned int, std::string> rpTags = {{c.sectorConfig45_.rp_F_.id_, c.sectorConfig45_.rp_F_.name_},
+                                                {c.sectorConfig45_.rp_N_.id_, c.sectorConfig45_.rp_N_.name_},
+                                                {c.sectorConfig56_.rp_N_.id_, c.sectorConfig56_.rp_N_.name_},
+                                                {c.sectorConfig56_.rp_F_.id_, c.sectorConfig56_.rp_F_.name_}};
+
+  os << "* x alignment shift step\n";
+  os << "    x_ali_sh_step = " << c.x_ali_sh_step_ << "\n\n";
+
+  os << "* mode graph parameters\n";
+  os << "    y_mode_sys_unc = " << c.y_mode_sys_unc_ << "\n";
+  os << "    chiSqThreshold = " << c.chiSqThreshold_ << "\n";
+  os << "    y_mode_unc_max_valid = " << c.y_mode_unc_max_valid_ << "\n";
+  os << "    y_mode_max_valid = " << c.y_mode_max_valid_ << "\n\n";
+
+  os << "* selection\n";
+  os << "    min_RP_tracks_size = " << c.minRPTracksSize_ << "\n";
+  os << "    max_RP_tracks_size = " << c.maxRPTracksSize_ << "\n\n";
+
+  os << "* cuts\n";
+  os << "    n_si = " << c.n_si_ << "\n\n";
+
+  os << "* matching\n" << std::setprecision(3);
+
+  os << "    shift ranges:\n";
+  for (const auto& p : c.matchingShiftRanges_)
+    os << "        RP " << rpTags[p.first] << " (" << std::setw(3) << p.first << "): sh_min = " << p.second.x_min_
+       << ", sh_max = " << p.second.x_max_ << "\n";
+
+  os << "    reference points:\n";
+  for (const auto& pm : c.matchingReferencePoints_) {
+    os << "        " << std::setw(3) << pm.first << ": ";
+    for (unsigned int i = 0; i < pm.second.size(); i++) {
+      const auto& p = pm.second[i];
+      if (i % 5 == 0 && i > 0)
+        os << "\n             ";
+      os << "(" << std::setw(6) << p.x_ << " +- " << p.ex_ << ", " << std::setw(6) << p.y_ << " +- " << p.ey_ << "), ";
+    }
+    os << "\n";
+  }
+
+  os << "\n"
+     << "* alignment_x_meth_o\n";
+  for (const auto& p : c.alignment_x_meth_o_ranges_)
+    os << "    RP " << rpTags[p.first] << " (" << std::setw(3) << p.first << "): sh_min = " << p.second.x_min_
+       << ", sh_max = " << p.second.x_max_ << "\n";
+  os << "    fit_profile_min_bin_entries = " << c.fitProfileMinBinEntries_ << "\n";
+  os << "    fit_profile_min_N_reasonable = " << c.fitProfileMinNReasonable_ << "\n";
+  os << "    meth_o_graph_min_N = " << c.methOGraphMinN_ << "\n";
+  os << "    meth_o_unc_fit_range = " << c.methOUncFitRange_ << "\n";
+
+  os << "\n"
+     << "* alignment_x_relative\n";
+  for (const auto& p : c.alignment_x_relative_ranges_)
+    if (p.first == c.sectorConfig45_.rp_N_.id_ || p.first == c.sectorConfig56_.rp_N_.id_) {  // only near RPs
+      os << "    RP " << rpTags[p.first] << " (" << std::setw(3) << p.first << "): sh_min = " << p.second.x_min_
+         << ", sh_max = " << p.second.x_max_ << "\n";
+    }
+  os << "    near_far_min_entries = " << c.nearFarMinEntries_ << "\n";
+
+  os << "\n"
+     << "* alignment_y\n";
+  for (const auto& p : c.alignment_y_ranges_)
+    os << "    RP " << rpTags[p.first] << " (" << std::setw(3) << p.first << "): sh_min = " << p.second.x_min_
+       << ", sh_max = " << p.second.x_max_ << "\n";
+  os << "    mode_graph_min_N = " << c.modeGraphMinN_ << "\n";
+  os << "    mult_sel_proj_y_min_entries = " << c.multSelProjYMinEntries_ << "\n";
+
+  os << "\n"
+     << "* binning\n";
+  os << c.binning_ << "\n";
+
+  if (!c.extraParams_.empty()) {
+    os << "\n";
+    os << "extra_params:\n";
+    for (size_t i = 0; i < c.extraParams_.size(); i++) {
+      os << std::setw(5) << i << ": " << c.extraParams_[i] << "\n";
+    }
+  }
+
+  return os;
+}
diff --git a/CondFormats/PPSObjects/src/T_EventSetup_PPSAlignmentConfiguration.cc b/CondFormats/PPSObjects/src/T_EventSetup_PPSAlignmentConfiguration.cc
new file mode 100644
index 0000000000000..66ce70016939b
--- /dev/null
+++ b/CondFormats/PPSObjects/src/T_EventSetup_PPSAlignmentConfiguration.cc
@@ -0,0 +1,4 @@
+#include "CondFormats/PPSObjects/interface/PPSAlignmentConfiguration.h"
+#include "FWCore/Utilities/interface/typelookup.h"
+
+TYPELOOKUP_DATA_REG(PPSAlignmentConfiguration);
diff --git a/CondFormats/PPSObjects/src/classes_def.xml b/CondFormats/PPSObjects/src/classes_def.xml
index 74cfa9a9761dc..30b9cabd974ff 100644
--- a/CondFormats/PPSObjects/src/classes_def.xml
+++ b/CondFormats/PPSObjects/src/classes_def.xml
@@ -81,4 +81,16 @@
     <class name="std::pair<unsigned int, SelectionRange>"/>
     <class name="PPSAlignmentConfig" class_version="0"/>
 
-  </lcgdict> 
\ No newline at end of file
+    <class name="PPSAlignmentConfiguration::PointErrors"/>
+    <class name="PPSAlignmentConfiguration::SelectionRange"/>
+    <class name="PPSAlignmentConfiguration::RPConfig"/>
+    <class name="PPSAlignmentConfiguration::SectorConfig"/>
+    <class name="PPSAlignmentConfiguration::Binning"/>
+    <class name="std::vector<PPSAlignmentConfiguration::PointErrors>"/>
+    <class name="std::map<unsigned int, std::vector<PPSAlignmentConfiguration::PointErrors>>"/>
+    <class name="std::pair<unsigned int, std::vector<PPSAlignmentConfiguration::PointErrors>>"/>
+    <class name="std::map<unsigned int, PPSAlignmentConfiguration::SelectionRange>"/>
+    <class name="std::pair<unsigned int, PPSAlignmentConfiguration::SelectionRange>"/>
+    <class name="PPSAlignmentConfiguration" class_version="0"/>
+
+</lcgdict>
diff --git a/CondFormats/PPSObjects/src/headers.h b/CondFormats/PPSObjects/src/headers.h
index 1b77a578cb8ca..bfc516c9e2727 100644
--- a/CondFormats/PPSObjects/src/headers.h
+++ b/CondFormats/PPSObjects/src/headers.h
@@ -5,6 +5,7 @@
 #include "CondFormats/PPSObjects/interface/CTPPSRPAlignmentCorrectionsData.h"
 #include "CondFormats/PPSObjects/interface/CTPPSRPAlignmentCorrectionsDataSequence.h"
 #include "CondFormats/PPSObjects/interface/PPSTimingCalibration.h"
+#include "CondFormats/PPSObjects/interface/PPSAlignmentConfiguration.h"
 
 #include "CondFormats/PPSObjects/interface/LHCOpticalFunctionsSet.h"
 #include "CondFormats/PPSObjects/interface/LHCOpticalFunctionsSetCollection.h"
diff --git a/CondFormats/PPSObjects/test/BuildFile.xml b/CondFormats/PPSObjects/test/BuildFile.xml
index edb32ad3438ca..ad9fcb974a153 100644
--- a/CondFormats/PPSObjects/test/BuildFile.xml
+++ b/CondFormats/PPSObjects/test/BuildFile.xml
@@ -13,3 +13,7 @@
 <bin file="testSerializationPPSAlignmentConfig.cc">
   <use name="CondFormats/PPSObjects"/>
 </bin>
+
+<bin file="testSerializationPPSAlignmentConfiguration.cc">
+  <use name="CondFormats/PPSObjects"/>
+</bin>
diff --git a/CondFormats/PPSObjects/test/testSerializationPPSAlignmentConfiguration.cc b/CondFormats/PPSObjects/test/testSerializationPPSAlignmentConfiguration.cc
new file mode 100644
index 0000000000000..092c293844946
--- /dev/null
+++ b/CondFormats/PPSObjects/test/testSerializationPPSAlignmentConfiguration.cc
@@ -0,0 +1,17 @@
+#include "CondFormats/Serialization/interface/Test.h"
+
+#include "../src/headers.h"
+
+int main() {
+  testSerialization<PPSAlignmentConfiguration::PointErrors>();
+  testSerialization<PPSAlignmentConfiguration::SelectionRange>();
+  testSerialization<PPSAlignmentConfiguration::RPConfig>();
+  testSerialization<PPSAlignmentConfiguration::SectorConfig>();
+  testSerialization<PPSAlignmentConfiguration::Binning>();
+
+  testSerialization<std::vector<PPSAlignmentConfiguration::PointErrors>>();
+  testSerialization<std::map<unsigned int, std::vector<PPSAlignmentConfiguration::PointErrors>>>();
+  testSerialization<std::map<unsigned int, PPSAlignmentConfiguration::SelectionRange>>();
+
+  testSerialization<PPSAlignmentConfiguration>();
+}
diff --git a/CondTools/CTPPS/plugins/RetrievePPSAlignmentConfiguration.cc b/CondTools/CTPPS/plugins/RetrievePPSAlignmentConfiguration.cc
new file mode 100644
index 0000000000000..823fe93efbc97
--- /dev/null
+++ b/CondTools/CTPPS/plugins/RetrievePPSAlignmentConfiguration.cc
@@ -0,0 +1,43 @@
+/****************************************************************************
+* Author: 
+*  Mateusz Kocot (mateuszkocot99@gmail.com)
+****************************************************************************/
+
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/one/EDAnalyzer.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Framework/interface/ESHandle.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/ServiceRegistry/interface/Service.h"
+
+#include "CondFormats/PPSObjects/interface/PPSAlignmentConfiguration.h"
+#include "CondFormats/DataRecord/interface/PPSAlignmentConfigurationRcd.h"
+
+#include <memory>
+
+class RetrievePPSAlignmentConfiguration : public edm::one::EDAnalyzer<> {
+public:
+  explicit RetrievePPSAlignmentConfiguration(const edm::ParameterSet&);
+
+private:
+  void analyze(const edm::Event&, const edm::EventSetup&) override;
+
+  edm::ESGetToken<PPSAlignmentConfiguration, PPSAlignmentConfigurationRcd> esToken_;
+};
+
+RetrievePPSAlignmentConfiguration::RetrievePPSAlignmentConfiguration(const edm::ParameterSet& iConfig)
+    : esToken_(esConsumes()) {}
+
+void RetrievePPSAlignmentConfiguration::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
+  // get the data
+  const auto& ppsAlignmentConfiguration = iSetup.getData(esToken_);
+
+  edm::LogInfo("PPS") << ppsAlignmentConfiguration;
+}
+
+//define this as a plug-in
+DEFINE_FWK_MODULE(RetrievePPSAlignmentConfiguration);
diff --git a/CondTools/CTPPS/plugins/WritePPSAlignmentConfiguration.cc b/CondTools/CTPPS/plugins/WritePPSAlignmentConfiguration.cc
new file mode 100644
index 0000000000000..387ec812d0bb6
--- /dev/null
+++ b/CondTools/CTPPS/plugins/WritePPSAlignmentConfiguration.cc
@@ -0,0 +1,51 @@
+/****************************************************************************
+* Author: 
+*  Mateusz Kocot (mateuszkocot99@gmail.com)
+****************************************************************************/
+
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/one/EDAnalyzer.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Framework/interface/ESHandle.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/ServiceRegistry/interface/Service.h"
+
+#include "CondCore/DBOutputService/interface/PoolDBOutputService.h"
+
+#include "CondFormats/PPSObjects/interface/PPSAlignmentConfiguration.h"
+#include "CondFormats/DataRecord/interface/PPSAlignmentConfigurationRcd.h"
+
+#include <memory>
+
+class WritePPSAlignmentConfiguration : public edm::one::EDAnalyzer<> {
+public:
+  explicit WritePPSAlignmentConfiguration(const edm::ParameterSet &);
+
+private:
+  void analyze(const edm::Event &, const edm::EventSetup &) override;
+
+  edm::ESGetToken<PPSAlignmentConfiguration, PPSAlignmentConfigurationRcd> esToken_;
+};
+
+WritePPSAlignmentConfiguration::WritePPSAlignmentConfiguration(const edm::ParameterSet &iConfig)
+    : esToken_(esConsumes<PPSAlignmentConfiguration, PPSAlignmentConfigurationRcd>(
+          edm::ESInputTag("", iConfig.getParameter<std::string>("label")))) {}
+
+void WritePPSAlignmentConfiguration::analyze(const edm::Event &iEvent, const edm::EventSetup &iSetup) {
+  // get the data
+  const auto &ppsAlignmentConfiguration = iSetup.getData(esToken_);
+
+  // store the data in a DB object
+  edm::Service<cond::service::PoolDBOutputService> poolDbService;
+  if (poolDbService.isAvailable()) {
+    poolDbService->writeOne(&ppsAlignmentConfiguration, poolDbService->currentTime(), "PPSAlignmentConfigurationRcd");
+  } else {
+    throw cms::Exception("WritePPSAlignmentConfiguration") << "PoolDBService required.";
+  }
+}
+
+//define this as a plug-in
+DEFINE_FWK_MODULE(WritePPSAlignmentConfiguration);
diff --git a/CondTools/CTPPS/test/retrieve_PPSAlignmentConfiguration_cfg.py b/CondTools/CTPPS/test/retrieve_PPSAlignmentConfiguration_cfg.py
new file mode 100644
index 0000000000000..2a9d3ddc5b1d3
--- /dev/null
+++ b/CondTools/CTPPS/test/retrieve_PPSAlignmentConfiguration_cfg.py
@@ -0,0 +1,52 @@
+##### configuration #####
+input_conditions = 'sqlite_file:alignment_config.db'  # input database
+run_number = 1  # used to select the IOV
+db_tag = 'PPSAlignmentConfiguration_v1_express'  # database tag
+#########################
+
+import FWCore.ParameterSet.Config as cms
+
+process = cms.Process("retrievePPSAlignmentConfiguration")
+
+# Message Logger
+process.MessageLogger = cms.Service("MessageLogger",
+    destinations = cms.untracked.vstring('retrieve_PPSAlignmentConfiguration'),
+    retrieve_PPSAlignmentConfiguration = cms.untracked.PSet(
+        threshold = cms.untracked.string('INFO')
+    )
+)
+
+# Load CondDB service
+process.load("CondCore.CondDB.CondDB_cfi")
+\
+# input database (in this case the local sqlite file)
+process.CondDB.connect = input_conditions
+
+# A data source must always be defined. We don't need it, so here's a dummy one.
+process.source = cms.Source("EmptyIOVSource",
+    timetype = cms.string('runnumber'),
+    firstValue = cms.uint64(run_number),
+    lastValue = cms.uint64(run_number),
+    interval = cms.uint64(1)
+)
+
+# input service
+process.PoolDBESSource = cms.ESSource("PoolDBESSource",
+    process.CondDB,
+    DumbStat = cms.untracked.bool(True),
+    toGet = cms.VPSet(cms.PSet(
+        record = cms.string('PPSAlignmentConfigurationRcd'),
+        tag = cms.string(db_tag)
+    ))
+)
+
+# DB object retrieve module
+process.retrieve_config = cms.EDAnalyzer("RetrievePPSAlignmentConfiguration",
+    toGet = cms.VPSet(cms.PSet(
+        record = cms.string('PPSAlignmentConfigurationRcd'),
+        data = cms.vstring('PPSAlignmentConfiguration')
+    )),
+    verbose = cms.untracked.bool(True)
+)
+
+process.path = cms.Path(process.retrieve_config)
diff --git a/CondTools/CTPPS/test/write_PPSAlignmentConfiguration_cfg.py b/CondTools/CTPPS/test/write_PPSAlignmentConfiguration_cfg.py
new file mode 100644
index 0000000000000..0c5b693ff9cab
--- /dev/null
+++ b/CondTools/CTPPS/test/write_PPSAlignmentConfiguration_cfg.py
@@ -0,0 +1,90 @@
+##### configuration #####
+output_conditions = 'sqlite_file:alignment_config.db'  # output database
+run_number = 1  # beginning of the IOV
+db_tag = 'PPSAlignmentConfiguration_v1_express'  # database tag
+produce_logs = True  # if set to True, a file with logs will be produced.
+product_instance_label = 'db_test'  # ES product label
+# ESSource parameters can be configured below
+#########################
+
+import FWCore.ParameterSet.Config as cms
+
+process = cms.Process("writePPSAlignmentConfiguration")
+
+# Message Logger
+if produce_logs:
+    process.MessageLogger = cms.Service("MessageLogger",
+        destinations = cms.untracked.vstring('write_PPSAlignmentConfiguration',
+                                             'cout'
+                                            ),
+        write_PPSAlignmentConfiguration = cms.untracked.PSet(
+            threshold = cms.untracked.string('INFO')
+        ),
+        cout = cms.untracked.PSet(
+            threshold = cms.untracked.string('WARNING')
+        )
+    )
+else:
+    process.MessageLogger = cms.Service("MessageLogger",
+        destinations = cms.untracked.vstring('cout'),
+        cout = cms.untracked.PSet(
+            threshold = cms.untracked.string('WARNING')
+        )
+    )
+
+# Load CondDB service
+process.load("CondCore.CondDB.CondDB_cfi")
+
+# output database
+process.CondDB.connect = output_conditions
+
+# A data source must always be defined. We don't need it, so here's a dummy one.
+process.source = cms.Source("EmptyIOVSource",
+    timetype = cms.string('runnumber'),
+    firstValue = cms.uint64(run_number),
+    lastValue = cms.uint64(run_number),
+    interval = cms.uint64(1)
+)
+
+# output service
+process.PoolDBOutputService = cms.Service("PoolDBOutputService",
+    process.CondDB,
+    timetype = cms.untracked.string('runnumber'),
+    toPut = cms.VPSet(cms.PSet(
+        record = cms.string('PPSAlignmentConfigurationRcd'),
+        tag = cms.string(db_tag)
+    ))
+)
+
+# ESSource
+process.ppsAlignmentConfigurationESSource = cms.ESSource("PPSAlignmentConfigurationESSource",
+    # PPSAlignmentConfigurationESSource parameters, defaults will be taken from fillDescriptions
+    label = cms.string(product_instance_label),
+    sector_45 = cms.PSet(
+        rp_N = cms.PSet(
+            name = cms.string('db_test_RP'),
+            id = cms.int32(44),
+            y_max_fit_mode = cms.double(66.6)
+        )
+    ),
+    y_alignment = cms.PSet(
+        rp_L_F = cms.PSet(
+            x_min = cms.double(102),
+            x_max = cms.double(210.0)
+        )
+    ),
+    extra_params = cms.vdouble( 1.15, 102., 777.7 )
+)
+
+# DB object maker
+process.config_writer = cms.EDAnalyzer("WritePPSAlignmentConfiguration",
+    record = cms.string('PPSAlignmentConfigurationRcd'),
+    loggingOn = cms.untracked.bool(True),
+    SinceAppendMode = cms.bool(True),
+    Source = cms.PSet(
+        IOVRun = cms.untracked.uint32(1)
+    ),
+    label = cms.string(product_instance_label)
+)
+
+process.path = cms.Path(process.config_writer)