HcalPlugins/src/HcalTextCalibrations.cc

0001 // -*- C++ -*-
0002 // Original Author:  Fedor Ratnikov
0003 //
0004 //
0005
0006 #include <memory>
0007 #include <iostream>
0008 #include <fstream>
0009
0010 #include "FWCore/Utilities/interface/Exception.h"
0011 #include "FWCore/ParameterSet/interface/FileInPath.h"
0012
0013 #include "FWCore/Framework/interface/ValidityInterval.h"
0014
0015 #include "Geometry/Records/interface/HcalRecNumberingRecord.h"
0016
0017 #include "CondFormats/DataRecord/interface/HcalAllRcds.h"
0018
0019 #include "HcalTextCalibrations.h"
0020 //
0021 // class declaration
0022 //
0023
0024 using namespace cms;
0025
0026 HcalTextCalibrations::HcalTextCalibrations(const edm::ParameterSet& iConfig)
0027
0028 {
0029   //parsing parameters
0030   std::vector<edm::ParameterSet> data = iConfig.getParameter<std::vector<edm::ParameterSet> >("input");
0031   std::vector<edm::ParameterSet>::iterator request = data.begin();
0032   for (; request != data.end(); ++request) {
0033     std::string objectName = request->getParameter<std::string>("object");
0034     edm::FileInPath fp = request->getParameter<edm::FileInPath>("file");
0035     mInputs[objectName] = fp.fullPath();
0036     //   std::cout << objectName << " with file " << fp.fullPath() << std::endl;
0037     if (objectName == "Pedestals") {
0038       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::producePedestals).consumes();
0039       findingRecord<HcalPedestalsRcd>();
0040     } else if (objectName == "PedestalWidths") {
0041       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::producePedestalWidths).consumes();
0042       findingRecord<HcalPedestalWidthsRcd>();
0043     } else if (objectName == "EffectivePedestals") {
0044       mTokens[objectName] =
0045           setWhatProduced(this, &HcalTextCalibrations::produceEffectivePedestals, edm::es::Label("effective"))
0046               .consumes();
0047       findingRecord<HcalPedestalsRcd>();
0048     } else if (objectName == "EffectivePedestalWidths") {
0049       mTokens[objectName] =
0050           setWhatProduced(this, &HcalTextCalibrations::produceEffectivePedestalWidths, edm::es::Label("effective"))
0051               .consumes();
0052       findingRecord<HcalPedestalWidthsRcd>();
0053     } else if (objectName == "Gains") {
0054       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::produceGains).consumes();
0055       findingRecord<HcalGainsRcd>();
0056     } else if (objectName == "GainWidths") {
0057       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::produceGainWidths).consumes();
0058       findingRecord<HcalGainWidthsRcd>();
0059     } else if (objectName == "PFCuts") {
0060       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::producePFCuts).consumes();
0061       findingRecord<HcalPFCutsRcd>();
0062     } else if (objectName == "QIEData") {
0063       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::produceQIEData).consumes();
0064       findingRecord<HcalQIEDataRcd>();
0065     } else if (objectName == "QIETypes") {
0066       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::produceQIETypes).consumes();
0067       findingRecord<HcalQIETypesRcd>();
0068     } else if (objectName == "ChannelQuality") {
0069       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::produceChannelQuality).consumes();
0070       findingRecord<HcalChannelQualityRcd>();
0071     } else if (objectName == "ZSThresholds") {
0072       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::produceZSThresholds).consumes();
0073       findingRecord<HcalZSThresholdsRcd>();
0074     } else if (objectName == "RespCorrs") {
0075       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::produceRespCorrs).consumes();
0076       findingRecord<HcalRespCorrsRcd>();
0077     } else if (objectName == "LUTCorrs") {
0078       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::produceLUTCorrs).consumes();
0079       findingRecord<HcalLUTCorrsRcd>();
0080     } else if (objectName == "PFCorrs") {
0081       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::producePFCorrs).consumes();
0082       findingRecord<HcalPFCorrsRcd>();
0083     } else if (objectName == "TimeCorrs") {
0084       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::produceTimeCorrs).consumes();
0085       findingRecord<HcalTimeCorrsRcd>();
0086     } else if (objectName == "L1TriggerObjects") {
0087       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::produceL1TriggerObjects).consumes();
0088       findingRecord<HcalL1TriggerObjectsRcd>();
0089     } else if (objectName == "ElectronicsMap") {
0090       setWhatProduced(this, &HcalTextCalibrations::produceElectronicsMap);
0091       findingRecord<HcalElectronicsMapRcd>();
0092     } else if (objectName == "FrontEndMap") {
0093       setWhatProduced(this, &HcalTextCalibrations::produceFrontEndMap);
0094       findingRecord<HcalFrontEndMapRcd>();
0095     } else if (objectName == "ValidationCorrs") {
0096       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::produceValidationCorrs).consumes();
0097       findingRecord<HcalValidationCorrsRcd>();
0098     } else if (objectName == "LutMetadata") {
0099       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::produceLutMetadata).consumes();
0100       findingRecord<HcalLutMetadataRcd>();
0101     } else if (objectName == "DcsValues") {
0102       setWhatProduced(this, &HcalTextCalibrations::produceDcsValues);
0103       findingRecord<HcalDcsRcd>();
0104     } else if (objectName == "DcsMap") {
0105       setWhatProduced(this, &HcalTextCalibrations::produceDcsMap);
0106       findingRecord<HcalDcsMapRcd>();
0107     } else if (objectName == "RecoParams") {
0108       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::produceRecoParams).consumes();
0109       findingRecord<HcalRecoParamsRcd>();
0110     } else if (objectName == "TimingParams") {
0111       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::produceTimingParams).consumes();
0112       findingRecord<HcalTimingParamsRcd>();
0113     } else if (objectName == "LongRecoParams") {
0114       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::produceLongRecoParams).consumes();
0115       findingRecord<HcalLongRecoParamsRcd>();
0116     } else if (objectName == "ZDCLowGainFractions") {
0117       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::produceZDCLowGainFractions).consumes();
0118       findingRecord<HcalZDCLowGainFractionsRcd>();
0119     } else if (objectName == "MCParams") {
0120       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::produceMCParams).consumes();
0121       findingRecord<HcalMCParamsRcd>();
0122     } else if (objectName == "FlagHFDigiTimeParams") {
0123       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::produceFlagHFDigiTimeParams).consumes();
0124       findingRecord<HcalFlagHFDigiTimeParamsRcd>();
0125     } else if (objectName == "SiPMParameters") {
0126       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::produceSiPMParameters).consumes();
0127       findingRecord<HcalSiPMParametersRcd>();
0128     } else if (objectName == "SiPMCharacteristics") {
0129       setWhatProduced(this, &HcalTextCalibrations::produceSiPMCharacteristics);
0130       findingRecord<HcalSiPMCharacteristicsRcd>();
0131     } else if (objectName == "TPChannelParameters") {
0132       mTokens[objectName] = setWhatProduced(this, &HcalTextCalibrations::produceTPChannelParameters).consumes();
0133       findingRecord<HcalTPChannelParametersRcd>();
0134     } else if (objectName == "TPParameters") {
0135       setWhatProduced(this, &HcalTextCalibrations::produceTPParameters);
0136       findingRecord<HcalTPParametersRcd>();
0137     } else {
0138       std::cerr << "HcalTextCalibrations-> Unknown object name '" << objectName << "', known names are: "
0139                 << "Pedestals PedestalWidths Gains GainWidths PFCuts QIEData QIETypes ChannelQuality ElectronicsMap "
0140                 << "FrontEndMap ZSThresholds RespCorrs LUTCorrs PFCorrs TimeCorrs L1TriggerObjects "
0141                 << "ValidationCorrs LutMetadata DcsValues DcsMap "
0142                 << "RecoParams LongRecoParams ZDCLowGainFraction FlagHFDigiTimeParams MCParams "
0143                 << "SiPMParameters SiPMCharacteristics TPChannelParameters TPParameters" << std::endl;
0144     }
0145   }
0146   //  setWhatProduced(this);
0147 }
0148
0149 HcalTextCalibrations::~HcalTextCalibrations() {}
0150
0151 //
0152 // member functions
0153 //
0154 void HcalTextCalibrations::setIntervalFor(const edm::eventsetup::EventSetupRecordKey& iKey,
0155                                           const edm::IOVSyncValue& iTime,
0156                                           edm::ValidityInterval& oInterval) {
0157   std::string record = iKey.name();
0158   oInterval = edm::ValidityInterval(edm::IOVSyncValue::beginOfTime(), edm::IOVSyncValue::endOfTime());  //infinite
0159 }
0160 namespace {
0161   template <class T, template <class> class F>
0162   std::unique_ptr<T> produce_impl(const std::string& fFile, const HcalTopology* topo = nullptr) {
0163     std::ifstream inStream(fFile.c_str());
0164     if (!inStream.good()) {
0165       std::cerr << "HcalTextCalibrations-> Unable to open file '" << fFile << "'" << std::endl;
0166       throw cms::Exception("FileNotFound") << "Unable to open '" << fFile << "'" << std::endl;
0167     }
0168     auto result = F<T>(topo)(inStream);
0169     if (!result) {
0170       std::cerr << "HcalTextCalibrations-> Can not read object from file '" << fFile << "'" << std::endl;
0171       throw cms::Exception("ReadError") << "Can not read object from file '" << fFile << "'" << std::endl;
0172     }
0173     return result;
0174   }
0175   template <class T>
0176   std::unique_ptr<T> get_impl(const std::string& fFile) {
0177     return produce_impl<T, HcalTextCalibrations::CheckGetObject>(fFile);
0178   }
0179   template <class T>
0180   std::unique_ptr<T> get_impl_topo(const std::string& fFile, const HcalTopology* topo) {
0181     return produce_impl<T, HcalTextCalibrations::CheckGetObjectTopo>(fFile, topo);
0182   }
0183   template <class T>
0184   std::unique_ptr<T> create_impl(const std::string& fFile) {
0185     return produce_impl<T, HcalTextCalibrations::CheckCreateObject>(fFile);
0186   }
0187 }  // namespace
0188
0189 std::unique_ptr<HcalPedestals> HcalTextCalibrations::producePedestals(const HcalPedestalsRcd& rcd) {
0190   std::string const n = "Pedestals";
0191   return get_impl_topo<HcalPedestals>(mInputs[n], &rcd.get(mTokens[n]));
0192 }
0193
0194 std::unique_ptr<HcalPedestalWidths> HcalTextCalibrations::producePedestalWidths(const HcalPedestalWidthsRcd& rcd) {
0195   std::string const n = "PedestalWidths";
0196   return get_impl_topo<HcalPedestalWidths>(mInputs[n], &rcd.get(mTokens[n]));
0197 }
0198
0199 std::unique_ptr<HcalPedestals> HcalTextCalibrations::produceEffectivePedestals(const HcalPedestalsRcd& rcd) {
0200   std::string const n = "EffectivePedestals";
0201   return get_impl_topo<HcalPedestals>(mInputs[n], &rcd.get(mTokens[n]));
0202 }
0203
0204 std::unique_ptr<HcalPedestalWidths> HcalTextCalibrations::produceEffectivePedestalWidths(
0205     const HcalPedestalWidthsRcd& rcd) {
0206   std::string const n = "EffectivePedestalWidths";
0207   return get_impl_topo<HcalPedestalWidths>(mInputs[n], &rcd.get(mTokens[n]));
0208 }
0209
0210 std::unique_ptr<HcalGains> HcalTextCalibrations::produceGains(const HcalGainsRcd& rcd) {
0211   std::string const n = "Gains";
0212   return get_impl_topo<HcalGains>(mInputs[n], &rcd.get(mTokens[n]));
0213 }
0214
0215 std::unique_ptr<HcalGainWidths> HcalTextCalibrations::produceGainWidths(const HcalGainWidthsRcd& rcd) {
0216   std::string const n = "GainWidths";
0217   return get_impl_topo<HcalGainWidths>(mInputs[n], &rcd.get(mTokens[n]));
0218 }
0219
0220 std::unique_ptr<HcalPFCuts> HcalTextCalibrations::producePFCuts(const HcalPFCutsRcd& rcd) {
0221   std::string const n = "PFCuts";
0222   return get_impl_topo<HcalPFCuts>(mInputs[n], &rcd.get(mTokens[n]));
0223 }
0224
0225 std::unique_ptr<HcalQIEData> HcalTextCalibrations::produceQIEData(const HcalQIEDataRcd& rcd) {
0226   std::string const n = "QIEData";
0227   return get_impl_topo<HcalQIEData>(mInputs[n], &rcd.get(mTokens[n]));
0228 }
0229
0230 std::unique_ptr<HcalQIETypes> HcalTextCalibrations::produceQIETypes(const HcalQIETypesRcd& rcd) {
0231   std::string const n = "QIETypes";
0232   return get_impl_topo<HcalQIETypes>(mInputs[n], &rcd.get(mTokens[n]));
0233 }
0234
0235 std::unique_ptr<HcalChannelQuality> HcalTextCalibrations::produceChannelQuality(const HcalChannelQualityRcd& rcd) {
0236   std::string const n = "ChannelQuality";
0237   return get_impl_topo<HcalChannelQuality>(mInputs[n], &rcd.get(mTokens[n]));
0238 }
0239
0240 std::unique_ptr<HcalZSThresholds> HcalTextCalibrations::produceZSThresholds(const HcalZSThresholdsRcd& rcd) {
0241   std::string const n = "ZSThresholds";
0242   return get_impl_topo<HcalZSThresholds>(mInputs[n], &rcd.get(mTokens[n]));
0243 }
0244
0245 std::unique_ptr<HcalRespCorrs> HcalTextCalibrations::produceRespCorrs(const HcalRespCorrsRcd& rcd) {
0246   std::string const n = "RespCorrs";
0247   return get_impl_topo<HcalRespCorrs>(mInputs[n], &rcd.get(mTokens[n]));
0248 }
0249
0250 std::unique_ptr<HcalLUTCorrs> HcalTextCalibrations::produceLUTCorrs(const HcalLUTCorrsRcd& rcd) {
0251   std::string const n = "LUTCorrs";
0252   return get_impl_topo<HcalLUTCorrs>(mInputs[n], &rcd.get(mTokens[n]));
0253 }
0254
0255 std::unique_ptr<HcalPFCorrs> HcalTextCalibrations::producePFCorrs(const HcalPFCorrsRcd& rcd) {
0256   std::string const n = "PFCorrs";
0257   return get_impl_topo<HcalPFCorrs>(mInputs[n], &rcd.get(mTokens[n]));
0258 }
0259
0260 std::unique_ptr<HcalTimeCorrs> HcalTextCalibrations::produceTimeCorrs(const HcalTimeCorrsRcd& rcd) {
0261   std::string const n = "TimeCorrs";
0262   return get_impl_topo<HcalTimeCorrs>(mInputs[n], &rcd.get(mTokens[n]));
0263 }
0264
0265 std::unique_ptr<HcalL1TriggerObjects> HcalTextCalibrations::produceL1TriggerObjects(const HcalL1TriggerObjectsRcd& rcd) {
0266   std::string const n = "L1TriggerObjects";
0267   return get_impl_topo<HcalL1TriggerObjects>(mInputs[n], &rcd.get(mTokens[n]));
0268 }
0269
0270 std::unique_ptr<HcalElectronicsMap> HcalTextCalibrations::produceElectronicsMap(const HcalElectronicsMapRcd& rcd) {
0271   return create_impl<HcalElectronicsMap>(mInputs["ElectronicsMap"]);
0272 }
0273
0274 std::unique_ptr<HcalFrontEndMap> HcalTextCalibrations::produceFrontEndMap(const HcalFrontEndMapRcd& rcd) {
0275   return create_impl<HcalFrontEndMap>(mInputs["FrontEndMap"]);
0276 }
0277
0278 std::unique_ptr<HcalValidationCorrs> HcalTextCalibrations::produceValidationCorrs(const HcalValidationCorrsRcd& rcd) {
0279   std::string const n = "ValidationCorrs";
0280   return get_impl_topo<HcalValidationCorrs>(mInputs[n], &rcd.get(mTokens[n]));
0281 }
0282
0283 std::unique_ptr<HcalLutMetadata> HcalTextCalibrations::produceLutMetadata(const HcalLutMetadataRcd& rcd) {
0284   std::string const n = "LutMetadata";
0285   return get_impl_topo<HcalLutMetadata>(mInputs[n], &rcd.get(mTokens[n]));
0286 }
0287
0288 std::unique_ptr<HcalDcsValues> HcalTextCalibrations::produceDcsValues(HcalDcsRcd const& rcd) {
0289   return get_impl<HcalDcsValues>(mInputs["DcsValues"]);
0290 }
0291
0292 std::unique_ptr<HcalDcsMap> HcalTextCalibrations::produceDcsMap(const HcalDcsMapRcd& rcd) {
0293   return create_impl<HcalDcsMap>(mInputs["DcsMap"]);
0294 }
0295
0296 std::unique_ptr<HcalRecoParams> HcalTextCalibrations::produceRecoParams(const HcalRecoParamsRcd& rcd) {
0297   std::string const n = "RecoParams";
0298   return get_impl_topo<HcalRecoParams>(mInputs[n], &rcd.get(mTokens[n]));
0299 }
0300
0301 std::unique_ptr<HcalLongRecoParams> HcalTextCalibrations::produceLongRecoParams(const HcalLongRecoParamsRcd& rcd) {
0302   std::string const n = "LongRecoParams";
0303   return get_impl_topo<HcalLongRecoParams>(mInputs[n], &rcd.get(mTokens[n]));
0304 }
0305
0306 std::unique_ptr<HcalZDCLowGainFractions> HcalTextCalibrations::produceZDCLowGainFractions(
0307     const HcalZDCLowGainFractionsRcd& rcd) {
0308   std::string const n = "ZDCLowGainFractions";
0309   return get_impl_topo<HcalZDCLowGainFractions>(mInputs[n], &rcd.get(mTokens[n]));
0310 }
0311
0312 std::unique_ptr<HcalTimingParams> HcalTextCalibrations::produceTimingParams(const HcalTimingParamsRcd& rcd) {
0313   std::string const n = "TimingParams";
0314   return get_impl_topo<HcalTimingParams>(mInputs[n], &rcd.get(mTokens[n]));
0315 }
0316 std::unique_ptr<HcalMCParams> HcalTextCalibrations::produceMCParams(const HcalMCParamsRcd& rcd) {
0317   std::string const n = "MCParams";
0318   return get_impl_topo<HcalMCParams>(mInputs[n], &rcd.get(mTokens[n]));
0319 }
0320
0321 std::unique_ptr<HcalFlagHFDigiTimeParams> HcalTextCalibrations::produceFlagHFDigiTimeParams(
0322     const HcalFlagHFDigiTimeParamsRcd& rcd) {
0323   std::string const n = "FlagHFDigiTimeParams";
0324   return get_impl_topo<HcalFlagHFDigiTimeParams>(mInputs[n], &rcd.get(mTokens[n]));
0325 }
0326
0327 std::unique_ptr<HcalSiPMParameters> HcalTextCalibrations::produceSiPMParameters(const HcalSiPMParametersRcd& rcd) {
0328   std::string const n = "SiPMParameters";
0329   return get_impl_topo<HcalSiPMParameters>(mInputs[n], &rcd.get(mTokens[n]));
0330 }
0331
0332 std::unique_ptr<HcalSiPMCharacteristics> HcalTextCalibrations::produceSiPMCharacteristics(
0333     const HcalSiPMCharacteristicsRcd& rcd) {
0334   return create_impl<HcalSiPMCharacteristics>(mInputs["SiPMCharacteristics"]);
0335 }
0336
0337 std::unique_ptr<HcalTPChannelParameters> HcalTextCalibrations::produceTPChannelParameters(
0338     const HcalTPChannelParametersRcd& rcd) {
0339   std::string const n = "TPChannelParameters";
0340   return get_impl_topo<HcalTPChannelParameters>(mInputs[n], &rcd.get(mTokens[n]));
0341 }
0342
0343 std::unique_ptr<HcalTPParameters> HcalTextCalibrations::produceTPParameters(const HcalTPParametersRcd& rcd) {
0344   return get_impl<HcalTPParameters>(mInputs["TPParameters"]);
0345 }