CastorTextCalibrations.cc

Go to the documentation of this file.

#include <memory>
#include <iostream>
#include <fstream>
 
#include "FWCore/Utilities/interface/Exception.h"
#include "FWCore/ParameterSet/interface/FileInPath.h"
 
#include "FWCore/Framework/interface/ValidityInterval.h"
 
#include "CalibCalorimetry/CastorCalib/interface/CastorDbASCIIIO.h"
 
#include "CondFormats/CastorObjects/interface/CastorPedestals.h"
#include "CondFormats/CastorObjects/interface/CastorPedestalWidths.h"
#include "CondFormats/CastorObjects/interface/CastorGains.h"
#include "CondFormats/CastorObjects/interface/CastorGainWidths.h"
#include "CondFormats/CastorObjects/interface/CastorElectronicsMap.h"
#include "CondFormats/CastorObjects/interface/CastorChannelQuality.h"
#include "CondFormats/CastorObjects/interface/CastorQIEData.h"
 
#include "CondFormats/DataRecord/interface/CastorPedestalsRcd.h"
#include "CondFormats/DataRecord/interface/CastorPedestalWidthsRcd.h"
#include "CondFormats/DataRecord/interface/CastorGainsRcd.h"
#include "CondFormats/DataRecord/interface/CastorGainWidthsRcd.h"
#include "CondFormats/DataRecord/interface/CastorElectronicsMapRcd.h"
#include "CondFormats/DataRecord/interface/CastorChannelQualityRcd.h"
#include "CondFormats/DataRecord/interface/CastorQIEDataRcd.h"
#include "CondFormats/DataRecord/interface/CastorRecoParamsRcd.h"
#include "CondFormats/DataRecord/interface/CastorSaturationCorrsRcd.h"
 
#include "CastorTextCalibrations.h"
//
// class decleration
//
 
using namespace cms;
 
CastorTextCalibrations::CastorTextCalibrations(const edm::ParameterSet& iConfig)
 
{
  //parsing parameters
  std::vector<edm::ParameterSet> data = iConfig.getParameter<std::vector<edm::ParameterSet> >("input");
  std::vector<edm::ParameterSet>::iterator request = data.begin();
  for (; request != data.end(); ++request) {
    std::string objectName = request->getParameter<std::string>("object");
    edm::FileInPath fp = request->getParameter<edm::FileInPath>("file");
    mInputs[objectName] = fp.fullPath();
    if (objectName == "Pedestals") {
      setWhatProduced(this, &CastorTextCalibrations::producePedestals);
      findingRecord<CastorPedestalsRcd>();
    } else if (objectName == "PedestalWidths") {
      setWhatProduced(this, &CastorTextCalibrations::producePedestalWidths);
      findingRecord<CastorPedestalWidthsRcd>();
    } else if (objectName == "Gains") {
      setWhatProduced(this, &CastorTextCalibrations::produceGains);
      findingRecord<CastorGainsRcd>();
    } else if (objectName == "GainWidths") {
      setWhatProduced(this, &CastorTextCalibrations::produceGainWidths);
      findingRecord<CastorGainWidthsRcd>();
    } else if (objectName == "QIEData") {
      setWhatProduced(this, &CastorTextCalibrations::produceQIEData);
      findingRecord<CastorQIEDataRcd>();
    } else if (objectName == "ChannelQuality") {
      setWhatProduced(this, &CastorTextCalibrations::produceChannelQuality);
      findingRecord<CastorChannelQualityRcd>();
    } else if (objectName == "ElectronicsMap") {
      setWhatProduced(this, &CastorTextCalibrations::produceElectronicsMap);
      findingRecord<CastorElectronicsMapRcd>();
    } else if (objectName == "RecoParams") {
      setWhatProduced(this, &CastorTextCalibrations::produceRecoParams);
      findingRecord<CastorRecoParamsRcd>();
    } else if (objectName == "SaturationCorrs") {
      setWhatProduced(this, &CastorTextCalibrations::produceSaturationCorrs);
      findingRecord<CastorSaturationCorrsRcd>();
    } else {
      std::cerr << "CastorTextCalibrations-> Unknown object name '" << objectName << "', known names are: "
                << "Pedestals PedestalWidths Gains GainWidths QIEData ChannelQuality ElectronicsMap RecoParams "
                   "SaturationCorrs"
                << std::endl;
    }
  }
  //  setWhatProduced(this);
}
 
CastorTextCalibrations::~CastorTextCalibrations() {}
 
//
// member functions
//
void CastorTextCalibrations::setIntervalFor(const edm::eventsetup::EventSetupRecordKey& iKey,
                                            const edm::IOVSyncValue& iTime,
                                            edm::ValidityInterval& oInterval) {
  std::string record = iKey.name();
  oInterval = edm::ValidityInterval(edm::IOVSyncValue::beginOfTime(), edm::IOVSyncValue::endOfTime());  //infinite
}
 
template <class T>
std::unique_ptr<T> produce_impl(const std::string& fFile) {
  std::unique_ptr<T> result(new T());
  std::ifstream inStream(fFile.c_str());
  if (!inStream.good()) {
    std::cerr << "CastorTextCalibrations-> Unable to open file '" << fFile << "'" << std::endl;
    throw cms::Exception("FileNotFound") << "Unable to open '" << fFile << "'" << std::endl;
  }
  if (!CastorDbASCIIIO::getObject(inStream, *result)) {
    std::cerr << "CastorTextCalibrations-> Can not read object from file '" << fFile << "'" << std::endl;
    throw cms::Exception("ReadError") << "Can not read object from file '" << fFile << "'" << std::endl;
  }
  return result;
}
 
std::unique_ptr<CastorPedestals> CastorTextCalibrations::producePedestals(const CastorPedestalsRcd&) {
  return produce_impl<CastorPedestals>(mInputs["Pedestals"]);
}
 
std::unique_ptr<CastorPedestalWidths> CastorTextCalibrations::producePedestalWidths(const CastorPedestalWidthsRcd&) {
  return produce_impl<CastorPedestalWidths>(mInputs["PedestalWidths"]);
}
 
std::unique_ptr<CastorGains> CastorTextCalibrations::produceGains(const CastorGainsRcd&) {
  return produce_impl<CastorGains>(mInputs["Gains"]);
}
 
std::unique_ptr<CastorGainWidths> CastorTextCalibrations::produceGainWidths(const CastorGainWidthsRcd&) {
  return produce_impl<CastorGainWidths>(mInputs["GainWidths"]);
}
 
std::unique_ptr<CastorQIEData> CastorTextCalibrations::produceQIEData(const CastorQIEDataRcd& rcd) {
  return produce_impl<CastorQIEData>(mInputs["QIEData"]);
}
 
std::unique_ptr<CastorChannelQuality> CastorTextCalibrations::produceChannelQuality(const CastorChannelQualityRcd& rcd) {
  return produce_impl<CastorChannelQuality>(mInputs["ChannelQuality"]);
}
 
std::unique_ptr<CastorElectronicsMap> CastorTextCalibrations::produceElectronicsMap(const CastorElectronicsMapRcd& rcd) {
  return produce_impl<CastorElectronicsMap>(mInputs["ElectronicsMap"]);
}
 
std::unique_ptr<CastorRecoParams> CastorTextCalibrations::produceRecoParams(const CastorRecoParamsRcd& rcd) {
  return produce_impl<CastorRecoParams>(mInputs["RecoParams"]);
}
 
std::unique_ptr<CastorSaturationCorrs> CastorTextCalibrations::produceSaturationCorrs(
    const CastorSaturationCorrsRcd& rcd) {
  return produce_impl<CastorSaturationCorrs>(mInputs["SaturationCorrs"]);
}