PPSTimingCalibrationESSource.cc

Go to the documentation of this file.

/****************************************************************************
 *
 * This is a part of CTPPS offline software.
 * Authors:
 *   Edoardo Bossini
 *   Filip Dej
 *   Laurent Forthomme
 *
 * NOTE:
 *   Given implementation handles calibration files in JSON format,
 *   which can be generated using dedicated python script.
 *
 ****************************************************************************/
 
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/Framework/interface/SourceFactory.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/ESProducer.h"
#include "FWCore/Framework/interface/EventSetupRecordIntervalFinder.h"
#include "FWCore/Framework/interface/ESProducts.h"
 
#include "FWCore/ParameterSet/interface/ParameterSet.h"
 
#include "CondFormats/PPSObjects/interface/PPSTimingCalibration.h"
#include "CondFormats/DataRecord/interface/PPSTimingCalibrationRcd.h"
 
#include <boost/property_tree/json_parser.hpp>
#include <boost/property_tree/ptree.hpp>
 
namespace pt = boost::property_tree;
 
//------------------------------------------------------------------------------
 
class PPSTimingCalibrationESSource : public edm::ESProducer, public edm::EventSetupRecordIntervalFinder {
public:
  PPSTimingCalibrationESSource(const edm::ParameterSet&);
 
  edm::ESProducts<std::unique_ptr<PPSTimingCalibration> > produce(const PPSTimingCalibrationRcd&);
 
  static void fillDescriptions(edm::ConfigurationDescriptions&);
 
private:
  enum struct DetectorType { INVALID = 0, TOTEM_UFSD = 1, PPS_DIAMOND = 2 };
 
  void setIntervalFor(const edm::eventsetup::EventSetupRecordKey&,
                      const edm::IOVSyncValue&,
                      edm::ValidityInterval&) override;
 
  std::unique_ptr<PPSTimingCalibration> parseTotemUFSDJsonFile() const;
  std::unique_ptr<PPSTimingCalibration> parsePPSDiamondJsonFile() const;
 
  const std::string filename_;
  DetectorType subdetector_;
};
 
//------------------------------------------------------------------------------
 
PPSTimingCalibrationESSource::PPSTimingCalibrationESSource(const edm::ParameterSet& iConfig)
    : filename_(iConfig.getParameter<edm::FileInPath>("calibrationFile").fullPath()),
      subdetector_((DetectorType)iConfig.getParameter<unsigned int>("subDetector")) {
  setWhatProduced(this);
  findingRecord<PPSTimingCalibrationRcd>();
}
 
//------------------------------------------------------------------------------
 
edm::ESProducts<std::unique_ptr<PPSTimingCalibration> > PPSTimingCalibrationESSource::produce(
    const PPSTimingCalibrationRcd&) {
  switch (subdetector_) {
    case DetectorType::TOTEM_UFSD:
      return edm::es::products(parseTotemUFSDJsonFile());
    case DetectorType::PPS_DIAMOND:
      return edm::es::products(parsePPSDiamondJsonFile());
    default:
      throw cms::Exception("PPSTimingCalibrationESSource") << "Subdetector " << (int)subdetector_ << " not recognised!";
  }
}
 
//------------------------------------------------------------------------------
 
void PPSTimingCalibrationESSource::setIntervalFor(const edm::eventsetup::EventSetupRecordKey&,
                                                  const edm::IOVSyncValue&,
                                                  edm::ValidityInterval& oValidity) {
  oValidity = edm::ValidityInterval(edm::IOVSyncValue::beginOfTime(), edm::IOVSyncValue::endOfTime());
}
 
//------------------------------------------------------------------------------
 
std::unique_ptr<PPSTimingCalibration> PPSTimingCalibrationESSource::parseTotemUFSDJsonFile() const {
  pt::ptree mother_node;
  pt::read_json(filename_, mother_node);
 
  const std::string formula = mother_node.get<std::string>("formula");
  PPSTimingCalibration::ParametersMap params;
  PPSTimingCalibration::TimingMap time_info;
 
  for (pt::ptree::value_type& par : mother_node.get_child("parameters")) {
    PPSTimingCalibration::Key key;
    key.db = (int)strtol(par.first.data(), nullptr, 10);
 
    for (pt::ptree::value_type& board : par.second) {
      key.sampic = board.second.get<int>("sampic");
      key.channel = board.second.get<int>("channel");
      double timeOffset = board.second.get<double>("time_offset");
      double timePrecision = board.second.get<double>("time_precision");
      key.cell = -1;
      time_info[key] = {timeOffset, timePrecision};
 
      int cell_ct = 0;
      for (pt::ptree::value_type& cell : board.second.get_child("cells")) {
        std::vector<double> values;
        key.cell = cell_ct;
 
        for (pt::ptree::value_type& param : cell.second)
          values.emplace_back(std::stod(param.second.data(), nullptr));
        params[key] = values;
        cell_ct++;
      }
    }
  }
  return std::make_unique<PPSTimingCalibration>(formula, params, time_info);
}
 
std::unique_ptr<PPSTimingCalibration> PPSTimingCalibrationESSource::parsePPSDiamondJsonFile() const {
  pt::ptree mother_node;
  pt::read_json(filename_, mother_node);
 
  const std::string formula = mother_node.get<std::string>("formula");
  PPSTimingCalibration::ParametersMap params;
  PPSTimingCalibration::TimingMap time_info;
 
  for (pt::ptree::value_type& par : mother_node.get_child("Parameters.Sectors")) {
    PPSTimingCalibration::Key key;
    key.db = par.second.get<int>("sector");
 
    for (pt::ptree::value_type& st : par.second.get_child("Stations")) {
      key.sampic = st.second.get<int>("station");
 
      for (pt::ptree::value_type& pl : st.second.get_child("Planes")) {
        key.channel = pl.second.get<int>("plane");
 
        for (pt::ptree::value_type& ch : pl.second.get_child("Channels")) {
          key.cell = ch.second.get<int>("channel");
          double timeOffset = ch.second.get<double>("time_offset");
          double timePrecision = ch.second.get<double>("time_precision");
          time_info[key] = {timeOffset, timePrecision};
 
          std::vector<double> values;
          for (pt::ptree::value_type& param : ch.second.get_child("param"))
            values.emplace_back(std::stod(param.second.data(), nullptr));
          params[key] = values;
        }
      }
    }
  }
  return std::make_unique<PPSTimingCalibration>(formula, params, time_info);
}
 
void PPSTimingCalibrationESSource::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
  edm::ParameterSetDescription desc;
  desc.add<edm::FileInPath>("calibrationFile", edm::FileInPath())
      ->setComment("file with SAMPIC calibrations, ADC and INL; if empty or corrupted, no calibration will be applied");
  desc.add<unsigned int>("subDetector", (unsigned int)PPSTimingCalibrationESSource::DetectorType::INVALID)
      ->setComment("type of sub-detector for which the calibrations are provided");
 
  descriptions.add("ppsTimingCalibrationESSource", desc);
}
 
DEFINE_FWK_EVENTSETUP_SOURCE(PPSTimingCalibrationESSource);