File indexing completed on 2021-02-14 12:47:09
0001
0002
0003
0004
0005 #include <fstream>
0006 #include <iostream>
0007 #include <memory>
0008
0009 #include "TRandom3.h"
0010
0011 #include "CalibCalorimetry/EcalTrivialCondModules/interface/EcalTrivialConditionRetriever.h"
0012 #include "SimG4CMS/Calo/interface/EnergyResolutionVsLumi.h"
0013 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0014 #include "FWCore/Utilities/interface/Exception.h"
0015
0016 #include "DataFormats/EcalDetId/interface/EBDetId.h"
0017 #include "DataFormats/EcalDetId/interface/EEDetId.h"
0018 #include "DataFormats/EcalDetId/interface/ESDetId.h"
0019 #include "DataFormats/EcalDetId/interface/EcalElectronicsId.h"
0020 #include "DataFormats/EcalDetId/interface/EcalTriggerElectronicsId.h"
0021 #include "DataFormats/EcalDetId/interface/EcalSubdetector.h"
0022
0023
0024
0025 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0026 #include "CondTools/Ecal/interface/EcalIntercalibConstantsXMLTranslator.h"
0027 #include "CondTools/Ecal/interface/EcalIntercalibConstantsMCXMLTranslator.h"
0028
0029 using namespace edm;
0030
0031 EcalTrivialConditionRetriever::EcalTrivialConditionRetriever(const edm::ParameterSet& ps) {
0032 std::string dataPath_ =
0033 ps.getUntrackedParameter<std::string>("dataPath", "CalibCalorimetry/EcalTrivialCondModules/data/");
0034
0035
0036
0037
0038
0039
0040
0041
0042
0043
0044
0045
0046
0047
0048
0049
0050
0051
0052 totLumi_ = ps.getUntrackedParameter<double>("TotLumi", 0.0);
0053 instLumi_ = ps.getUntrackedParameter<double>("InstLumi", 0.0);
0054
0055
0056 adcToGeVEBConstant_ = ps.getUntrackedParameter<double>("adcToGeVEBConstant", 0.035);
0057 adcToGeVEEConstant_ = ps.getUntrackedParameter<double>("adcToGeVEEConstant", 0.060);
0058
0059 intercalibConstantMeanMC_ = ps.getUntrackedParameter<double>("intercalibConstantMeanMC", 1.0);
0060 intercalibConstantSigmaMC_ = ps.getUntrackedParameter<double>("intercalibConstantSigmaMC", 0.0);
0061
0062 linCorrMean_ = ps.getUntrackedParameter<double>("linCorrMean", 1.0);
0063 linCorrSigma_ = ps.getUntrackedParameter<double>("linCorrSigma", 0.0);
0064
0065 linearTime1_ = (unsigned long)atoi(ps.getUntrackedParameter<std::string>("linearTime1", "1").c_str());
0066 linearTime2_ = (unsigned long)atoi(ps.getUntrackedParameter<std::string>("linearTime2", "0").c_str());
0067 linearTime3_ = (unsigned long)atoi(ps.getUntrackedParameter<std::string>("linearTime3", "0").c_str());
0068
0069 intercalibConstantMean_ = ps.getUntrackedParameter<double>("intercalibConstantMean", 1.0);
0070 intercalibConstantSigma_ = ps.getUntrackedParameter<double>("intercalibConstantSigma", 0.0);
0071 intercalibErrorMean_ = ps.getUntrackedParameter<double>("IntercalibErrorMean", 0.0);
0072
0073 timeCalibConstantMean_ = ps.getUntrackedParameter<double>("timeCalibConstantMean", 0.0);
0074 timeCalibConstantSigma_ = ps.getUntrackedParameter<double>("timeCalibConstantSigma", 0.0);
0075 timeCalibErrorMean_ = ps.getUntrackedParameter<double>("timeCalibErrorMean", 0.0);
0076
0077 timeOffsetEBConstant_ = ps.getUntrackedParameter<double>("timeOffsetEBConstant", 0.0);
0078 timeOffsetEEConstant_ = ps.getUntrackedParameter<double>("timeOffsetEEConstant", 0.0);
0079
0080 laserAlphaMean_ = ps.getUntrackedParameter<double>("laserAlphaMean", 1.55);
0081 laserAlphaSigma_ = ps.getUntrackedParameter<double>("laserAlphaSigma", 0);
0082
0083 laserAPDPNTime1_ = (unsigned long)atoi(ps.getUntrackedParameter<std::string>("laserAPDPNTime1", "1").c_str());
0084 laserAPDPNTime2_ = (unsigned long)atoi(ps.getUntrackedParameter<std::string>("laserAPDPNTime2", "0").c_str());
0085 laserAPDPNTime3_ = (unsigned long)atoi(ps.getUntrackedParameter<std::string>("laserAPDPNTime3", "0").c_str());
0086
0087 laserAPDPNRefMean_ = ps.getUntrackedParameter<double>("laserAPDPNRefMean", 1.0);
0088 laserAPDPNRefSigma_ = ps.getUntrackedParameter<double>("laserAPDPNRefSigma", 0.0);
0089
0090 laserAPDPNMean_ = ps.getUntrackedParameter<double>("laserAPDPNMean", 1.0);
0091 laserAPDPNSigma_ = ps.getUntrackedParameter<double>("laserAPDPNSigma", 0.0);
0092
0093 pfRecHitThresholdsNSigmas_ = ps.getUntrackedParameter<double>("EcalPFRecHitThresholdNSigmas", 1.0);
0094 pfRecHitThresholdsNSigmasHEta_ = ps.getUntrackedParameter<double>("EcalPFRecHitThresholdNSigmasHEta", 1.0);
0095 pfRecHitThresholdsEB_ = ps.getUntrackedParameter<double>("EcalPFRecHitThresholdEB", 0.0);
0096 pfRecHitThresholdsEE_ = ps.getUntrackedParameter<double>("EcalPFRecHitThresholdEE", 0.0);
0097
0098 localContCorrParameters_ =
0099 ps.getUntrackedParameter<std::vector<double> >("localContCorrParameters", std::vector<double>(0));
0100 crackCorrParameters_ = ps.getUntrackedParameter<std::vector<double> >("crackCorrParameters", std::vector<double>(0));
0101 energyCorrectionParameters_ =
0102 ps.getUntrackedParameter<std::vector<double> >("energyCorrectionParameters", std::vector<double>(0));
0103 energyUncertaintyParameters_ =
0104 ps.getUntrackedParameter<std::vector<double> >("energyUncertaintyParameters", std::vector<double>(0));
0105 energyCorrectionObjectSpecificParameters_ = ps.getUntrackedParameter<std::vector<double> >(
0106 "energyCorrectionObjectSpecificParameters", std::vector<double>(0));
0107
0108 EBpedMeanX12_ = ps.getUntrackedParameter<double>("EBpedMeanX12", 200.);
0109 EBpedRMSX12_ = ps.getUntrackedParameter<double>("EBpedRMSX12", 1.10);
0110 EBpedMeanX6_ = ps.getUntrackedParameter<double>("EBpedMeanX6", 200.);
0111 EBpedRMSX6_ = ps.getUntrackedParameter<double>("EBpedRMSX6", 0.90);
0112 EBpedMeanX1_ = ps.getUntrackedParameter<double>("EBpedMeanX1", 200.);
0113 EBpedRMSX1_ = ps.getUntrackedParameter<double>("EBpedRMSX1", 0.62);
0114
0115 EEpedMeanX12_ = ps.getUntrackedParameter<double>("EEpedMeanX12", 200.);
0116 EEpedRMSX12_ = ps.getUntrackedParameter<double>("EEpedRMSX12", 2.50);
0117 EEpedMeanX6_ = ps.getUntrackedParameter<double>("EEpedMeanX6", 200.);
0118 EEpedRMSX6_ = ps.getUntrackedParameter<double>("EEpedRMSX6", 2.00);
0119 EEpedMeanX1_ = ps.getUntrackedParameter<double>("EEpedMeanX1", 200.);
0120 EEpedRMSX1_ = ps.getUntrackedParameter<double>("EEpedRMSX1", 1.40);
0121
0122 gainRatio12over6_ = ps.getUntrackedParameter<double>("gainRatio12over6", 2.0);
0123 gainRatio6over1_ = ps.getUntrackedParameter<double>("gainRatio6over1", 6.0);
0124
0125 getWeightsFromFile_ = ps.getUntrackedParameter<bool>("getWeightsFromFile", false);
0126
0127 sampleMaskEB_ = ps.getUntrackedParameter<unsigned int>("sampleMaskEB", 1023);
0128 sampleMaskEE_ = ps.getUntrackedParameter<unsigned int>("sampleMaskEB", 1023);
0129
0130 EBtimeCorrAmplitudeBins_ =
0131 ps.getUntrackedParameter<std::vector<double> >("EBtimeCorrAmplitudeBins", std::vector<double>());
0132 EBtimeCorrShiftBins_ = ps.getUntrackedParameter<std::vector<double> >("EBtimeCorrShiftBins", std::vector<double>());
0133 EEtimeCorrAmplitudeBins_ =
0134 ps.getUntrackedParameter<std::vector<double> >("EEtimeCorrAmplitudeBins", std::vector<double>());
0135 EEtimeCorrShiftBins_ = ps.getUntrackedParameter<std::vector<double> >("EEtimeCorrShiftBins", std::vector<double>());
0136
0137 EBG12samplesCorrelation_ =
0138 ps.getUntrackedParameter<std::vector<double> >("EBG12samplesCorrelation", std::vector<double>());
0139 EBG6samplesCorrelation_ =
0140 ps.getUntrackedParameter<std::vector<double> >("EBG6samplesCorrelation", std::vector<double>());
0141 EBG1samplesCorrelation_ =
0142 ps.getUntrackedParameter<std::vector<double> >("EBG1samplesCorrelation", std::vector<double>());
0143 EEG12samplesCorrelation_ =
0144 ps.getUntrackedParameter<std::vector<double> >("EEG12samplesCorrelation", std::vector<double>());
0145 EEG6samplesCorrelation_ =
0146 ps.getUntrackedParameter<std::vector<double> >("EEG6samplesCorrelation", std::vector<double>());
0147 EEG1samplesCorrelation_ =
0148 ps.getUntrackedParameter<std::vector<double> >("EEG1samplesCorrelation", std::vector<double>());
0149
0150 sim_pulse_shape_EB_thresh_ = ps.getParameter<double>("sim_pulse_shape_EB_thresh");
0151 sim_pulse_shape_EE_thresh_ = ps.getParameter<double>("sim_pulse_shape_EE_thresh");
0152 sim_pulse_shape_APD_thresh_ = ps.getParameter<double>("sim_pulse_shape_APD_thresh");
0153
0154 sim_pulse_shape_TI_ = ps.getUntrackedParameter<double>("sim_pulse_shape_TI", 1.0);
0155
0156 nTDCbins_ = 1;
0157
0158 weightsForAsynchronousRunning_ = ps.getUntrackedParameter<bool>("weightsForTB", false);
0159
0160 edm::LogInfo(" EcalTrivialConditionRetriever ");
0161
0162 if (totLumi_ > 0) {
0163 edm::LogInfo(" EcalTrivialConditionRetriever going to create conditions based on the damage due to ")
0164 << totLumi_ << " fb-1 integrated luminosity";
0165 }
0166
0167 if (weightsForAsynchronousRunning_) {
0168 getWeightsFromFile_ = true;
0169
0170 nTDCbins_ = 50;
0171 }
0172
0173 std::string weightType;
0174 std::ostringstream str;
0175
0176 if (!weightsForAsynchronousRunning_)
0177 str << "_CMS.txt";
0178 else
0179 str << "_TB.txt";
0180
0181 weightType = str.str();
0182
0183 amplWeightsFile_ = ps.getUntrackedParameter<std::string>("amplWeightsFile", dataPath_ + "ampWeights" + weightType);
0184 amplWeightsAftFile_ =
0185 ps.getUntrackedParameter<std::string>("amplWeightsAftFile", dataPath_ + "ampWeightsAfterGainSwitch" + weightType);
0186 pedWeightsFile_ = ps.getUntrackedParameter<std::string>("pedWeightsFile", dataPath_ + "pedWeights" + weightType);
0187 pedWeightsAftFile_ =
0188 ps.getUntrackedParameter<std::string>("pedWeightsAftFile", dataPath_ + "pedWeightsAfterGainSwitch" + weightType);
0189 jittWeightsFile_ = ps.getUntrackedParameter<std::string>("jittWeightsFile", dataPath_ + "timeWeights" + weightType);
0190 jittWeightsAftFile_ = ps.getUntrackedParameter<std::string>("jittWeightsAftFile",
0191 dataPath_ + "timeWeightsAfterGainSwitch" + weightType);
0192 chi2MatrixFile_ = ps.getUntrackedParameter<std::string>("chi2MatrixFile", dataPath_ + "chi2Matrix" + weightType);
0193 chi2MatrixAftFile_ =
0194 ps.getUntrackedParameter<std::string>("chi2MatrixAftFile", dataPath_ + "chi2MatrixAfterGainSwitch" + weightType);
0195
0196 amplWeights_.resize(nTDCbins_);
0197 amplWeightsAft_.resize(nTDCbins_);
0198 pedWeights_.resize(nTDCbins_);
0199 pedWeightsAft_.resize(nTDCbins_);
0200 jittWeights_.resize(nTDCbins_);
0201 jittWeightsAft_.resize(nTDCbins_);
0202 chi2Matrix_.resize(nTDCbins_);
0203 chi2MatrixAft_.resize(nTDCbins_);
0204
0205
0206 getWeightsFromConfiguration(ps);
0207
0208 producedEcalPedestals_ = ps.getUntrackedParameter<bool>("producedEcalPedestals", true);
0209 producedEcalWeights_ = ps.getUntrackedParameter<bool>("producedEcalWeights", true);
0210
0211 producedEcalGainRatios_ = ps.getUntrackedParameter<bool>("producedEcalGainRatios", true);
0212 producedEcalADCToGeVConstant_ = ps.getUntrackedParameter<bool>("producedEcalADCToGeVConstant", true);
0213
0214 producedEcalMappingElectronics_ = ps.getUntrackedParameter<bool>("producedEcalMappingElectronics", true);
0215 mappingFile_ = ps.getUntrackedParameter<std::string>("mappingFile", "");
0216
0217 if (producedEcalMappingElectronics_) {
0218 if (!mappingFile_.empty()) {
0219 setWhatProduced(this, &EcalTrivialConditionRetriever::getMappingFromConfiguration);
0220 } else {
0221 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalMappingElectronics);
0222 }
0223 findingRecord<EcalMappingElectronicsRcd>();
0224 }
0225
0226 getEBAlignmentFromFile_ = ps.getUntrackedParameter<bool>("getEBAlignmentFromFile", false);
0227 if (getEBAlignmentFromFile_) {
0228 EBAlignmentFile_ = ps.getUntrackedParameter<std::string>("EBAlignmentFile", dataPath_ + "EBAlignment.txt");
0229 }
0230
0231 getEEAlignmentFromFile_ = ps.getUntrackedParameter<bool>("getEEAlignmentFromFile", false);
0232 if (getEEAlignmentFromFile_) {
0233 EEAlignmentFile_ = ps.getUntrackedParameter<std::string>("EEAlignmentFile", dataPath_ + "EEAlignment.txt");
0234 }
0235
0236 getESAlignmentFromFile_ = ps.getUntrackedParameter<bool>("getESAlignmentFromFile", false);
0237 if (getESAlignmentFromFile_)
0238 ESAlignmentFile_ = ps.getUntrackedParameter<std::string>("ESAlignmentFile", dataPath_ + "ESAlignment.txt");
0239
0240 verbose_ = ps.getUntrackedParameter<int>("verbose", 0);
0241
0242
0243
0244 if (producedEcalPedestals_)
0245 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalPedestals);
0246
0247 if (producedEcalWeights_) {
0248 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalWeightXtalGroups);
0249 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalTBWeights);
0250 }
0251
0252 if (producedEcalGainRatios_)
0253 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalGainRatios);
0254
0255 if (producedEcalADCToGeVConstant_)
0256 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalADCToGeVConstant);
0257
0258
0259 producedEcalTimeOffsetConstant_ = ps.getUntrackedParameter<bool>("producedEcalTimeOffsetConstant", true);
0260
0261 if (producedEcalTimeOffsetConstant_) {
0262 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalTimeOffsetConstant);
0263 findingRecord<EcalTimeOffsetConstantRcd>();
0264 }
0265
0266
0267 producedEcalLinearCorrections_ = ps.getUntrackedParameter<bool>("producedEcalLinearCorrections", true);
0268 linearCorrectionsFile_ = ps.getUntrackedParameter<std::string>("linearCorrectionsFile", "");
0269
0270 if (producedEcalLinearCorrections_) {
0271 if (!linearCorrectionsFile_.empty()) {
0272 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalLinearCorrections);
0273 } else {
0274 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalLinearCorrections);
0275 }
0276 findingRecord<EcalLinearCorrectionsRcd>();
0277 }
0278
0279
0280 producedEcalIntercalibConstants_ = ps.getUntrackedParameter<bool>("producedEcalIntercalibConstants", true);
0281 intercalibConstantsFile_ = ps.getUntrackedParameter<std::string>("intercalibConstantsFile", "");
0282
0283 intercalibConstantsMCFile_ = ps.getUntrackedParameter<std::string>("intercalibConstantsMCFile", "");
0284
0285 if (producedEcalIntercalibConstants_) {
0286 if (!intercalibConstantsFile_.empty()) {
0287 setWhatProduced(this, &EcalTrivialConditionRetriever::getIntercalibConstantsFromConfiguration);
0288 } else {
0289 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalIntercalibConstants);
0290 }
0291 findingRecord<EcalIntercalibConstantsRcd>();
0292 }
0293
0294 producedEcalIntercalibConstantsMC_ = ps.getUntrackedParameter<bool>("producedEcalIntercalibConstantsMC", true);
0295
0296 if (producedEcalIntercalibConstantsMC_) {
0297 if (!intercalibConstantsMCFile_.empty()) {
0298 setWhatProduced(this, &EcalTrivialConditionRetriever::getIntercalibConstantsMCFromConfiguration);
0299 } else {
0300 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalIntercalibConstantsMC);
0301 }
0302 findingRecord<EcalIntercalibConstantsMCRcd>();
0303 }
0304
0305
0306 producedEcalIntercalibErrors_ = ps.getUntrackedParameter<bool>("producedEcalIntercalibErrors", true);
0307 intercalibErrorsFile_ = ps.getUntrackedParameter<std::string>("intercalibErrorsFile", "");
0308
0309 if (producedEcalIntercalibErrors_) {
0310 if (!intercalibErrorsFile_.empty()) {
0311 setWhatProduced(this, &EcalTrivialConditionRetriever::getIntercalibErrorsFromConfiguration);
0312 } else {
0313 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalIntercalibErrors);
0314 }
0315 findingRecord<EcalIntercalibErrorsRcd>();
0316 }
0317
0318
0319 producedEcalTimeCalibConstants_ = ps.getUntrackedParameter<bool>("producedEcalTimeCalibConstants", true);
0320 timeCalibConstantsFile_ = ps.getUntrackedParameter<std::string>("timeCalibConstantsFile", "");
0321
0322 if (producedEcalTimeCalibConstants_) {
0323 if (!timeCalibConstantsFile_.empty()) {
0324 setWhatProduced(this, &EcalTrivialConditionRetriever::getTimeCalibConstantsFromConfiguration);
0325 } else {
0326 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalTimeCalibConstants);
0327 }
0328 findingRecord<EcalTimeCalibConstantsRcd>();
0329 }
0330
0331
0332 producedEcalTimeCalibErrors_ = ps.getUntrackedParameter<bool>("producedEcalTimeCalibErrors", true);
0333 timeCalibErrorsFile_ = ps.getUntrackedParameter<std::string>("timeCalibErrorsFile", "");
0334
0335 if (producedEcalTimeCalibErrors_) {
0336 if (!timeCalibErrorsFile_.empty()) {
0337 setWhatProduced(this, &EcalTrivialConditionRetriever::getTimeCalibErrorsFromConfiguration);
0338 } else {
0339 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalTimeCalibErrors);
0340 }
0341 findingRecord<EcalTimeCalibErrorsRcd>();
0342 }
0343
0344
0345 getSimPulseShapeFromFile_ = ps.getUntrackedParameter<bool>("getSimPulseShapeFromFile", false);
0346 producedEcalSimPulseShape_ = ps.getUntrackedParameter<bool>("producedEcalSimPulseShape", true);
0347 EBSimPulseShapeFile_ = ps.getUntrackedParameter<std::string>("EBSimPulseShapeFile", "");
0348 EESimPulseShapeFile_ = ps.getUntrackedParameter<std::string>("EESimPulseShapeFile", "");
0349 APDSimPulseShapeFile_ = ps.getUntrackedParameter<std::string>("APDSimPulseShapeFile", "");
0350
0351 if (producedEcalSimPulseShape_) {
0352 setWhatProduced(this, &EcalTrivialConditionRetriever::getEcalSimPulseShapeFromConfiguration);
0353 findingRecord<EcalSimPulseShapeRcd>();
0354 }
0355
0356 producedEcalPFRecHitThresholds_ = ps.getUntrackedParameter<bool>("producedEcalPFRecHitThresholds", false);
0357
0358
0359 pfRecHitFile_ = ps.getUntrackedParameter<std::string>("pFRecHitFile", dataPath_ + "EB_product_TL235.txt");
0360 pfRecHitFileEE_ = ps.getUntrackedParameter<std::string>("pFRecHitFileEE", dataPath_ + "EE_product_TL235.txt");
0361
0362 if (producedEcalPFRecHitThresholds_) {
0363 if (!pfRecHitFile_.empty()) {
0364 setWhatProduced(this, &EcalTrivialConditionRetriever::getPFRecHitThresholdsFromConfiguration);
0365 } else {
0366 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalPFRecHitThresholds);
0367 }
0368 findingRecord<EcalPFRecHitThresholdsRcd>();
0369 }
0370
0371
0372 producedEcalClusterLocalContCorrParameters_ =
0373 ps.getUntrackedParameter<bool>("producedEcalClusterLocalContCorrParameters", false);
0374 producedEcalClusterCrackCorrParameters_ =
0375 ps.getUntrackedParameter<bool>("producedEcalClusterCrackCorrParameters", false);
0376 producedEcalClusterEnergyCorrectionParameters_ =
0377 ps.getUntrackedParameter<bool>("producedEcalClusterEnergyCorrectionParameters", false);
0378 producedEcalClusterEnergyUncertaintyParameters_ =
0379 ps.getUntrackedParameter<bool>("producedEcalClusterEnergyUncertaintyParameters", false);
0380 producedEcalClusterEnergyCorrectionObjectSpecificParameters_ =
0381 ps.getUntrackedParameter<bool>("producedEcalClusterEnergyCorrectionObjectSpecificParameters", false);
0382 if (producedEcalClusterLocalContCorrParameters_) {
0383 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalClusterLocalContCorrParameters);
0384 findingRecord<EcalClusterLocalContCorrParametersRcd>();
0385 }
0386 if (producedEcalClusterCrackCorrParameters_) {
0387 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalClusterCrackCorrParameters);
0388 findingRecord<EcalClusterCrackCorrParametersRcd>();
0389 }
0390 if (producedEcalClusterEnergyCorrectionParameters_) {
0391 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalClusterEnergyCorrectionParameters);
0392 findingRecord<EcalClusterEnergyCorrectionParametersRcd>();
0393 }
0394 if (producedEcalClusterEnergyUncertaintyParameters_) {
0395 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalClusterEnergyUncertaintyParameters);
0396 findingRecord<EcalClusterEnergyUncertaintyParametersRcd>();
0397 }
0398 if (producedEcalClusterEnergyCorrectionObjectSpecificParameters_) {
0399 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalClusterEnergyCorrectionObjectSpecificParameters);
0400 findingRecord<EcalClusterEnergyCorrectionObjectSpecificParametersRcd>();
0401 }
0402
0403
0404 producedEcalLaserCorrection_ = ps.getUntrackedParameter<bool>("producedEcalLaserCorrection", false);
0405 if (producedEcalLaserCorrection_) {
0406
0407 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalLaserAlphas);
0408 findingRecord<EcalLaserAlphasRcd>();
0409 getLaserAlphaFromFileEB_ = ps.getUntrackedParameter<bool>("getLaserAlphaFromFileEB", false);
0410 getLaserAlphaFromFileEE_ = ps.getUntrackedParameter<bool>("getLaserAlphaFromFileEE", false);
0411 getLaserAlphaFromTypeEB_ = ps.getUntrackedParameter<bool>("getLaserAlphaFromTypeEB", false);
0412 getLaserAlphaFromTypeEE_ = ps.getUntrackedParameter<bool>("getLaserAlphaFromTypeEE", false);
0413 edm::LogInfo(" getLaserAlphaFromFileEB_ ") << getLaserAlphaFromFileEB_;
0414 edm::LogInfo(" getLaserAlphaFromFileEE_ ") << getLaserAlphaFromFileEE_;
0415 edm::LogInfo(" getLaserAlphaFromTypeEB_ ") << getLaserAlphaFromTypeEB_;
0416 edm::LogInfo(" getLaserAlphaFromTypeEE_ ") << getLaserAlphaFromTypeEE_;
0417 if (getLaserAlphaFromFileEB_) {
0418 EBLaserAlphaFile_ = ps.getUntrackedParameter<std::string>(
0419 "EBLaserAlphaFile", dataPath_ + "EBLaserAlpha.txt");
0420 }
0421 if (getLaserAlphaFromFileEE_) {
0422 EELaserAlphaFile_ = ps.getUntrackedParameter<std::string>(
0423 "EELaserAlphaFile", dataPath_ + "EELaserAlpha.txt");
0424 }
0425 if (getLaserAlphaFromTypeEB_) {
0426 laserAlphaMeanEBR_ = ps.getUntrackedParameter<double>("laserAlphaMeanEBR", 1.55);
0427 laserAlphaMeanEBC_ = ps.getUntrackedParameter<double>("laserAlphaMeanEBC", 1.00);
0428 EBLaserAlphaFile_ = ps.getUntrackedParameter<std::string>(
0429 "EBLaserAlphaFile", dataPath_ + "EBLaserAlpha.txt");
0430 }
0431 if (getLaserAlphaFromTypeEE_) {
0432 laserAlphaMeanEEC_higheta_ = ps.getUntrackedParameter<double>("laserAlphaMeanEEC_higheta",
0433 1.00);
0434 laserAlphaMeanEER_higheta_ = ps.getUntrackedParameter<double>("laserAlphaMeanEER_higheta",
0435 1.16);
0436 laserAlphaMeanEER_ = ps.getUntrackedParameter<double>("laserAlphaMeanEER", 1.16);
0437 laserAlphaMeanEEC_ = ps.getUntrackedParameter<double>("laserAlphaMeanEEC", 1.00);
0438 EELaserAlphaFile_ = ps.getUntrackedParameter<std::string>(
0439 "EELaserAlphaFile",
0440 dataPath_ + "EELaserAlpha.txt");
0441 EELaserAlphaFile2_ = ps.getUntrackedParameter<std::string>(
0442 "EELaserAlphaFile2", dataPath_ + "EELaserAlpha2.txt");
0443 }
0444 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalLaserAPDPNRatiosRef);
0445 findingRecord<EcalLaserAPDPNRatiosRefRcd>();
0446 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalLaserAPDPNRatios);
0447 findingRecord<EcalLaserAPDPNRatiosRcd>();
0448 }
0449
0450
0451 producedEcalChannelStatus_ = ps.getUntrackedParameter<bool>("producedEcalChannelStatus", true);
0452 channelStatusFile_ = ps.getUntrackedParameter<std::string>("channelStatusFile", "");
0453
0454 if (producedEcalChannelStatus_) {
0455 if (!channelStatusFile_.empty()) {
0456 setWhatProduced(this, &EcalTrivialConditionRetriever::getChannelStatusFromConfiguration);
0457 } else {
0458 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalChannelStatus);
0459 }
0460 findingRecord<EcalChannelStatusRcd>();
0461 }
0462
0463 producedEcalDQMChannelStatus_ = ps.getUntrackedParameter<bool>("producedEcalDQMChannelStatus", true);
0464 if (producedEcalDQMChannelStatus_) {
0465 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalDQMChannelStatus);
0466 findingRecord<EcalDQMChannelStatusRcd>();
0467 }
0468
0469 producedEcalDCSTowerStatus_ = ps.getUntrackedParameter<bool>("producedEcalDCSTowerStatus", true);
0470 if (producedEcalDCSTowerStatus_) {
0471 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalDCSTowerStatus);
0472 findingRecord<EcalDCSTowerStatusRcd>();
0473 }
0474
0475 producedEcalDAQTowerStatus_ = ps.getUntrackedParameter<bool>("producedEcalDAQTowerStatus", true);
0476 if (producedEcalDAQTowerStatus_) {
0477 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalDAQTowerStatus);
0478 findingRecord<EcalDAQTowerStatusRcd>();
0479 }
0480
0481 producedEcalDQMTowerStatus_ = ps.getUntrackedParameter<bool>("producedEcalDQMTowerStatus", true);
0482 if (producedEcalDQMTowerStatus_) {
0483 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalDQMTowerStatus);
0484 findingRecord<EcalDQMTowerStatusRcd>();
0485 }
0486
0487
0488 producedEcalTrgChannelStatus_ = ps.getUntrackedParameter<bool>("producedEcalTrgChannelStatus", true);
0489 trgChannelStatusFile_ = ps.getUntrackedParameter<std::string>("trgChannelStatusFile", "");
0490
0491 if (producedEcalTrgChannelStatus_) {
0492 if (!trgChannelStatusFile_.empty()) {
0493 setWhatProduced(this, &EcalTrivialConditionRetriever::getTrgChannelStatusFromConfiguration);
0494 } else {
0495 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalTrgChannelStatus);
0496 }
0497 findingRecord<EcalTPGCrystalStatusRcd>();
0498 }
0499
0500
0501 producedEcalAlignmentEB_ = ps.getUntrackedParameter<bool>("producedEcalAlignmentEB", true);
0502 if (producedEcalAlignmentEB_) {
0503 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalAlignmentEB);
0504 findingRecord<EBAlignmentRcd>();
0505 }
0506 producedEcalAlignmentEE_ = ps.getUntrackedParameter<bool>("producedEcalAlignmentEE", true);
0507 if (producedEcalAlignmentEE_) {
0508 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalAlignmentEE);
0509 findingRecord<EEAlignmentRcd>();
0510 }
0511 producedEcalAlignmentES_ = ps.getUntrackedParameter<bool>("producedEcalAlignmentES", true);
0512 if (producedEcalAlignmentES_) {
0513 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalAlignmentES);
0514 findingRecord<ESAlignmentRcd>();
0515 }
0516
0517 if (producedEcalPedestals_)
0518 findingRecord<EcalPedestalsRcd>();
0519
0520 if (producedEcalWeights_) {
0521 findingRecord<EcalWeightXtalGroupsRcd>();
0522 findingRecord<EcalTBWeightsRcd>();
0523 }
0524
0525 if (producedEcalGainRatios_)
0526 findingRecord<EcalGainRatiosRcd>();
0527
0528 if (producedEcalADCToGeVConstant_)
0529 findingRecord<EcalADCToGeVConstantRcd>();
0530
0531 producedEcalSampleMask_ = ps.getUntrackedParameter<bool>("producedEcalSampleMask", true);
0532 if (producedEcalSampleMask_) {
0533 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalSampleMask);
0534 findingRecord<EcalSampleMaskRcd>();
0535 }
0536 producedEcalTimeBiasCorrections_ = ps.getUntrackedParameter<bool>("producedEcalTimeBiasCorrections", false);
0537 if (producedEcalTimeBiasCorrections_) {
0538 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalTimeBiasCorrections);
0539 findingRecord<EcalTimeBiasCorrectionsRcd>();
0540 }
0541 producedEcalSamplesCorrelation_ = ps.getUntrackedParameter<bool>("producedEcalSamplesCorrelation", false);
0542 if (producedEcalSamplesCorrelation_) {
0543 setWhatProduced(this, &EcalTrivialConditionRetriever::produceEcalSamplesCorrelation);
0544 findingRecord<EcalSamplesCorrelationRcd>();
0545 getSamplesCorrelationFromFile_ = ps.getUntrackedParameter<bool>("getSamplesCorrelationFromFile", false);
0546 if (getSamplesCorrelationFromFile_) {
0547 SamplesCorrelationFile_ =
0548 ps.getUntrackedParameter<std::string>("SamplesCorrelationFile", "EcalSamplesCorrelation.txt");
0549 }
0550 }
0551 }
0552
0553 EcalTrivialConditionRetriever::~EcalTrivialConditionRetriever() {}
0554
0555
0556
0557
0558 void EcalTrivialConditionRetriever::setIntervalFor(const edm::eventsetup::EventSetupRecordKey& rk,
0559 const edm::IOVSyncValue& iTime,
0560 edm::ValidityInterval& oValidity) {
0561 if (verbose_ >= 1)
0562 edm::LogInfo("EcalTrivialConditionRetriever::setIntervalFor(): record key = ")
0563 << rk.name() << "\ttime: " << iTime.time().value();
0564
0565 oValidity = edm::ValidityInterval(edm::IOVSyncValue::beginOfTime(), edm::IOVSyncValue::endOfTime());
0566 }
0567
0568
0569 std::unique_ptr<EcalPedestals> EcalTrivialConditionRetriever::produceEcalPedestals(const EcalPedestalsRcd&) {
0570 auto peds = std::make_unique<EcalPedestals>();
0571 EcalPedestals::Item EBitem;
0572 EcalPedestals::Item EEitem;
0573
0574 EBitem.mean_x1 = EBpedMeanX1_;
0575 EBitem.rms_x1 = EBpedRMSX1_;
0576 EBitem.mean_x6 = EBpedMeanX6_;
0577 EBitem.rms_x6 = EBpedRMSX6_;
0578 EBitem.mean_x12 = EBpedMeanX12_;
0579 EBitem.rms_x12 = EBpedRMSX12_;
0580
0581 EEitem.mean_x1 = EEpedMeanX1_;
0582 EEitem.rms_x1 = EEpedRMSX1_;
0583 EEitem.mean_x6 = EEpedMeanX6_;
0584 EEitem.rms_x6 = EEpedRMSX6_;
0585 EEitem.mean_x12 = EEpedMeanX12_;
0586 EEitem.rms_x12 = EEpedRMSX12_;
0587
0588 for (int iEta = -EBDetId::MAX_IETA; iEta <= EBDetId::MAX_IETA; ++iEta) {
0589 if (iEta == 0)
0590 continue;
0591
0592 if (totLumi_ > 0) {
0593 double eta = EBDetId::approxEta(EBDetId(iEta, 1));
0594
0595 EnergyResolutionVsLumi ageing;
0596 ageing.setLumi(totLumi_);
0597 ageing.setInstLumi(instLumi_);
0598 eta = fabs(eta);
0599 double noisefactor = ageing.calcnoiseIncreaseADC(eta);
0600
0601 EBitem.rms_x1 = EBpedRMSX1_ * noisefactor;
0602 EBitem.rms_x6 = EBpedRMSX6_ * noisefactor;
0603 EBitem.rms_x12 = EBpedRMSX12_ * noisefactor;
0604 edm::LogInfo("rms ped at eta:") << eta << " =" << EBitem.rms_x12;
0605 }
0606
0607 for (int iPhi = EBDetId::MIN_IPHI; iPhi <= EBDetId::MAX_IPHI; ++iPhi) {
0608
0609 if (EBDetId::validDetId(iEta, iPhi)) {
0610 EBDetId ebdetid(iEta, iPhi);
0611 peds->insert(std::make_pair(ebdetid.rawId(), EBitem));
0612 }
0613 }
0614 }
0615
0616 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
0617 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
0618
0619 if (EEDetId::validDetId(iX, iY, 1)) {
0620 EEDetId eedetidpos(iX, iY, 1);
0621 peds->insert(std::make_pair(eedetidpos.rawId(), EEitem));
0622 }
0623 if (EEDetId::validDetId(iX, iY, -1)) {
0624 EEDetId eedetidneg(iX, iY, -1);
0625 peds->insert(std::make_pair(eedetidneg.rawId(), EEitem));
0626 }
0627 }
0628 }
0629
0630
0631 return peds;
0632 }
0633
0634 std::unique_ptr<EcalWeightXtalGroups> EcalTrivialConditionRetriever::produceEcalWeightXtalGroups(
0635 const EcalWeightXtalGroupsRcd&) {
0636 auto xtalGroups = std::make_unique<EcalWeightXtalGroups>();
0637 EcalXtalGroupId defaultGroupId(1);
0638 for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
0639 if (ieta == 0)
0640 continue;
0641 for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
0642
0643 if (EBDetId::validDetId(ieta, iphi)) {
0644 EBDetId ebid(ieta, iphi);
0645
0646 xtalGroups->setValue(ebid.rawId(), defaultGroupId);
0647 }
0648 }
0649 }
0650
0651 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
0652 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
0653
0654 if (EEDetId::validDetId(iX, iY, 1)) {
0655 EEDetId eedetidpos(iX, iY, 1);
0656 xtalGroups->setValue(eedetidpos.rawId(), defaultGroupId);
0657 }
0658 if (EEDetId::validDetId(iX, iY, -1)) {
0659 EEDetId eedetidneg(iX, iY, -1);
0660 xtalGroups->setValue(eedetidneg.rawId(), defaultGroupId);
0661 }
0662 }
0663 }
0664 return xtalGroups;
0665 }
0666
0667 std::unique_ptr<EcalLinearCorrections> EcalTrivialConditionRetriever::produceEcalLinearCorrections(
0668 const EcalLinearCorrectionsRcd&) {
0669 auto ical = std::make_unique<EcalLinearCorrections>();
0670
0671 for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
0672 if (ieta == 0)
0673 continue;
0674 for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
0675 if (EBDetId::validDetId(ieta, iphi)) {
0676 EBDetId ebid(ieta, iphi);
0677 double r = (double)std::rand() / (double(RAND_MAX) + double(1));
0678
0679 EcalLinearCorrections::Values pairAPDPN;
0680 pairAPDPN.p1 = linCorrMean_ + r * linCorrSigma_;
0681 pairAPDPN.p2 = linCorrMean_ + r * linCorrSigma_;
0682 pairAPDPN.p3 = linCorrMean_ + r * linCorrSigma_;
0683 ical->setValue(ebid, pairAPDPN);
0684 }
0685 }
0686 }
0687
0688 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
0689 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
0690
0691 if (EEDetId::validDetId(iX, iY, 1)) {
0692 double r = (double)std::rand() / (double(RAND_MAX) + double(1));
0693 EEDetId eedetidpos(iX, iY, 1);
0694
0695 EcalLinearCorrections::Values pairAPDPN;
0696 pairAPDPN.p1 = linCorrMean_ + r * linCorrSigma_;
0697 pairAPDPN.p2 = linCorrMean_ + r * linCorrSigma_;
0698 pairAPDPN.p3 = linCorrMean_ + r * linCorrSigma_;
0699
0700 ical->setValue(eedetidpos, pairAPDPN);
0701 }
0702
0703 if (EEDetId::validDetId(iX, iY, -1)) {
0704 double r1 = (double)std::rand() / (double(RAND_MAX) + double(1));
0705 EEDetId eedetidneg(iX, iY, -1);
0706
0707 EcalLinearCorrections::Values pairAPDPN;
0708 pairAPDPN.p1 = linCorrMean_ + r1 * linCorrSigma_;
0709 pairAPDPN.p2 = linCorrMean_ + r1 * linCorrSigma_;
0710 pairAPDPN.p3 = linCorrMean_ + r1 * linCorrSigma_;
0711
0712 ical->setValue(eedetidneg, pairAPDPN);
0713 }
0714 }
0715 }
0716
0717 EcalLinearCorrections::Times TimeStamp;
0718
0719 for (int i = 0; i < 92; i++) {
0720 TimeStamp.t1 = Timestamp(linearTime1_);
0721 if (linearTime2_ == 0) {
0722 TimeStamp.t2 = Timestamp(edm::Timestamp::endOfTime().value());
0723 } else {
0724 TimeStamp.t2 = Timestamp(linearTime2_);
0725 }
0726 if (linearTime3_ == 0) {
0727 TimeStamp.t3 = Timestamp(edm::Timestamp::endOfTime().value());
0728 } else {
0729 TimeStamp.t3 = Timestamp(linearTime3_);
0730 }
0731
0732 ical->setTime(i, TimeStamp);
0733 }
0734
0735 return ical;
0736 }
0737
0738
0739
0740 std::unique_ptr<EcalPFRecHitThresholds> EcalTrivialConditionRetriever::produceEcalPFRecHitThresholds(
0741 const EcalPFRecHitThresholdsRcd&) {
0742 auto ical = std::make_unique<EcalPFRecHitThresholds>();
0743
0744 for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
0745 if (ieta == 0)
0746 continue;
0747 for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
0748
0749 if (EBDetId::validDetId(ieta, iphi)) {
0750 EBDetId ebid(ieta, iphi);
0751 ical->setValue(ebid.rawId(), pfRecHitThresholdsEB_);
0752 }
0753 }
0754 }
0755
0756 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
0757 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
0758
0759 if (EEDetId::validDetId(iX, iY, 1)) {
0760 EEDetId eedetidpos(iX, iY, 1);
0761 ical->setValue(eedetidpos.rawId(), pfRecHitThresholdsEE_);
0762 }
0763 if (EEDetId::validDetId(iX, iY, -1)) {
0764 EEDetId eedetidneg(iX, iY, -1);
0765 ical->setValue(eedetidneg.rawId(), pfRecHitThresholdsEE_);
0766 }
0767 }
0768 }
0769
0770 return ical;
0771 }
0772
0773
0774
0775 std::unique_ptr<EcalIntercalibConstants> EcalTrivialConditionRetriever::produceEcalIntercalibConstants(
0776 const EcalIntercalibConstantsRcd&) {
0777 auto ical = std::make_unique<EcalIntercalibConstants>();
0778
0779 for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
0780 if (ieta == 0)
0781 continue;
0782 for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
0783
0784 if (EBDetId::validDetId(ieta, iphi)) {
0785 EBDetId ebid(ieta, iphi);
0786 double r = (double)std::rand() / (double(RAND_MAX) + double(1));
0787 ical->setValue(ebid.rawId(), intercalibConstantMean_ + r * intercalibConstantSigma_);
0788 }
0789 }
0790 }
0791
0792 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
0793 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
0794
0795 if (EEDetId::validDetId(iX, iY, 1)) {
0796 double r = (double)std::rand() / (double(RAND_MAX) + double(1));
0797 EEDetId eedetidpos(iX, iY, 1);
0798 ical->setValue(eedetidpos.rawId(), intercalibConstantMean_ + r * intercalibConstantSigma_);
0799 }
0800 if (EEDetId::validDetId(iX, iY, -1)) {
0801 double r1 = (double)std::rand() / (double(RAND_MAX) + double(1));
0802 EEDetId eedetidneg(iX, iY, -1);
0803 ical->setValue(eedetidneg.rawId(), intercalibConstantMean_ + r1 * intercalibConstantSigma_);
0804 }
0805 }
0806 }
0807
0808 return ical;
0809 }
0810
0811 std::unique_ptr<EcalIntercalibConstantsMC> EcalTrivialConditionRetriever::produceEcalIntercalibConstantsMC(
0812 const EcalIntercalibConstantsMCRcd&) {
0813 auto ical = std::make_unique<EcalIntercalibConstantsMC>();
0814
0815 for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
0816 if (ieta == 0)
0817 continue;
0818 for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
0819
0820 if (EBDetId::validDetId(ieta, iphi)) {
0821 EBDetId ebid(ieta, iphi);
0822 double r = (double)std::rand() / (double(RAND_MAX) + double(1));
0823 ical->setValue(ebid.rawId(), intercalibConstantMeanMC_ + r * intercalibConstantSigmaMC_);
0824 }
0825 }
0826 }
0827
0828 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
0829 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
0830
0831 if (EEDetId::validDetId(iX, iY, 1)) {
0832 double r = (double)std::rand() / (double(RAND_MAX) + double(1));
0833 EEDetId eedetidpos(iX, iY, 1);
0834 ical->setValue(eedetidpos.rawId(), intercalibConstantMeanMC_ + r * intercalibConstantSigmaMC_);
0835 }
0836 if (EEDetId::validDetId(iX, iY, -1)) {
0837 double r1 = (double)std::rand() / (double(RAND_MAX) + double(1));
0838 EEDetId eedetidneg(iX, iY, -1);
0839 ical->setValue(eedetidneg.rawId(), intercalibConstantMeanMC_ + r1 * intercalibConstantSigmaMC_);
0840 }
0841 }
0842 }
0843
0844 return ical;
0845 }
0846
0847 std::unique_ptr<EcalIntercalibErrors> EcalTrivialConditionRetriever::produceEcalIntercalibErrors(
0848 const EcalIntercalibErrorsRcd&) {
0849 auto ical = std::make_unique<EcalIntercalibErrors>();
0850
0851 for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
0852 if (ieta == 0)
0853 continue;
0854 for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
0855
0856 if (EBDetId::validDetId(ieta, iphi)) {
0857 EBDetId ebid(ieta, iphi);
0858 ical->setValue(ebid.rawId(), intercalibErrorMean_);
0859 }
0860 }
0861 }
0862
0863 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
0864 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
0865
0866 if (EEDetId::validDetId(iX, iY, 1)) {
0867 EEDetId eedetidpos(iX, iY, 1);
0868 ical->setValue(eedetidpos.rawId(), intercalibErrorMean_);
0869 }
0870 if (EEDetId::validDetId(iX, iY, -1)) {
0871 EEDetId eedetidneg(iX, iY, -1);
0872 ical->setValue(eedetidneg.rawId(), intercalibErrorMean_);
0873 }
0874 }
0875 }
0876
0877 return ical;
0878 }
0879
0880 std::unique_ptr<EcalTimeCalibConstants> EcalTrivialConditionRetriever::produceEcalTimeCalibConstants(
0881 const EcalTimeCalibConstantsRcd&) {
0882 auto ical = std::make_unique<EcalTimeCalibConstants>();
0883
0884 for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
0885 if (ieta == 0)
0886 continue;
0887 for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
0888
0889 if (EBDetId::validDetId(ieta, iphi)) {
0890 EBDetId ebid(ieta, iphi);
0891 double r = (double)std::rand() / (double(RAND_MAX) + double(1));
0892 ical->setValue(ebid.rawId(), timeCalibConstantMean_ + r * timeCalibConstantSigma_);
0893 }
0894 }
0895 }
0896
0897 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
0898 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
0899
0900 if (EEDetId::validDetId(iX, iY, 1)) {
0901 double r = (double)std::rand() / (double(RAND_MAX) + double(1));
0902 EEDetId eedetidpos(iX, iY, 1);
0903 ical->setValue(eedetidpos.rawId(), timeCalibConstantMean_ + r * timeCalibConstantSigma_);
0904 }
0905 if (EEDetId::validDetId(iX, iY, -1)) {
0906 double r1 = (double)std::rand() / (double(RAND_MAX) + double(1));
0907 EEDetId eedetidneg(iX, iY, -1);
0908 ical->setValue(eedetidneg.rawId(), timeCalibConstantMean_ + r1 * timeCalibConstantSigma_);
0909 }
0910 }
0911 }
0912
0913 return ical;
0914 }
0915
0916 std::unique_ptr<EcalTimeCalibErrors> EcalTrivialConditionRetriever::produceEcalTimeCalibErrors(
0917 const EcalTimeCalibErrorsRcd&) {
0918 auto ical = std::make_unique<EcalTimeCalibErrors>();
0919
0920 for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
0921 if (ieta == 0)
0922 continue;
0923 for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
0924
0925 if (EBDetId::validDetId(ieta, iphi)) {
0926 EBDetId ebid(ieta, iphi);
0927 ical->setValue(ebid.rawId(), timeCalibErrorMean_);
0928 }
0929 }
0930 }
0931
0932 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
0933 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
0934
0935 if (EEDetId::validDetId(iX, iY, 1)) {
0936 EEDetId eedetidpos(iX, iY, 1);
0937 ical->setValue(eedetidpos.rawId(), timeCalibErrorMean_);
0938 }
0939 if (EEDetId::validDetId(iX, iY, -1)) {
0940 EEDetId eedetidneg(iX, iY, -1);
0941 ical->setValue(eedetidneg.rawId(), timeCalibErrorMean_);
0942 }
0943 }
0944 }
0945
0946 return ical;
0947 }
0948
0949 std::unique_ptr<EcalTimeOffsetConstant> EcalTrivialConditionRetriever::produceEcalTimeOffsetConstant(
0950 const EcalTimeOffsetConstantRcd&) {
0951 edm::LogInfo(" produceEcalTimeOffsetConstant: ");
0952 edm::LogInfo(" EB ") << timeOffsetEBConstant_ << " EE " << timeOffsetEEConstant_;
0953 return std::make_unique<EcalTimeOffsetConstant>(timeOffsetEBConstant_, timeOffsetEEConstant_);
0954 }
0955
0956 std::unique_ptr<EcalGainRatios> EcalTrivialConditionRetriever::produceEcalGainRatios(const EcalGainRatiosRcd&) {
0957 auto gratio = std::make_unique<EcalGainRatios>();
0958 EcalMGPAGainRatio gr;
0959 gr.setGain12Over6(gainRatio12over6_);
0960 gr.setGain6Over1(gainRatio6over1_);
0961
0962 for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
0963 if (ieta == 0)
0964 continue;
0965 for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
0966 if (EBDetId::validDetId(ieta, iphi)) {
0967 EBDetId ebid(ieta, iphi);
0968 gratio->setValue(ebid.rawId(), gr);
0969 }
0970 }
0971 }
0972
0973 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
0974 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
0975
0976 if (EEDetId::validDetId(iX, iY, 1)) {
0977 EEDetId eedetidpos(iX, iY, 1);
0978 gratio->setValue(eedetidpos.rawId(), gr);
0979 }
0980 if (EEDetId::validDetId(iX, iY, -1)) {
0981 EEDetId eedetidneg(iX, iY, -1);
0982 gratio->setValue(eedetidneg.rawId(), gr);
0983 }
0984 }
0985 }
0986
0987 return gratio;
0988 }
0989
0990 std::unique_ptr<EcalADCToGeVConstant> EcalTrivialConditionRetriever::produceEcalADCToGeVConstant(
0991 const EcalADCToGeVConstantRcd&) {
0992 return std::make_unique<EcalADCToGeVConstant>(adcToGeVEBConstant_, adcToGeVEEConstant_);
0993 }
0994
0995 std::unique_ptr<EcalTBWeights> EcalTrivialConditionRetriever::produceEcalTBWeights(const EcalTBWeightsRcd&) {
0996
0997 auto tbwgt = std::make_unique<EcalTBWeights>();
0998
0999
1000
1001
1002
1003 int igrp = 1;
1004 for (int itdc = 1; itdc <= nTDCbins_; ++itdc) {
1005
1006
1007
1008
1009 EcalWeightSet wgt;
1010
1011 EcalWeightSet::EcalWeightMatrix& mat1 = wgt.getWeightsBeforeGainSwitch();
1012 EcalWeightSet::EcalWeightMatrix& mat2 = wgt.getWeightsAfterGainSwitch();
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035 mat1.Place_in_row(amplWeights_[itdc - 1], 0, 0);
1036 mat1.Place_in_row(pedWeights_[itdc - 1], 1, 0);
1037 mat1.Place_in_row(jittWeights_[itdc - 1], 2, 0);
1038
1039
1040 mat2.Place_in_row(amplWeightsAft_[itdc - 1], 0, 0);
1041 mat2.Place_in_row(pedWeightsAft_[itdc - 1], 1, 0);
1042 mat2.Place_in_row(jittWeightsAft_[itdc - 1], 2, 0);
1043
1044
1045
1046 EcalWeightSet::EcalChi2WeightMatrix& mat3 = wgt.getChi2WeightsBeforeGainSwitch();
1047 EcalWeightSet::EcalChi2WeightMatrix& mat4 = wgt.getChi2WeightsAfterGainSwitch();
1048 mat3 = chi2Matrix_[itdc - 1];
1049 mat4 = chi2MatrixAft_[itdc - 1];
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071 tbwgt->setValue(std::make_pair(igrp, itdc), wgt);
1072 }
1073
1074 return tbwgt;
1075 }
1076
1077
1078 std::unique_ptr<EcalClusterLocalContCorrParameters>
1079 EcalTrivialConditionRetriever::produceEcalClusterLocalContCorrParameters(const EcalClusterLocalContCorrParametersRcd&) {
1080 auto ipar = std::make_unique<EcalClusterLocalContCorrParameters>();
1081 for (size_t i = 0; i < localContCorrParameters_.size(); ++i) {
1082 ipar->params().push_back(localContCorrParameters_[i]);
1083 }
1084 return ipar;
1085 }
1086 std::unique_ptr<EcalClusterCrackCorrParameters> EcalTrivialConditionRetriever::produceEcalClusterCrackCorrParameters(
1087 const EcalClusterCrackCorrParametersRcd&) {
1088 auto ipar = std::make_unique<EcalClusterCrackCorrParameters>();
1089 for (size_t i = 0; i < crackCorrParameters_.size(); ++i) {
1090 ipar->params().push_back(crackCorrParameters_[i]);
1091 }
1092 return ipar;
1093 }
1094 std::unique_ptr<EcalClusterEnergyCorrectionParameters>
1095 EcalTrivialConditionRetriever::produceEcalClusterEnergyCorrectionParameters(
1096 const EcalClusterEnergyCorrectionParametersRcd&) {
1097 auto ipar = std::make_unique<EcalClusterEnergyCorrectionParameters>();
1098 for (size_t i = 0; i < energyCorrectionParameters_.size(); ++i) {
1099 ipar->params().push_back(energyCorrectionParameters_[i]);
1100 }
1101 return ipar;
1102 }
1103 std::unique_ptr<EcalClusterEnergyUncertaintyParameters>
1104 EcalTrivialConditionRetriever::produceEcalClusterEnergyUncertaintyParameters(
1105 const EcalClusterEnergyUncertaintyParametersRcd&) {
1106 auto ipar = std::make_unique<EcalClusterEnergyUncertaintyParameters>();
1107 for (size_t i = 0; i < energyUncertaintyParameters_.size(); ++i) {
1108 ipar->params().push_back(energyUncertaintyParameters_[i]);
1109 }
1110 return ipar;
1111 }
1112 std::unique_ptr<EcalClusterEnergyCorrectionObjectSpecificParameters>
1113 EcalTrivialConditionRetriever::produceEcalClusterEnergyCorrectionObjectSpecificParameters(
1114 const EcalClusterEnergyCorrectionObjectSpecificParametersRcd&) {
1115 auto ipar = std::make_unique<EcalClusterEnergyCorrectionObjectSpecificParameters>();
1116 for (size_t i = 0; i < energyCorrectionObjectSpecificParameters_.size(); ++i) {
1117 ipar->params().push_back(energyCorrectionObjectSpecificParameters_[i]);
1118 }
1119 return ipar;
1120 }
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300 std::unique_ptr<EcalLaserAlphas> EcalTrivialConditionRetriever::produceEcalLaserAlphas(const EcalLaserAlphasRcd&) {
1301 edm::LogInfo(" produceEcalLaserAlphas ");
1302 auto ical = std::make_unique<EcalLaserAlphas>();
1303
1304
1305 if (getLaserAlphaFromTypeEB_) {
1306 std::ifstream fEB(edm::FileInPath(EBLaserAlphaFile_).fullPath().c_str());
1307 int SMpos[36] = {-10, 4, -7, -16, 6, -9, 11, -17, 5, 18, 3, -8, 1, -3, -13, 14, -6, 2,
1308 15, -18, 8, 17, -2, 9, -1, 10, -5, 7, -12, -11, 16, -4, -15, -14, 12, 13};
1309
1310 int SMCal[36] = {12, 17, 10, 1, 8, 4, 27, 20, 23, 25, 6, 34, 35, 15, 18, 30, 21, 9,
1311 24, 22, 13, 31, 26, 16, 2, 11, 5, 0, 29, 28, 14, 33, 32, 3, 7, 19};
1312
1313 for (int SMcons = 0; SMcons < 36; SMcons++) {
1314 int SM = SMpos[SMcons];
1315 if (SM < 0)
1316 SM = 17 + abs(SM);
1317 else
1318 SM--;
1319 if (SMCal[SM] != SMcons)
1320 edm::LogInfo(" SM pb : read SM ") << SMcons << " SMpos " << SM << " SMCal " << SMCal[SM];
1321 }
1322
1323 std::string type, batch;
1324 int readSM, pos, bar, bar2;
1325 float alpha = 0;
1326 for (int SMcons = 0; SMcons < 36; SMcons++) {
1327 int SM = SMpos[SMcons];
1328 for (int ic = 0; ic < 1700; ic++) {
1329 fEB >> readSM >> pos >> bar >> bar2 >> type >> batch;
1330
1331 if (readSM != SMcons || pos != ic + 1)
1332 edm::LogInfo(" barrel read pb read SM ")
1333 << readSM << " const SM " << SMcons << " read pos " << pos << " ic " << ic;
1334 if (SM < 0)
1335 SM = 18 + abs(SM);
1336 EBDetId ebdetid(SM, pos, EBDetId::SMCRYSTALMODE);
1337 if (bar == 33101 || bar == 30301)
1338 alpha = laserAlphaMeanEBR_;
1339 else if (bar == 33106) {
1340 if (bar2 <= 2000)
1341 alpha = laserAlphaMeanEBC_;
1342 else {
1343 edm::LogInfo(" problem with barcode first ")
1344 << bar << " last " << bar2 << " read SM " << readSM << " read pos " << pos;
1345 alpha = laserAlphaMeanEBR_;
1346 }
1347 }
1348 ical->setValue(ebdetid, alpha);
1349
1350 if (ic == 1650) {
1351 edm::LogInfo(" ic/alpha ") << ic << "/" << alpha;
1352 }
1353 }
1354 }
1355 fEB.close();
1356
1357 } else if (getLaserAlphaFromFileEB_) {
1358
1359 edm::LogInfo("Laser alpha for EB will be taken from File");
1360 int ieta, iphi;
1361 float alpha;
1362 std::ifstream fEB(edm::FileInPath(EBLaserAlphaFile_).fullPath().c_str());
1363
1364 for (int ic = 0; ic < 61200; ic++) {
1365 fEB >> ieta >> iphi >> alpha;
1366
1367 if (EBDetId::validDetId(ieta, iphi)) {
1368 EBDetId ebid(ieta, iphi);
1369 ical->setValue(ebid, alpha);
1370
1371 }
1372 if (ieta == 10) {
1373 edm::LogInfo("I will print some alphas from the file... ieta/iphi/alpha ")
1374 << ieta << "/" << iphi << "/" << alpha;
1375 }
1376 }
1377 fEB.close();
1378
1379 } else {
1380 edm::LogInfo("laser alphas from default values");
1381
1382
1383 for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
1384 if (ieta == 0)
1385 continue;
1386 for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
1387 if (EBDetId::validDetId(ieta, iphi)) {
1388 EBDetId ebid(ieta, iphi);
1389 double r = (double)std::rand() / (double(RAND_MAX) + double(1));
1390 ical->setValue(ebid, laserAlphaMean_ + r * laserAlphaSigma_);
1391 }
1392 }
1393 }
1394 }
1395
1396 edm::LogInfo(" produceEcalLaserAlphas EE");
1397
1398
1399 int itype, iring, iyear;
1400 float laser = 0;
1401 float las[2][140][6];
1402
1403 if (getLaserAlphaFromTypeEE_) {
1404 edm::LogInfo(" EE laser alphas from type");
1405
1406 std::ifstream fRing(edm::FileInPath(EELaserAlphaFile2_).fullPath().c_str());
1407 for (int i = 0; i < 1681; i++) {
1408 fRing >> itype >> iring >> iyear >> laser;
1409 edm::LogInfo(" ") << itype << " " << iring << " " << iyear << " " << laser << std::endl;
1410 las[itype][iring][iyear] = laser;
1411 }
1412 fRing.close();
1413
1414 std::ifstream fEE(edm::FileInPath(EELaserAlphaFile_).fullPath().c_str());
1415 int nxt = 0;
1416 for (int crystal = 0; crystal < 14648; crystal++) {
1417 int x, y, z, bid, bar, bar2;
1418 float LY, alpha = 0;
1419 fEE >> z >> x >> y >> LY >> bid >> bar >> bar2;
1420 if (x < 1 || x > 100 || y < 1 || y > 100)
1421 edm::LogInfo(" wrong coordinates for barcode ") << bar << " x " << x << " y " << y << " z " << z;
1422 else {
1423 int iyear = 4;
1424 int iring = (int)(sqrt(((float)x - 50.5) * ((float)x - 50.5) + ((float)y - 50.5) * ((float)y - 50.5)) + 85);
1425
1426 double eta = -log(tan(0.5 * atan(sqrt((x - 50.5) * (x - 50.5) + (y - 50.5) * (y - 50.5)) * 2.98 / 328.)));
1427
1428 if (bar == 33201 || (bar == 30399 && bar2 < 568)) {
1429
1430 alpha = laserAlphaMeanEER_;
1431
1432 double raggio = 50.5 - sqrt(((float)x - 50.5) * ((float)x - 50.5) + ((float)y - 50.5) * ((float)y - 50.5));
1433
1434 if (raggio >= 25) {
1435 alpha = 1.07;
1436 }
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450 if (x == 50)
1451 edm::LogInfo("R=") << raggio << " x " << x << " y " << y << " z " << z << "eta=" << eta
1452 << " alpha=" << alpha << " R";
1453
1454 } else if ((bar == 33106 && bar2 > 2000 && bar2 < 4669) || (bar == 30399 && bar2 > 567)) {
1455
1456 itype = 1;
1457 alpha = laserAlphaMeanEEC_;
1458
1459 double raggio = 50.5 - sqrt(((float)x - 50.5) * ((float)x - 50.5) + ((float)y - 50.5) * ((float)y - 50.5));
1460
1461 if (raggio >= 25) {
1462 alpha = 0.80;
1463 }
1464 if (raggio >= 34) {
1465 float r = sqrt((x - 50.5) * (x - 50.5) + (y - 50.5) * (y - 50.5));
1466 if (r < 21) {
1467 nxt = nxt + 1;
1468
1469
1470 if (las[itype][iring][iyear] != 999) {
1471 alpha = 0.7312 + 0.2688 * las[itype][iring][iyear];
1472 }
1473 }
1474 }
1475 if (x == 50)
1476 edm::LogInfo("R=") << raggio << " x " << x << " y " << y << " z " << z << "eta=" << eta
1477 << " alpha=" << alpha << " C";
1478
1479 } else {
1480 edm::LogInfo(" problem with barcode ") << bar << " " << bar2 << " x " << x << " y " << y << " z " << z;
1481 alpha = laserAlphaMeanEER_;
1482 }
1483 }
1484
1485 if (EEDetId::validDetId(x, y, z)) {
1486 EEDetId eedetidpos(x, y, z);
1487 ical->setValue(eedetidpos, alpha);
1488 if (x == 50)
1489 edm::LogInfo(" x ") << x << " y " << y << " alpha " << alpha;
1490 } else
1491 edm::LogInfo(" problem with EEDetId ") << " x " << x << " y " << y << " z " << z;
1492 }
1493 fEE.close();
1494 edm::LogInfo("Number of inner SIC crystals with different alpha= ") << nxt;
1495
1496
1497 } else if (getLaserAlphaFromFileEE_) {
1498 edm::LogInfo(" EE laser alphas from file");
1499
1500 std::ifstream fEE(edm::FileInPath(EELaserAlphaFile_).fullPath().c_str());
1501
1502 for (int crystal = 0; crystal < 14648; crystal++) {
1503 int x, y, z;
1504 float alpha = 1;
1505 fEE >> z >> x >> y >> alpha;
1506 if (x < 1 || x > 100 || y < 1 || y > 100 || z == 0 || z > 1 || z < -1) {
1507 edm::LogInfo("ERROR: wrong coordinates for crystal ") << " x " << x << " y " << y << " z " << z;
1508 edm::LogInfo(" the format of the file should be z x y alpha ");
1509 } else {
1510 if (EEDetId::validDetId(x, y, z)) {
1511 EEDetId eedetidpos(x, y, z);
1512 ical->setValue(eedetidpos, alpha);
1513 } else
1514 edm::LogInfo(" problem with EEDetId ") << " x " << x << " y " << y << " z " << z;
1515 }
1516 }
1517 fEE.close();
1518
1519
1520 } else {
1521
1522 edm::LogInfo(" EE laser alphas from default values");
1523 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
1524 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
1525
1526 if (EEDetId::validDetId(iX, iY, 1)) {
1527 double r = (double)std::rand() / (double(RAND_MAX) + double(1));
1528 EEDetId eedetidpos(iX, iY, 1);
1529 ical->setValue(eedetidpos, laserAlphaMean_ + r * laserAlphaSigma_);
1530 }
1531 if (EEDetId::validDetId(iX, iY, -1)) {
1532 double r1 = (double)std::rand() / (double(RAND_MAX) + double(1));
1533 EEDetId eedetidneg(iX, iY, -1);
1534 ical->setValue(eedetidneg, laserAlphaMean_ + r1 * laserAlphaSigma_);
1535 }
1536 }
1537 }
1538 }
1539
1540 return ical;
1541 }
1542
1543 std::unique_ptr<EcalLaserAPDPNRatiosRef> EcalTrivialConditionRetriever::produceEcalLaserAPDPNRatiosRef(
1544 const EcalLaserAPDPNRatiosRefRcd&) {
1545 auto ical = std::make_unique<EcalLaserAPDPNRatiosRef>();
1546 for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
1547 if (ieta == 0)
1548 continue;
1549 for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
1550 if (EBDetId::validDetId(ieta, iphi)) {
1551 EBDetId ebid(ieta, iphi);
1552 double r = (double)std::rand() / (double(RAND_MAX) + double(1));
1553 ical->setValue(ebid, laserAPDPNRefMean_ + r * laserAPDPNRefSigma_);
1554 }
1555 }
1556 }
1557
1558 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
1559 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
1560
1561 if (EEDetId::validDetId(iX, iY, 1)) {
1562 double r = (double)std::rand() / (double(RAND_MAX) + double(1));
1563 EEDetId eedetidpos(iX, iY, 1);
1564 ical->setValue(eedetidpos, laserAPDPNRefMean_ + r * laserAPDPNRefSigma_);
1565 }
1566
1567 if (EEDetId::validDetId(iX, iY, -1)) {
1568 double r1 = (double)std::rand() / (double(RAND_MAX) + double(1));
1569 EEDetId eedetidneg(iX, iY, -1);
1570 ical->setValue(eedetidneg, laserAPDPNRefMean_ + r1 * laserAPDPNRefSigma_);
1571 }
1572 }
1573 }
1574
1575 return ical;
1576 }
1577
1578 std::unique_ptr<EcalLaserAPDPNRatios> EcalTrivialConditionRetriever::produceEcalLaserAPDPNRatios(
1579 const EcalLaserAPDPNRatiosRcd&) {
1580 EnergyResolutionVsLumi ageing;
1581 ageing.setLumi(totLumi_);
1582 ageing.setInstLumi(instLumi_);
1583
1584 auto ical = std::make_unique<EcalLaserAPDPNRatios>();
1585 for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
1586 if (ieta == 0)
1587 continue;
1588
1589 double eta = EBDetId::approxEta(EBDetId(ieta, 1));
1590
1591 eta = fabs(eta);
1592 double drop = ageing.calcampDropTotal(eta);
1593
1594
1595 for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
1596 if (EBDetId::validDetId(ieta, iphi)) {
1597 EBDetId ebid(ieta, iphi);
1598 double r = (double)std::rand() / (double(RAND_MAX) + double(1));
1599
1600 EcalLaserAPDPNRatios::EcalLaserAPDPNpair pairAPDPN;
1601 pairAPDPN.p1 = laserAPDPNMean_ * drop + r * laserAPDPNSigma_;
1602 pairAPDPN.p2 = laserAPDPNMean_ * drop + r * laserAPDPNSigma_;
1603 pairAPDPN.p3 = laserAPDPNMean_ * drop + r * laserAPDPNSigma_;
1604 ical->setValue(ebid, pairAPDPN);
1605 }
1606 }
1607 }
1608
1609 edm::LogInfo("----- EE -----");
1610
1611 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
1612 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
1613
1614
1615 if (EEDetId::validDetId(iX, iY, 1)) {
1616 double r = (double)std::rand() / (double(RAND_MAX) + double(1));
1617 EEDetId eedetidpos(iX, iY, 1);
1618
1619 double eta = -log(tan(0.5 * atan(sqrt((iX - 50.0) * (iX - 50.0) + (iY - 50.0) * (iY - 50.0)) * 2.98 / 328.)));
1620 eta = fabs(eta);
1621 double drop = ageing.calcampDropTotal(eta);
1622
1623
1624 EcalLaserAPDPNRatios::EcalLaserAPDPNpair pairAPDPN;
1625 pairAPDPN.p1 = laserAPDPNMean_ * drop + r * laserAPDPNSigma_;
1626 pairAPDPN.p2 = laserAPDPNMean_ * drop + r * laserAPDPNSigma_;
1627 pairAPDPN.p3 = laserAPDPNMean_ * drop + r * laserAPDPNSigma_;
1628 ical->setValue(eedetidpos, pairAPDPN);
1629 }
1630
1631 if (EEDetId::validDetId(iX, iY, -1)) {
1632 double r1 = (double)std::rand() / (double(RAND_MAX) + double(1));
1633 EEDetId eedetidneg(iX, iY, -1);
1634
1635 double eta = -log(tan(0.5 * atan(sqrt((iX - 50.0) * (iX - 50.0) + (iY - 50.0) * (iY - 50.0)) * 2.98 / 328.)));
1636 eta = fabs(eta);
1637 double drop = ageing.calcampDropTotal(eta);
1638
1639
1640 EcalLaserAPDPNRatios::EcalLaserAPDPNpair pairAPDPN;
1641 pairAPDPN.p1 = laserAPDPNMean_ * drop + r1 * laserAPDPNSigma_;
1642 pairAPDPN.p2 = laserAPDPNMean_ * drop + r1 * laserAPDPNSigma_;
1643 pairAPDPN.p3 = laserAPDPNMean_ * drop + r1 * laserAPDPNSigma_;
1644 ical->setValue(eedetidneg, pairAPDPN);
1645 }
1646 }
1647 }
1648
1649 EcalLaserAPDPNRatios::EcalLaserTimeStamp TimeStamp;
1650
1651 for (int i = 0; i < 92; i++) {
1652 TimeStamp.t1 = Timestamp(laserAPDPNTime1_);
1653 if (laserAPDPNTime2_ == 0) {
1654 TimeStamp.t2 = Timestamp(edm::Timestamp::endOfTime().value());
1655 } else {
1656 TimeStamp.t2 = Timestamp(laserAPDPNTime2_);
1657 }
1658 if (laserAPDPNTime3_ == 0) {
1659 TimeStamp.t3 = Timestamp(edm::Timestamp::endOfTime().value());
1660 } else {
1661 TimeStamp.t3 = Timestamp(laserAPDPNTime3_);
1662 }
1663
1664 ical->setTime(i, TimeStamp);
1665 }
1666
1667 return ical;
1668 }
1669
1670 void EcalTrivialConditionRetriever::getWeightsFromConfiguration(const edm::ParameterSet& ps) {
1671 std::vector<std::vector<double> > amplwgtv(nTDCbins_);
1672
1673 if (!getWeightsFromFile_ && nTDCbins_ == 1) {
1674 std::vector<double> vampl;
1675
1676 vampl.push_back(-0.33333);
1677 vampl.push_back(-0.33333);
1678 vampl.push_back(-0.33333);
1679 vampl.push_back(0.);
1680 vampl.push_back(0.);
1681 vampl.push_back(1.);
1682 vampl.push_back(0.);
1683 vampl.push_back(0.);
1684 vampl.push_back(0.);
1685 vampl.push_back(0.);
1686 amplwgtv[0] = ps.getUntrackedParameter<std::vector<double> >("amplWeights", vampl);
1687 } else if (getWeightsFromFile_) {
1688 edm::LogInfo("EcalTrivialConditionRetriever")
1689 << "Reading amplitude weights from file " << edm::FileInPath(amplWeightsFile_).fullPath().c_str();
1690 std::ifstream amplFile(edm::FileInPath(amplWeightsFile_).fullPath().c_str());
1691 int tdcBin = 0;
1692 while (!amplFile.eof() && tdcBin < nTDCbins_) {
1693 for (int j = 0; j < 10; ++j) {
1694 float ww;
1695 amplFile >> ww;
1696 amplwgtv[tdcBin].push_back(ww);
1697 }
1698 ++tdcBin;
1699 }
1700 assert(tdcBin == nTDCbins_);
1701
1702 } else {
1703
1704 edm::LogError("EcalTrivialConditionRetriever") << "Configuration not supported. Exception is raised ";
1705 throw cms::Exception("WrongConfig");
1706 }
1707
1708 for (int i = 0; i < nTDCbins_; i++) {
1709 assert(amplwgtv[i].size() == 10);
1710 int j = 0;
1711 for (std::vector<double>::const_iterator it = amplwgtv[i].begin(); it != amplwgtv[i].end(); ++it) {
1712 (amplWeights_[i])[j] = *it;
1713 j++;
1714 }
1715 }
1716
1717 std::vector<std::vector<double> > amplwgtvAftGain(nTDCbins_);
1718
1719 if (!getWeightsFromFile_ && nTDCbins_ == 1) {
1720 std::vector<double> vamplAftGain;
1721 vamplAftGain.push_back(0.);
1722 vamplAftGain.push_back(0.);
1723 vamplAftGain.push_back(0.);
1724 vamplAftGain.push_back(0.);
1725 vamplAftGain.push_back(0.);
1726 vamplAftGain.push_back(1.);
1727 vamplAftGain.push_back(0.);
1728 vamplAftGain.push_back(0.);
1729 vamplAftGain.push_back(0.);
1730 vamplAftGain.push_back(0.);
1731 amplwgtvAftGain[0] = ps.getUntrackedParameter<std::vector<double> >("amplWeightsAftGain", vamplAftGain);
1732 } else if (getWeightsFromFile_) {
1733
1734 edm::LogInfo("EcalTrivialConditionRetriever") << "Reading amplitude weights aftre gain switch from file "
1735 << edm::FileInPath(amplWeightsAftFile_).fullPath().c_str();
1736 std::ifstream amplFile(edm::FileInPath(amplWeightsAftFile_).fullPath().c_str());
1737 int tdcBin = 0;
1738 while (!amplFile.eof() && tdcBin < nTDCbins_) {
1739 for (int j = 0; j < 10; ++j) {
1740 float ww;
1741 amplFile >> ww;
1742 amplwgtvAftGain[tdcBin].push_back(ww);
1743 }
1744 ++tdcBin;
1745 }
1746 assert(tdcBin == nTDCbins_);
1747 } else {
1748
1749 edm::LogError("EcalTrivialConditionRetriever") << "Configuration not supported. Exception is raised ";
1750 throw cms::Exception("WrongConfig");
1751 }
1752
1753 for (int i = 0; i < nTDCbins_; i++) {
1754 assert(amplwgtvAftGain[i].size() == 10);
1755 int j = 0;
1756 for (std::vector<double>::const_iterator it = amplwgtvAftGain[i].begin(); it != amplwgtvAftGain[i].end(); ++it) {
1757 (amplWeightsAft_[i])[j] = *it;
1758 j++;
1759 }
1760 }
1761
1762
1763
1764 std::vector<std::vector<double> > pedwgtv(nTDCbins_);
1765
1766 if (!getWeightsFromFile_ && nTDCbins_ == 1) {
1767 std::vector<double> vped;
1768 vped.push_back(0.33333);
1769 vped.push_back(0.33333);
1770 vped.push_back(0.33333);
1771 vped.push_back(0.);
1772 vped.push_back(0.);
1773 vped.push_back(0.);
1774 vped.push_back(0.);
1775 vped.push_back(0.);
1776 vped.push_back(0.);
1777 vped.push_back(0.);
1778 pedwgtv[0] = ps.getUntrackedParameter<std::vector<double> >("pedWeights", vped);
1779 } else if (getWeightsFromFile_) {
1780
1781 edm::LogInfo("EcalTrivialConditionRetriever")
1782 << "Reading pedestal weights from file " << edm::FileInPath(pedWeightsFile_).fullPath().c_str();
1783 std::ifstream pedFile(edm::FileInPath(pedWeightsFile_).fullPath().c_str());
1784 int tdcBin = 0;
1785 while (!pedFile.eof() && tdcBin < nTDCbins_) {
1786 for (int j = 0; j < 10; ++j) {
1787 float ww;
1788 pedFile >> ww;
1789 pedwgtv[tdcBin].push_back(ww);
1790 }
1791 ++tdcBin;
1792 }
1793 assert(tdcBin == nTDCbins_);
1794 } else {
1795
1796 edm::LogError("EcalTrivialConditionRetriever") << "Configuration not supported. Exception is raised ";
1797 throw cms::Exception("WrongConfig");
1798 }
1799
1800 for (int i = 0; i < nTDCbins_; i++) {
1801 assert(pedwgtv[i].size() == 10);
1802 int j = 0;
1803 for (std::vector<double>::const_iterator it = pedwgtv[i].begin(); it != pedwgtv[i].end(); ++it) {
1804 (pedWeights_[i])[j] = *it;
1805 j++;
1806 }
1807 }
1808
1809 std::vector<std::vector<double> > pedwgtvaft(nTDCbins_);
1810
1811 if (!getWeightsFromFile_ && nTDCbins_ == 1) {
1812 std::vector<double> vped;
1813 vped.push_back(0.);
1814 vped.push_back(0.);
1815 vped.push_back(0.);
1816 vped.push_back(0.);
1817 vped.push_back(0.);
1818 vped.push_back(0.);
1819 vped.push_back(0.);
1820 vped.push_back(0.);
1821 vped.push_back(0.);
1822 vped.push_back(0.);
1823 pedwgtvaft[0] = ps.getUntrackedParameter<std::vector<double> >("pedWeightsAft", vped);
1824 } else if (getWeightsFromFile_) {
1825
1826 edm::LogInfo("EcalTrivialConditionRetriever") << "Reading pedestal after gain switch weights from file "
1827 << edm::FileInPath(pedWeightsAftFile_).fullPath().c_str();
1828 std::ifstream pedFile(edm::FileInPath(pedWeightsAftFile_).fullPath().c_str());
1829 int tdcBin = 0;
1830 while (!pedFile.eof() && tdcBin < nTDCbins_) {
1831 for (int j = 0; j < 10; ++j) {
1832 float ww;
1833 pedFile >> ww;
1834 pedwgtvaft[tdcBin].push_back(ww);
1835 }
1836 ++tdcBin;
1837 }
1838 assert(tdcBin == nTDCbins_);
1839 } else {
1840
1841 edm::LogError("EcalTrivialConditionRetriever") << "Configuration not supported. Exception is raised ";
1842 throw cms::Exception("WrongConfig");
1843 }
1844
1845 for (int i = 0; i < nTDCbins_; i++) {
1846 assert(pedwgtvaft[i].size() == 10);
1847 int j = 0;
1848 for (std::vector<double>::const_iterator it = pedwgtvaft[i].begin(); it != pedwgtvaft[i].end(); ++it) {
1849 (pedWeightsAft_[i])[j] = *it;
1850 j++;
1851 }
1852 }
1853
1854
1855
1856 std::vector<std::vector<double> > jittwgtv(nTDCbins_);
1857
1858 if (!getWeightsFromFile_ && nTDCbins_ == 1) {
1859 std::vector<double> vjitt;
1860 vjitt.push_back(0.04066309);
1861 vjitt.push_back(0.04066309);
1862 vjitt.push_back(0.04066309);
1863 vjitt.push_back(0.000);
1864 vjitt.push_back(1.325176);
1865 vjitt.push_back(-0.04997078);
1866 vjitt.push_back(-0.504338);
1867 vjitt.push_back(-0.5024844);
1868 vjitt.push_back(-0.3903718);
1869 vjitt.push_back(0.000);
1870 jittwgtv[0] = ps.getUntrackedParameter<std::vector<double> >("jittWeights", vjitt);
1871 } else if (getWeightsFromFile_) {
1872
1873 edm::LogInfo("EcalTrivialConditionRetriever")
1874 << "Reading jitter weights from file " << edm::FileInPath(jittWeightsFile_).fullPath().c_str();
1875 std::ifstream jittFile(edm::FileInPath(jittWeightsFile_).fullPath().c_str());
1876 int tdcBin = 0;
1877 while (!jittFile.eof() && tdcBin < nTDCbins_) {
1878 for (int j = 0; j < 10; ++j) {
1879 float ww;
1880 jittFile >> ww;
1881 jittwgtv[tdcBin].push_back(ww);
1882 }
1883 ++tdcBin;
1884 }
1885 assert(tdcBin == nTDCbins_);
1886 } else {
1887
1888 edm::LogError("EcalTrivialConditionRetriever") << "Configuration not supported. Exception is raised ";
1889 throw cms::Exception("WrongConfig");
1890 }
1891
1892 for (int i = 0; i < nTDCbins_; i++) {
1893 assert(jittwgtv[i].size() == 10);
1894 int j = 0;
1895 for (std::vector<double>::const_iterator it = jittwgtv[i].begin(); it != jittwgtv[i].end(); ++it) {
1896 (jittWeights_[i])[j] = *it;
1897 j++;
1898 }
1899 }
1900
1901 std::vector<std::vector<double> > jittwgtvaft(nTDCbins_);
1902
1903 if (!getWeightsFromFile_ && nTDCbins_ == 1) {
1904 std::vector<double> vjitt;
1905 vjitt.push_back(0.);
1906 vjitt.push_back(0.);
1907 vjitt.push_back(0.);
1908 vjitt.push_back(0.);
1909 vjitt.push_back(1.097871);
1910 vjitt.push_back(-0.04551035);
1911 vjitt.push_back(-0.4159156);
1912 vjitt.push_back(-0.4185352);
1913 vjitt.push_back(-0.3367127);
1914 vjitt.push_back(0.);
1915 jittwgtvaft[0] = ps.getUntrackedParameter<std::vector<double> >("jittWeightsAft", vjitt);
1916 } else if (getWeightsFromFile_) {
1917
1918 edm::LogInfo("EcalTrivialConditionRetriever") << "Reading jitter after gain switch weights from file "
1919 << edm::FileInPath(jittWeightsAftFile_).fullPath().c_str();
1920 std::ifstream jittFile(edm::FileInPath(jittWeightsAftFile_).fullPath().c_str());
1921 int tdcBin = 0;
1922 while (!jittFile.eof() && tdcBin < nTDCbins_) {
1923 for (int j = 0; j < 10; ++j) {
1924 float ww;
1925 jittFile >> ww;
1926 jittwgtvaft[tdcBin].push_back(ww);
1927 }
1928 ++tdcBin;
1929 }
1930 assert(tdcBin == nTDCbins_);
1931 } else {
1932
1933 edm::LogError("EcalTrivialConditionRetriever") << "Configuration not supported. Exception is raised ";
1934 throw cms::Exception("WrongConfig");
1935 }
1936
1937 for (int i = 0; i < nTDCbins_; i++) {
1938 assert(jittwgtvaft[i].size() == 10);
1939 int j = 0;
1940 for (std::vector<double>::const_iterator it = jittwgtvaft[i].begin(); it != jittwgtvaft[i].end(); ++it) {
1941 (jittWeightsAft_[i])[j] = *it;
1942 j++;
1943 }
1944 }
1945
1946 std::vector<EcalWeightSet::EcalChi2WeightMatrix> chi2Matrix(nTDCbins_);
1947 if (!getWeightsFromFile_ && nTDCbins_ == 1) {
1948
1949
1950
1951
1952 chi2Matrix[0](0, 0) = 0.694371;
1953 chi2Matrix[0](0, 1) = -0.305629;
1954 chi2Matrix[0](0, 2) = -0.305629;
1955 chi2Matrix[0](0, 3) = 0.;
1956 chi2Matrix[0](0, 4) = 0.;
1957 chi2Matrix[0](0, 5) = 0.;
1958 chi2Matrix[0](0, 6) = 0.;
1959 chi2Matrix[0](0, 7) = 0.;
1960 chi2Matrix[0](0, 8) = 0.;
1961 chi2Matrix[0](0, 9) = 0.;
1962 chi2Matrix[0](1, 0) = -0.305629;
1963 chi2Matrix[0](1, 1) = 0.694371;
1964 chi2Matrix[0](1, 2) = -0.305629;
1965 chi2Matrix[0](1, 3) = 0.;
1966 chi2Matrix[0](1, 4) = 0.;
1967 chi2Matrix[0](1, 5) = 0.;
1968 chi2Matrix[0](1, 6) = 0.;
1969 chi2Matrix[0](1, 7) = 0.;
1970 chi2Matrix[0](1, 8) = 0.;
1971 chi2Matrix[0](1, 9) = 0.;
1972 chi2Matrix[0](2, 0) = -0.305629;
1973 chi2Matrix[0](2, 1) = -0.305629;
1974 chi2Matrix[0](2, 2) = 0.694371;
1975 chi2Matrix[0](2, 3) = 0.;
1976 chi2Matrix[0](2, 4) = 0.;
1977 chi2Matrix[0](2, 5) = 0.;
1978 chi2Matrix[0](2, 6) = 0.;
1979 chi2Matrix[0](2, 7) = 0.;
1980 chi2Matrix[0](2, 8) = 0.;
1981 chi2Matrix[0](2, 9) = 0.;
1982 chi2Matrix[0](3, 0) = 0.;
1983 chi2Matrix[0](3, 1) = 0.;
1984 chi2Matrix[0](3, 2) = 0.;
1985 chi2Matrix[0](3, 3) = 0.;
1986 chi2Matrix[0](3, 4) = 0.;
1987 chi2Matrix[0](3, 5) = 0.;
1988 chi2Matrix[0](3, 6) = 0.;
1989 chi2Matrix[0](3, 7) = 0.;
1990 chi2Matrix[0](3, 8) = 0.;
1991 chi2Matrix[0](3, 9) = 0.;
1992 chi2Matrix[0](4, 0) = 0.;
1993 chi2Matrix[0](4, 1) = 0.;
1994 chi2Matrix[0](4, 2) = 0.;
1995 chi2Matrix[0](4, 3) = 0.;
1996 chi2Matrix[0](4, 4) = 0.8027116;
1997 chi2Matrix[0](4, 5) = -0.2517103;
1998 chi2Matrix[0](4, 6) = -0.2232882;
1999 chi2Matrix[0](4, 7) = -0.1716192;
2000 chi2Matrix[0](4, 8) = -0.1239006;
2001 chi2Matrix[0](4, 9) = 0.;
2002 chi2Matrix[0](5, 0) = 0.;
2003 chi2Matrix[0](5, 1) = 0.;
2004 chi2Matrix[0](5, 2) = 0.;
2005 chi2Matrix[0](5, 3) = 0.;
2006 chi2Matrix[0](5, 4) = -0.2517103;
2007 chi2Matrix[0](5, 5) = 0.6528964;
2008 chi2Matrix[0](5, 6) = -0.2972839;
2009 chi2Matrix[0](5, 7) = -0.2067162;
2010 chi2Matrix[0](5, 8) = -0.1230729;
2011 chi2Matrix[0](5, 9) = 0.;
2012 chi2Matrix[0](6, 0) = 0.;
2013 chi2Matrix[0](6, 1) = 0.;
2014 chi2Matrix[0](6, 2) = 0.;
2015 chi2Matrix[0](6, 3) = 0.;
2016 chi2Matrix[0](6, 4) = -0.2232882;
2017 chi2Matrix[0](6, 5) = -0.2972839;
2018 chi2Matrix[0](6, 6) = 0.7413607;
2019 chi2Matrix[0](6, 7) = -0.1883866;
2020 chi2Matrix[0](6, 8) = -0.1235052;
2021 chi2Matrix[0](6, 9) = 0.;
2022 chi2Matrix[0](7, 0) = 0.;
2023 chi2Matrix[0](7, 1) = 0.;
2024 chi2Matrix[0](7, 2) = 0.;
2025 chi2Matrix[0](7, 3) = 0.;
2026 chi2Matrix[0](7, 4) = -0.1716192;
2027 chi2Matrix[0](7, 5) = -0.2067162;
2028 chi2Matrix[0](7, 6) = -0.1883866;
2029 chi2Matrix[0](7, 7) = 0.844935;
2030 chi2Matrix[0](7, 8) = -0.124291;
2031 chi2Matrix[0](7, 9) = 0.;
2032 chi2Matrix[0](8, 0) = 0.;
2033 chi2Matrix[0](8, 1) = 0.;
2034 chi2Matrix[0](8, 2) = 0.;
2035 chi2Matrix[0](8, 3) = 0.;
2036 chi2Matrix[0](8, 4) = -0.1239006;
2037 chi2Matrix[0](8, 5) = -0.1230729;
2038 chi2Matrix[0](8, 6) = -0.1235052;
2039 chi2Matrix[0](8, 7) = -0.124291;
2040 chi2Matrix[0](8, 8) = 0.8749833;
2041 chi2Matrix[0](8, 9) = 0.;
2042 chi2Matrix[0](9, 0) = 0.;
2043 chi2Matrix[0](9, 1) = 0.;
2044 chi2Matrix[0](9, 2) = 0.;
2045 chi2Matrix[0](9, 3) = 0.;
2046 chi2Matrix[0](9, 4) = 0.;
2047 chi2Matrix[0](9, 5) = 0.;
2048 chi2Matrix[0](9, 6) = 0.;
2049 chi2Matrix[0](9, 7) = 0.;
2050 chi2Matrix[0](9, 8) = 0.;
2051 chi2Matrix[0](9, 9) = 0.;
2052 } else if (getWeightsFromFile_) {
2053
2054 edm::LogInfo("EcalTrivialConditionRetriever")
2055 << "Reading chi2Matrix from file " << edm::FileInPath(chi2MatrixFile_).fullPath().c_str();
2056 std::ifstream chi2MatrixFile(edm::FileInPath(chi2MatrixFile_).fullPath().c_str());
2057 int tdcBin = 0;
2058 while (!chi2MatrixFile.eof() && tdcBin < nTDCbins_) {
2059
2060 for (int j = 0; j < 10; ++j) {
2061 for (int l = 0; l < 10; ++l) {
2062 float ww;
2063 chi2MatrixFile >> ww;
2064 chi2Matrix[tdcBin](j, l) = ww;
2065 }
2066 }
2067 ++tdcBin;
2068 }
2069 assert(tdcBin == nTDCbins_);
2070 } else {
2071
2072 edm::LogError("EcalTrivialConditionRetriever") << "Configuration not supported. Exception is raised ";
2073 throw cms::Exception("WrongConfig");
2074 }
2075
2076
2077
2078
2079 chi2Matrix_ = chi2Matrix;
2080
2081
2082 std::vector<EcalWeightSet::EcalChi2WeightMatrix> chi2MatrixAft(nTDCbins_);
2083 if (!getWeightsFromFile_ && nTDCbins_ == 1) {
2084
2085
2086
2087
2088 chi2MatrixAft[0](0, 0) = 0.;
2089 chi2MatrixAft[0](0, 1) = 0.;
2090 chi2MatrixAft[0](0, 2) = 0.;
2091 chi2MatrixAft[0](0, 3) = 0.;
2092 chi2MatrixAft[0](0, 4) = 0.;
2093 chi2MatrixAft[0](0, 5) = 0.;
2094 chi2MatrixAft[0](0, 6) = 0.;
2095 chi2MatrixAft[0](0, 7) = 0.;
2096 chi2MatrixAft[0](0, 8) = 0.;
2097 chi2MatrixAft[0](0, 9) = 0.;
2098 chi2MatrixAft[0](1, 0) = 0.;
2099 chi2MatrixAft[0](1, 1) = 0.;
2100 chi2MatrixAft[0](1, 2) = 0.;
2101 chi2MatrixAft[0](1, 3) = 0.;
2102 chi2MatrixAft[0](1, 4) = 0.;
2103 chi2MatrixAft[0](1, 5) = 0.;
2104 chi2MatrixAft[0](1, 6) = 0.;
2105 chi2MatrixAft[0](1, 7) = 0.;
2106 chi2MatrixAft[0](1, 8) = 0.;
2107 chi2MatrixAft[0](1, 9) = 0.;
2108 chi2MatrixAft[0](2, 0) = 0.;
2109 chi2MatrixAft[0](2, 1) = 0.;
2110 chi2MatrixAft[0](2, 2) = 0.;
2111 chi2MatrixAft[0](2, 3) = 0.;
2112 chi2MatrixAft[0](2, 4) = 0.;
2113 chi2MatrixAft[0](2, 5) = 0.;
2114 chi2MatrixAft[0](2, 6) = 0.;
2115 chi2MatrixAft[0](2, 7) = 0.;
2116 chi2MatrixAft[0](2, 8) = 0.;
2117 chi2MatrixAft[0](2, 9) = 0.;
2118 chi2MatrixAft[0](3, 0) = 0.;
2119 chi2MatrixAft[0](3, 1) = 0.;
2120 chi2MatrixAft[0](3, 2) = 0.;
2121 chi2MatrixAft[0](3, 3) = 0.;
2122 chi2MatrixAft[0](3, 4) = 0.;
2123 chi2MatrixAft[0](3, 5) = 0.;
2124 chi2MatrixAft[0](3, 6) = 0.;
2125 chi2MatrixAft[0](3, 7) = 0.;
2126 chi2MatrixAft[0](3, 8) = 0.;
2127 chi2MatrixAft[0](3, 9) = 0.;
2128 chi2MatrixAft[0](4, 0) = 0.;
2129 chi2MatrixAft[0](4, 1) = 0.;
2130 chi2MatrixAft[0](4, 2) = 0.;
2131 chi2MatrixAft[0](4, 3) = 0.;
2132 chi2MatrixAft[0](4, 4) = 0.8030884;
2133 chi2MatrixAft[0](4, 5) = -0.2543541;
2134 chi2MatrixAft[0](4, 6) = -0.2243544;
2135 chi2MatrixAft[0](4, 7) = -0.1698177;
2136 chi2MatrixAft[0](4, 8) = -0.1194506;
2137 chi2MatrixAft[0](4, 9) = 0.;
2138 chi2MatrixAft[0](5, 0) = 0.;
2139 chi2MatrixAft[0](5, 1) = 0.;
2140 chi2MatrixAft[0](5, 2) = 0.;
2141 chi2MatrixAft[0](5, 3) = 0.;
2142 chi2MatrixAft[0](5, 4) = -0.2543541;
2143 chi2MatrixAft[0](5, 5) = 0.6714465;
2144 chi2MatrixAft[0](5, 6) = -0.2898025;
2145 chi2MatrixAft[0](5, 7) = -0.2193564;
2146 chi2MatrixAft[0](5, 8) = -0.1542964;
2147 chi2MatrixAft[0](5, 9) = 0.;
2148 chi2MatrixAft[0](6, 0) = 0.;
2149 chi2MatrixAft[0](6, 1) = 0.;
2150 chi2MatrixAft[0](6, 2) = 0.;
2151 chi2MatrixAft[0](6, 3) = 0.;
2152 chi2MatrixAft[0](6, 4) = -0.2243544;
2153 chi2MatrixAft[0](6, 5) = -0.2898025;
2154 chi2MatrixAft[0](6, 6) = 0.7443781;
2155 chi2MatrixAft[0](6, 7) = -0.1934846;
2156 chi2MatrixAft[0](6, 8) = -0.136098;
2157 chi2MatrixAft[0](6, 9) = 0.;
2158 chi2MatrixAft[0](7, 0) = 0.;
2159 chi2MatrixAft[0](7, 1) = 0.;
2160 chi2MatrixAft[0](7, 2) = 0.;
2161 chi2MatrixAft[0](7, 3) = 0.;
2162 chi2MatrixAft[0](7, 4) = -0.1698177;
2163 chi2MatrixAft[0](7, 5) = -0.2193564;
2164 chi2MatrixAft[0](7, 6) = -0.1934846;
2165 chi2MatrixAft[0](7, 7) = 0.8535482;
2166 chi2MatrixAft[0](7, 8) = -0.1030149;
2167 chi2MatrixAft[0](7, 9) = 0.;
2168 chi2MatrixAft[0](8, 0) = 0.;
2169 chi2MatrixAft[0](8, 1) = 0.;
2170 chi2MatrixAft[0](8, 2) = 0.;
2171 chi2MatrixAft[0](8, 3) = 0.;
2172 chi2MatrixAft[0](8, 4) = -0.1194506;
2173 chi2MatrixAft[0](8, 5) = -0.1542964;
2174 chi2MatrixAft[0](8, 6) = -0.136098;
2175 chi2MatrixAft[0](8, 7) = -0.1030149;
2176 chi2MatrixAft[0](8, 8) = 0.9275388;
2177 chi2MatrixAft[0](8, 9) = 0.;
2178 chi2MatrixAft[0](9, 0) = 0.;
2179 chi2MatrixAft[0](9, 1) = 0.;
2180 chi2MatrixAft[0](9, 2) = 0.;
2181 chi2MatrixAft[0](9, 3) = 0.;
2182 chi2MatrixAft[0](9, 4) = 0.;
2183 chi2MatrixAft[0](9, 5) = 0.;
2184 chi2MatrixAft[0](9, 6) = 0.;
2185 chi2MatrixAft[0](9, 7) = 0.;
2186 chi2MatrixAft[0](9, 8) = 0.;
2187 chi2MatrixAft[0](9, 9) = 0.;
2188 } else if (getWeightsFromFile_) {
2189
2190 edm::LogInfo("EcalTrivialConditionRetriever")
2191 << "Reading chi2MatrixAft from file " << edm::FileInPath(chi2MatrixAftFile_).fullPath().c_str();
2192 std::ifstream chi2MatrixAftFile(edm::FileInPath(chi2MatrixAftFile_).fullPath().c_str());
2193 int tdcBin = 0;
2194 while (!chi2MatrixAftFile.eof() && tdcBin < nTDCbins_) {
2195
2196 for (int j = 0; j < 10; ++j) {
2197 for (int l = 0; l < 10; ++l) {
2198 float ww;
2199 chi2MatrixAftFile >> ww;
2200 chi2MatrixAft[tdcBin](j, l) = ww;
2201 }
2202 }
2203 ++tdcBin;
2204 }
2205 assert(tdcBin == nTDCbins_);
2206 } else {
2207
2208 edm::LogError("EcalTrivialConditionRetriever") << "Configuration not supported. Exception is raised ";
2209 throw cms::Exception("WrongConfig");
2210 }
2211
2212
2213
2214
2215 chi2MatrixAft_ = chi2MatrixAft;
2216
2217 }
2218
2219
2220
2221 std::unique_ptr<EcalChannelStatus> EcalTrivialConditionRetriever::getChannelStatusFromConfiguration(
2222 const EcalChannelStatusRcd&) {
2223 auto ecalStatus = std::make_unique<EcalChannelStatus>();
2224
2225
2226
2227
2228 for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
2229 if (ieta == 0)
2230 continue;
2231 for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
2232 if (EBDetId::validDetId(ieta, iphi)) {
2233 EBDetId ebid(ieta, iphi);
2234 ecalStatus->setValue(ebid, 0);
2235 }
2236 }
2237 }
2238
2239 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
2240 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
2241
2242 if (EEDetId::validDetId(iX, iY, 1)) {
2243 EEDetId eedetidpos(iX, iY, 1);
2244 ecalStatus->setValue(eedetidpos, 0);
2245 }
2246 if (EEDetId::validDetId(iX, iY, -1)) {
2247 EEDetId eedetidneg(iX, iY, -1);
2248 ecalStatus->setValue(eedetidneg, 0);
2249 }
2250 }
2251 }
2252
2253
2254
2255 edm::LogInfo("EcalTrivialConditionRetriever")
2256 << "Reading channel statuses from file " << edm::FileInPath(channelStatusFile_).fullPath().c_str();
2257 std::ifstream statusFile(edm::FileInPath(channelStatusFile_).fullPath().c_str());
2258 if (!statusFile.good()) {
2259 edm::LogError("EcalTrivialConditionRetriever") << "*** Problems opening file: " << channelStatusFile_;
2260 throw cms::Exception("Cannot open ECAL channel status file");
2261 }
2262
2263 std::string EcalSubDet;
2264 std::string str;
2265 int hashIndex(0);
2266 int status(0);
2267
2268 while (!statusFile.eof()) {
2269 statusFile >> EcalSubDet;
2270 if (EcalSubDet != std::string("EB") && EcalSubDet != std::string("EE")) {
2271 std::getline(statusFile, str);
2272 continue;
2273 } else {
2274 statusFile >> hashIndex >> status;
2275 }
2276
2277
2278 if (EcalSubDet == std::string("EB")) {
2279 EBDetId ebid = EBDetId::unhashIndex(hashIndex);
2280 ecalStatus->setValue(ebid, status);
2281 } else if (EcalSubDet == std::string("EE")) {
2282 EEDetId eedetid = EEDetId::unhashIndex(hashIndex);
2283 ecalStatus->setValue(eedetid, status);
2284 } else {
2285 edm::LogError("EcalTrivialConditionRetriever") << " *** " << EcalSubDet << " is neither EB nor EE ";
2286 }
2287 }
2288
2289
2290 statusFile.close();
2291 return ecalStatus;
2292 }
2293
2294 std::unique_ptr<EcalChannelStatus> EcalTrivialConditionRetriever::produceEcalChannelStatus(const EcalChannelStatusRcd&) {
2295 auto ical = std::make_unique<EcalChannelStatus>();
2296
2297 for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
2298 if (ieta == 0)
2299 continue;
2300 for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
2301 if (EBDetId::validDetId(ieta, iphi)) {
2302 EBDetId ebid(ieta, iphi);
2303 ical->setValue(ebid, 0);
2304 }
2305 }
2306 }
2307
2308 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
2309 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
2310
2311 if (EEDetId::validDetId(iX, iY, 1)) {
2312 EEDetId eedetidpos(iX, iY, 1);
2313 ical->setValue(eedetidpos, 0);
2314 }
2315 if (EEDetId::validDetId(iX, iY, -1)) {
2316 EEDetId eedetidneg(iX, iY, -1);
2317 ical->setValue(eedetidneg, 0);
2318 }
2319 }
2320 }
2321 return ical;
2322 }
2323
2324
2325 std::unique_ptr<EcalDQMChannelStatus> EcalTrivialConditionRetriever::produceEcalDQMChannelStatus(
2326 const EcalDQMChannelStatusRcd&) {
2327 uint32_t sta(0);
2328
2329 auto ical = std::make_unique<EcalDQMChannelStatus>();
2330
2331 for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
2332 if (ieta == 0)
2333 continue;
2334 for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
2335 if (EBDetId::validDetId(ieta, iphi)) {
2336 EBDetId ebid(ieta, iphi);
2337 ical->setValue(ebid, sta);
2338 }
2339 }
2340 }
2341
2342 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
2343 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
2344
2345 if (EEDetId::validDetId(iX, iY, 1)) {
2346 EEDetId eedetidpos(iX, iY, 1);
2347 ical->setValue(eedetidpos, sta);
2348 }
2349 if (EEDetId::validDetId(iX, iY, -1)) {
2350 EEDetId eedetidneg(iX, iY, -1);
2351 ical->setValue(eedetidneg, sta);
2352 }
2353 }
2354 }
2355 return ical;
2356 }
2357
2358
2359 std::unique_ptr<EcalDQMTowerStatus> EcalTrivialConditionRetriever::produceEcalDQMTowerStatus(
2360 const EcalDQMTowerStatusRcd&) {
2361 auto ical = std::make_unique<EcalDQMTowerStatus>();
2362
2363 uint32_t sta(0);
2364
2365
2366 int iz = 0;
2367 for (int k = 0; k < 2; k++) {
2368 if (k == 0)
2369 iz = -1;
2370 if (k == 1)
2371 iz = +1;
2372 for (int i = 1; i < 73; i++) {
2373 for (int j = 1; j < 18; j++) {
2374 if (EcalTrigTowerDetId::validDetId(iz, EcalBarrel, j, i)) {
2375 EcalTrigTowerDetId ebid(iz, EcalBarrel, j, i);
2376
2377 ical->setValue(ebid, sta);
2378 }
2379 }
2380 }
2381 }
2382
2383
2384 for (int k = 0; k < 2; k++) {
2385 if (k == 0)
2386 iz = -1;
2387 if (k == 1)
2388 iz = +1;
2389 for (int i = 1; i < 21; i++) {
2390 for (int j = 1; j < 21; j++) {
2391 if (EcalScDetId::validDetId(i, j, iz)) {
2392 EcalScDetId eeid(i, j, iz);
2393 ical->setValue(eeid, sta);
2394 }
2395 }
2396 }
2397 }
2398
2399 return ical;
2400 }
2401
2402
2403 std::unique_ptr<EcalDCSTowerStatus> EcalTrivialConditionRetriever::produceEcalDCSTowerStatus(
2404 const EcalDCSTowerStatusRcd&) {
2405 auto ical = std::make_unique<EcalDCSTowerStatus>();
2406
2407 int status(0);
2408
2409
2410 int iz = 0;
2411 for (int k = 0; k < 2; k++) {
2412 if (k == 0)
2413 iz = -1;
2414 if (k == 1)
2415 iz = +1;
2416 for (int i = 1; i < 73; i++) {
2417 for (int j = 1; j < 18; j++) {
2418 if (EcalTrigTowerDetId::validDetId(iz, EcalBarrel, j, i)) {
2419 EcalTrigTowerDetId ebid(iz, EcalBarrel, j, i);
2420
2421 ical->setValue(ebid, status);
2422 }
2423 }
2424 }
2425 }
2426
2427
2428 for (int k = 0; k < 2; k++) {
2429 if (k == 0)
2430 iz = -1;
2431 if (k == 1)
2432 iz = +1;
2433 for (int i = 1; i < 21; i++) {
2434 for (int j = 1; j < 21; j++) {
2435 if (EcalScDetId::validDetId(i, j, iz)) {
2436 EcalScDetId eeid(i, j, iz);
2437 ical->setValue(eeid, status);
2438 }
2439 }
2440 }
2441 }
2442
2443 return ical;
2444 }
2445
2446
2447 std::unique_ptr<EcalDAQTowerStatus> EcalTrivialConditionRetriever::produceEcalDAQTowerStatus(
2448 const EcalDAQTowerStatusRcd&) {
2449 auto ical = std::make_unique<EcalDAQTowerStatus>();
2450
2451 int status(0);
2452
2453
2454 int iz = 0;
2455 for (int k = 0; k < 2; k++) {
2456 if (k == 0)
2457 iz = -1;
2458 if (k == 1)
2459 iz = +1;
2460 for (int i = 1; i < 73; i++) {
2461 for (int j = 1; j < 18; j++) {
2462 if (EcalTrigTowerDetId::validDetId(iz, EcalBarrel, j, i)) {
2463 EcalTrigTowerDetId ebid(iz, EcalBarrel, j, i);
2464
2465 ical->setValue(ebid, status);
2466 }
2467 }
2468 }
2469 }
2470
2471
2472 for (int k = 0; k < 2; k++) {
2473 if (k == 0)
2474 iz = -1;
2475 if (k == 1)
2476 iz = +1;
2477 for (int i = 1; i < 21; i++) {
2478 for (int j = 1; j < 21; j++) {
2479 if (EcalScDetId::validDetId(i, j, iz)) {
2480 EcalScDetId eeid(i, j, iz);
2481 ical->setValue(eeid, status);
2482 }
2483 }
2484 }
2485 }
2486
2487 return ical;
2488 }
2489
2490
2491 std::unique_ptr<EcalTPGCrystalStatus> EcalTrivialConditionRetriever::getTrgChannelStatusFromConfiguration(
2492 const EcalTPGCrystalStatusRcd&) {
2493 auto ecalStatus = std::make_unique<EcalTPGCrystalStatus>();
2494
2495
2496
2497
2498 for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
2499 if (ieta == 0)
2500 continue;
2501 for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
2502 if (EBDetId::validDetId(ieta, iphi)) {
2503 EBDetId ebid(ieta, iphi);
2504 ecalStatus->setValue(ebid, 0);
2505 }
2506 }
2507 }
2508
2509 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
2510 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
2511
2512 if (EEDetId::validDetId(iX, iY, 1)) {
2513 EEDetId eedetidpos(iX, iY, 1);
2514 ecalStatus->setValue(eedetidpos, 0);
2515 }
2516 if (EEDetId::validDetId(iX, iY, -1)) {
2517 EEDetId eedetidneg(iX, iY, -1);
2518 ecalStatus->setValue(eedetidneg, 0);
2519 }
2520 }
2521 }
2522
2523
2524
2525 edm::LogInfo("EcalTrivialConditionRetriever")
2526 << "Reading channel statuses from file " << edm::FileInPath(channelStatusFile_).fullPath().c_str();
2527 std::ifstream statusFile(edm::FileInPath(channelStatusFile_).fullPath().c_str());
2528 if (!statusFile.good()) {
2529 edm::LogError("EcalTrivialConditionRetriever") << "*** Problems opening file: " << channelStatusFile_;
2530 throw cms::Exception("Cannot open ECAL channel status file");
2531 }
2532
2533 std::string EcalSubDet;
2534 std::string str;
2535 int hashIndex(0);
2536 int status(0);
2537
2538 while (!statusFile.eof()) {
2539 statusFile >> EcalSubDet;
2540 if (EcalSubDet != std::string("EB") && EcalSubDet != std::string("EE")) {
2541 std::getline(statusFile, str);
2542 continue;
2543 } else {
2544 statusFile >> hashIndex >> status;
2545 }
2546
2547
2548 if (EcalSubDet == std::string("EB")) {
2549 EBDetId ebid = EBDetId::unhashIndex(hashIndex);
2550 ecalStatus->setValue(ebid, status);
2551 } else if (EcalSubDet == std::string("EE")) {
2552 EEDetId eedetid = EEDetId::unhashIndex(hashIndex);
2553 ecalStatus->setValue(eedetid, status);
2554 } else {
2555 edm::LogError("EcalTrivialConditionRetriever") << " *** " << EcalSubDet << " is neither EB nor EE ";
2556 }
2557 }
2558
2559
2560 statusFile.close();
2561 return ecalStatus;
2562 }
2563
2564 std::unique_ptr<EcalTPGCrystalStatus> EcalTrivialConditionRetriever::produceEcalTrgChannelStatus(
2565 const EcalTPGCrystalStatusRcd&) {
2566 auto ical = std::make_unique<EcalTPGCrystalStatus>();
2567
2568 for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
2569 if (ieta == 0)
2570 continue;
2571 for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
2572 if (EBDetId::validDetId(ieta, iphi)) {
2573 EBDetId ebid(ieta, iphi);
2574 ical->setValue(ebid, 0);
2575 }
2576 }
2577 }
2578
2579 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
2580 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
2581
2582 if (EEDetId::validDetId(iX, iY, 1)) {
2583 EEDetId eedetidpos(iX, iY, 1);
2584 ical->setValue(eedetidpos, 0);
2585 }
2586 if (EEDetId::validDetId(iX, iY, -1)) {
2587 EEDetId eedetidneg(iX, iY, -1);
2588 ical->setValue(eedetidneg, 0);
2589 }
2590 }
2591 }
2592 return ical;
2593 }
2594
2595 std::unique_ptr<EcalIntercalibConstants> EcalTrivialConditionRetriever::getIntercalibConstantsFromConfiguration(
2596 const EcalIntercalibConstantsRcd&) {
2597 std::unique_ptr<EcalIntercalibConstants> ical;
2598
2599
2600
2601
2602
2603 edm::LogInfo("EcalTrivialConditionRetriever")
2604 << "Reading intercalibration constants from file " << intercalibConstantsFile_.c_str();
2605
2606 if (intercalibConstantsFile_.find(".xml") != std::string::npos) {
2607 edm::LogInfo("generating Intercalib from xml file");
2608
2609 EcalCondHeader h;
2610 EcalIntercalibConstants* rcd = new EcalIntercalibConstants;
2611 EcalIntercalibConstantsXMLTranslator::readXML(intercalibConstantsFile_, h, *rcd);
2612
2613 if (totLumi_ != 0 || instLumi_ != 0) {
2614 edm::LogInfo("implementing ageing for intercalib");
2615
2616 EcalIntercalibConstantsMC* rcdMC = new EcalIntercalibConstantsMC;
2617
2618 if (intercalibConstantsMCFile_.find(".xml") != std::string::npos) {
2619 edm::LogInfo("generating IntercalibMC from xml file");
2620
2621 EcalCondHeader h;
2622 EcalIntercalibConstantsMCXMLTranslator::readXML(intercalibConstantsMCFile_, h, *rcdMC);
2623
2624 } else {
2625 edm::LogInfo("please provide the xml file of the EcalIntercalibConstantsMC");
2626 }
2627
2628 TRandom3* gRandom = new TRandom3();
2629
2630 EnergyResolutionVsLumi ageing;
2631 ageing.setLumi(totLumi_);
2632 ageing.setInstLumi(instLumi_);
2633
2634 const EcalIntercalibConstantMap& mymap = rcd->getMap();
2635 const EcalIntercalibConstantMCMap& mymapMC = rcdMC->getMap();
2636
2637 for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
2638 if (ieta == 0)
2639 continue;
2640
2641 double eta = EBDetId::approxEta(EBDetId(ieta, 1));
2642 eta = fabs(eta);
2643 double constantTerm = ageing.calcresolutitonConstantTerm(eta);
2644 edm::LogInfo("EB at eta=") << eta << " constant term is " << constantTerm;
2645
2646 for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
2647
2648 if (EBDetId::validDetId(ieta, iphi)) {
2649 EBDetId ebid(ieta, iphi);
2650 EcalIntercalibConstants::const_iterator idref = mymap.find(ebid);
2651 EcalIntercalibConstant icalconstant = 1;
2652 if (idref != mymap.end())
2653 icalconstant = (*idref);
2654
2655 EcalIntercalibConstantsMC::const_iterator idrefMC = mymapMC.find(ebid);
2656 EcalIntercalibConstantMC icalconstantMC = 1;
2657 if (idrefMC != mymapMC.end())
2658 icalconstantMC = (*idrefMC);
2659
2660 double r = gRandom->Gaus(0, constantTerm);
2661
2662 if (iphi == 10)
2663 edm::LogInfo("EB at eta=") << eta << " IC=" << icalconstant << " ICMC=" << icalconstantMC
2664 << " smear=" << r << " ";
2665
2666 icalconstant = icalconstant + r * 1.29 * icalconstantMC;
2667 rcd->setValue(ebid.rawId(), icalconstant);
2668
2669 if (iphi == 10)
2670 edm::LogInfo("newIC=") << icalconstant;
2671
2672 EcalIntercalibConstant icalconstant2 = (*idref);
2673 if (icalconstant != icalconstant2)
2674 edm::LogInfo(">>>> error in smearing intercalib");
2675 }
2676 }
2677 }
2678
2679 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
2680 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
2681
2682 if (EEDetId::validDetId(iX, iY, 1)) {
2683 EEDetId eedetidpos(iX, iY, 1);
2684 double eta =
2685 -log(tan(0.5 * atan(sqrt((iX - 50.0) * (iX - 50.0) + (iY - 50.0) * (iY - 50.0)) * 2.98 / 328.)));
2686 eta = fabs(eta);
2687 double constantTerm = ageing.calcresolutitonConstantTerm(eta);
2688 if (iX == 50)
2689 edm::LogInfo("EE at eta=") << eta << " constant term is " << constantTerm;
2690
2691 EcalIntercalibConstants::const_iterator idref = mymap.find(eedetidpos);
2692 EcalIntercalibConstant icalconstant = 1;
2693 if (idref != mymap.end())
2694 icalconstant = (*idref);
2695
2696 EcalIntercalibConstantsMC::const_iterator idrefMC = mymapMC.find(eedetidpos);
2697 EcalIntercalibConstantMC icalconstantMC = 1;
2698 if (idrefMC != mymapMC.end())
2699 icalconstantMC = (*idrefMC);
2700
2701 double r = gRandom->Gaus(0, constantTerm);
2702
2703 if (iX == 10)
2704 edm::LogInfo("EE at eta=") << eta << " IC=" << icalconstant << " ICMC=" << icalconstantMC
2705 << " smear=" << r << " ";
2706 icalconstant = icalconstant + r * 1.29 * icalconstantMC;
2707 rcd->setValue(eedetidpos.rawId(), icalconstant);
2708 if (iX == 10)
2709 edm::LogInfo("newIC=") << icalconstant;
2710 }
2711 if (EEDetId::validDetId(iX, iY, -1)) {
2712 EEDetId eedetidneg(iX, iY, -1);
2713 double eta =
2714 -log(tan(0.5 * atan(sqrt((iX - 50.0) * (iX - 50.0) + (iY - 50.0) * (iY - 50.0)) * 2.98 / 328.)));
2715 eta = fabs(eta);
2716 double constantTerm = ageing.calcresolutitonConstantTerm(eta);
2717 EcalIntercalibConstant icalconstant = 1;
2718
2719 EcalIntercalibConstantsMC::const_iterator idrefMC = mymapMC.find(eedetidneg);
2720 EcalIntercalibConstantMC icalconstantMC = 1;
2721 if (idrefMC != mymapMC.end())
2722 icalconstantMC = (*idrefMC);
2723
2724 double r = gRandom->Gaus(0, constantTerm);
2725 icalconstant = icalconstant + r * 1.29 * icalconstantMC;
2726 rcd->setValue(eedetidneg.rawId(), icalconstant);
2727 }
2728 }
2729 }
2730
2731 ical = std::unique_ptr<EcalIntercalibConstants>(rcd);
2732
2733 delete gRandom;
2734 }
2735
2736 } else {
2737 ical = std::make_unique<EcalIntercalibConstants>();
2738
2739 FILE* inpFile;
2740 inpFile = fopen(intercalibConstantsFile_.c_str(), "r");
2741 if (!inpFile) {
2742 edm::LogError("EcalTrivialConditionRetriever") << "*** Can not open file: " << intercalibConstantsFile_;
2743 throw cms::Exception("Cannot open inter-calibration coefficients txt file");
2744 }
2745
2746 char line[256];
2747 std::ostringstream str;
2748 fgets(line, 255, inpFile);
2749 int sm_number = atoi(line);
2750 str << "sm: " << sm_number;
2751
2752 fgets(line, 255, inpFile);
2753
2754
2755 fgets(line, 255, inpFile);
2756 std::string gen_tag = line;
2757 str << "gen tag: " << gen_tag;
2758
2759 fgets(line, 255, inpFile);
2760 std::string cali_method = line;
2761 str << "cali method: " << cali_method << std::endl;
2762
2763 fgets(line, 255, inpFile);
2764 std::string cali_version = line;
2765 str << "cali version: " << cali_version << std::endl;
2766
2767 fgets(line, 255, inpFile);
2768 std::string cali_type = line;
2769 str << "cali type: " << cali_type;
2770
2771 edm::LogInfo("EcalTrivialConditionRetriever") << "[PIETRO] Intercalibration file - " << str.str();
2772
2773 float calib[1700] = {1};
2774 int calib_status[1700] = {0};
2775
2776 int ii = 0;
2777
2778 while (fgets(line, 255, inpFile)) {
2779 ii++;
2780 int dmy_num = 0;
2781 float dmy_calib = 0.;
2782 float dmy_RMS = 0.;
2783 int dmy_events = 0;
2784 int dmy_status = 0;
2785 sscanf(line, "%d %f %f %d %d", &dmy_num, &dmy_calib, &dmy_RMS, &dmy_events, &dmy_status);
2786 assert(dmy_num >= 1);
2787 assert(dmy_num <= 1700);
2788 calib[dmy_num - 1] = dmy_calib;
2789 calib_status[dmy_num - 1] = dmy_status;
2790
2791
2792
2793
2794
2795
2796
2797
2798 }
2799
2800 fclose(inpFile);
2801 edm::LogInfo("EcalTrivialConditionRetriever") << "Read intercalibrations for " << ii << " xtals ";
2802 if (ii != 1700)
2803 edm::LogWarning("StoreEcalCondition") << "Some crystals missing, set to 1" << std::endl;
2804
2805
2806
2807
2808
2809 int sm_db = 1;
2810
2811 for (int i = 0; i < 1700; i++) {
2812
2813
2814
2815
2816
2817
2818
2819 if (sm_db >= EBDetId::MIN_SM && sm_db <= EBDetId::MAX_SM) {
2820 EBDetId ebid(sm_db, i + 1, EBDetId::SMCRYSTALMODE);
2821 if (calib_status[i])
2822 ical->setValue(ebid.rawId(), calib[i]);
2823 else
2824 ical->setValue(ebid.rawId(), 1.);
2825 }
2826
2827 }
2828 }
2829
2830 return ical;
2831 }
2832
2833
2834
2835 std::unique_ptr<EcalPFRecHitThresholds> EcalTrivialConditionRetriever::getPFRecHitThresholdsFromConfiguration(
2836 const EcalPFRecHitThresholdsRcd&) {
2837 std::unique_ptr<EcalPFRecHitThresholds> ical;
2838
2839
2840 edm::LogInfo("EcalTrivialConditionRetriever")
2841 << "Reading PF RecHit Thresholds from file " << edm::FileInPath(pfRecHitFile_).fullPath().c_str();
2842
2843 std::ifstream PFRecHitsFile(edm::FileInPath(pfRecHitFile_).fullPath().c_str());
2844
2845 ical = std::make_unique<EcalPFRecHitThresholds>();
2846
2847
2848
2849 int nxt = 0;
2850
2851 edm::LogInfo("Going to multiply the sigmas by ") << pfRecHitThresholdsNSigmas_;
2852 edm::LogInfo("We will print some values ");
2853
2854 while (!PFRecHitsFile.eof()) {
2855
2856 float thresh;
2857 int eta = 0;
2858 int phi = 0;
2859 int zeta = 0;
2860 PFRecHitsFile >> eta >> phi >> zeta >> thresh;
2861
2862
2863 thresh = thresh * pfRecHitThresholdsNSigmas_;
2864
2865 if (phi == 50)
2866 edm::LogInfo("EB ") << std::dec << eta << "/" << std::dec << phi << "/" << std::dec << zeta
2867 << " thresh: " << thresh;
2868 nxt = nxt + 1;
2869 if (EBDetId::validDetId(eta, phi)) {
2870 EBDetId ebid(eta, phi);
2871 ical->setValue(ebid.rawId(), thresh);
2872 }
2873 }
2874 PFRecHitsFile.close();
2875
2876
2877 edm::LogInfo("Read number of EB crystals: ") << nxt;
2878
2879
2880 edm::LogInfo("Now reading the EE file ... ");
2881 edm::LogInfo("We will multiply the sigma in EE by ") << pfRecHitThresholdsNSigmas_;
2882 edm::LogInfo("We will multiply the sigma in EE at high eta by") << pfRecHitThresholdsNSigmasHEta_;
2883 edm::LogInfo("We will print some values ");
2884
2885 edm::LogInfo("EcalTrivialConditionRetriever")
2886 << "Reading PF RecHit Thresholds EE from file " << edm::FileInPath(pfRecHitFileEE_).fullPath().c_str();
2887 std::ifstream PFRecHitsFileEE(edm::FileInPath(pfRecHitFileEE_).fullPath().c_str());
2888
2889 nxt = 0;
2890
2891 while (!PFRecHitsFileEE.eof()) {
2892
2893 float thresh;
2894 int ix = 0;
2895 int iy = 0;
2896 int iz = 0;
2897 PFRecHitsFileEE >> ix >> iy >> iz >> thresh;
2898
2899
2900 double eta =
2901 -log(tan(0.5 * atan(sqrt((ix - 50.5) * (ix - 50.5) + (iy - 50.5) * (iy - 50.5)) * 2.98 / 328.)));
2902
2903 if (eta > 2.5) {
2904 thresh = thresh * pfRecHitThresholdsNSigmasHEta_;
2905 } else {
2906 thresh = thresh * pfRecHitThresholdsNSigmas_;
2907 }
2908
2909 if (ix == 50)
2910 edm::LogInfo("EE ") << std::dec << ix << "/" << std::dec << iy << "/" << std::dec << iz << " thresh: " << thresh;
2911 if (EEDetId::validDetId(ix, iy, iz)) {
2912 EEDetId eeid(ix, iy, iz);
2913 ical->setValue(eeid.rawId(), thresh);
2914 }
2915 nxt = nxt + 1;
2916 }
2917 PFRecHitsFileEE.close();
2918
2919 edm::LogInfo("Read number of EE crystals: ") << nxt;
2920 edm::LogInfo("end PF Rec Hits ... ");
2921
2922 return ical;
2923 }
2924
2925 std::unique_ptr<EcalIntercalibConstantsMC> EcalTrivialConditionRetriever::getIntercalibConstantsMCFromConfiguration(
2926 const EcalIntercalibConstantsMCRcd&) {
2927 std::unique_ptr<EcalIntercalibConstantsMC> ical;
2928
2929
2930
2931
2932
2933 edm::LogInfo("EcalTrivialConditionRetriever")
2934 << "Reading intercalibration constants MC from file " << intercalibConstantsMCFile_.c_str();
2935
2936 if (intercalibConstantsMCFile_.find(".xml") != std::string::npos) {
2937 edm::LogInfo("generating Intercalib MC from xml file");
2938
2939 EcalCondHeader h;
2940 EcalIntercalibConstantsMC* rcd = new EcalIntercalibConstantsMC;
2941 EcalIntercalibConstantsMCXMLTranslator::readXML(intercalibConstantsMCFile_, h, *rcd);
2942
2943 ical = std::unique_ptr<EcalIntercalibConstants>(rcd);
2944
2945 } else {
2946 edm::LogInfo("ERROR>>> please provide a xml file");
2947 }
2948
2949 return ical;
2950 }
2951
2952 std::unique_ptr<EcalIntercalibErrors> EcalTrivialConditionRetriever::getIntercalibErrorsFromConfiguration(
2953 const EcalIntercalibErrorsRcd&) {
2954 auto ical = std::make_unique<EcalIntercalibErrors>();
2955
2956
2957
2958
2959 edm::LogInfo("EcalTrivialConditionRetriever")
2960 << "Reading intercalibration constants from file " << intercalibErrorsFile_.c_str();
2961
2962 FILE* inpFile;
2963 inpFile = fopen(intercalibErrorsFile_.c_str(), "r");
2964 if (!inpFile) {
2965 edm::LogError("EcalTrivialConditionRetriever") << "*** Can not open file: " << intercalibErrorsFile_;
2966 throw cms::Exception("Cannot open inter-calibration coefficients txt file");
2967 }
2968
2969 char line[256];
2970 std::ostringstream str;
2971 fgets(line, 255, inpFile);
2972 int sm_number = atoi(line);
2973 str << "sm: " << sm_number;
2974
2975 fgets(line, 255, inpFile);
2976
2977
2978 fgets(line, 255, inpFile);
2979 std::string gen_tag = line;
2980 str << "gen tag: " << gen_tag;
2981
2982 fgets(line, 255, inpFile);
2983 std::string cali_method = line;
2984 str << "cali method: " << cali_method << std::endl;
2985
2986 fgets(line, 255, inpFile);
2987 std::string cali_version = line;
2988 str << "cali version: " << cali_version << std::endl;
2989
2990 fgets(line, 255, inpFile);
2991 std::string cali_type = line;
2992 str << "cali type: " << cali_type;
2993
2994 edm::LogInfo("EcalTrivialConditionRetriever") << "[PIETRO] Intercalibration file - " << str.str() << std::endl;
2995
2996 float calib[1700] = {1};
2997 int calib_status[1700] = {0};
2998
2999 int ii = 0;
3000
3001 while (fgets(line, 255, inpFile)) {
3002 ii++;
3003 int dmy_num = 0;
3004 float dmy_calib = 0.;
3005 float dmy_RMS = 0.;
3006 int dmy_events = 0;
3007 int dmy_status = 0;
3008 sscanf(line, "%d %f %f %d %d", &dmy_num, &dmy_calib, &dmy_RMS, &dmy_events, &dmy_status);
3009 assert(dmy_num >= 1);
3010 assert(dmy_num <= 1700);
3011 calib[dmy_num - 1] = dmy_calib;
3012 calib_status[dmy_num - 1] = dmy_status;
3013
3014
3015
3016
3017
3018
3019
3020
3021 }
3022
3023 fclose(inpFile);
3024 edm::LogInfo("EcalTrivialConditionRetriever") << "Read intercalibrations for " << ii << " xtals ";
3025 if (ii != 1700)
3026 edm::LogWarning("StoreEcalCondition") << "Some crystals missing, set to 1" << std::endl;
3027
3028
3029
3030
3031
3032 int sm_db = 1;
3033
3034 for (int i = 0; i < 1700; i++) {
3035
3036
3037
3038
3039
3040
3041
3042 if (sm_db >= EBDetId::MIN_SM && sm_db <= EBDetId::MAX_SM) {
3043 EBDetId ebid(sm_db, i + 1, EBDetId::SMCRYSTALMODE);
3044 if (calib_status[i])
3045 ical->setValue(ebid.rawId(), calib[i]);
3046 else
3047 ical->setValue(ebid.rawId(), 1.);
3048 }
3049
3050 }
3051
3052
3053 return ical;
3054 }
3055
3056
3057
3058 std::unique_ptr<EcalTimeCalibConstants> EcalTrivialConditionRetriever::getTimeCalibConstantsFromConfiguration(
3059 const EcalTimeCalibConstantsRcd&) {
3060 auto ical = std::make_unique<EcalTimeCalibConstants>();
3061
3062
3063
3064
3065 edm::LogInfo("EcalTrivialConditionRetriever")
3066 << "Reading time calibration constants from file " << timeCalibConstantsFile_.c_str();
3067
3068 FILE* inpFile;
3069 inpFile = fopen(timeCalibConstantsFile_.c_str(), "r");
3070 if (!inpFile) {
3071 edm::LogError("EcalTrivialConditionRetriever") << "*** Can not open file: " << timeCalibConstantsFile_;
3072 throw cms::Exception("Cannot open inter-calibration coefficients txt file");
3073 }
3074
3075 char line[256];
3076 std::ostringstream str;
3077 fgets(line, 255, inpFile);
3078 int sm_number = atoi(line);
3079 str << "sm: " << sm_number;
3080
3081 fgets(line, 255, inpFile);
3082
3083
3084 fgets(line, 255, inpFile);
3085 std::string gen_tag = line;
3086 str << "gen tag: " << gen_tag;
3087
3088 fgets(line, 255, inpFile);
3089 std::string cali_method = line;
3090 str << "cali method: " << cali_method << std::endl;
3091
3092 fgets(line, 255, inpFile);
3093 std::string cali_version = line;
3094 str << "cali version: " << cali_version << std::endl;
3095
3096 fgets(line, 255, inpFile);
3097 std::string cali_type = line;
3098 str << "cali type: " << cali_type;
3099
3100 edm::LogInfo("EcalTrivialConditionRetriever") << "TimeCalibration file - " << str.str() << std::endl;
3101
3102 float calib[1700] = {1};
3103 int calib_status[1700] = {0};
3104
3105 int ii = 0;
3106
3107 while (fgets(line, 255, inpFile)) {
3108 ii++;
3109 int dmy_num = 0;
3110 float dmy_calib = 0.;
3111 float dmy_RMS = 0.;
3112 int dmy_events = 0;
3113 int dmy_status = 0;
3114 sscanf(line, "%d %f %f %d %d", &dmy_num, &dmy_calib, &dmy_RMS, &dmy_events, &dmy_status);
3115 assert(dmy_num >= 1);
3116 assert(dmy_num <= 1700);
3117 calib[dmy_num - 1] = dmy_calib;
3118 calib_status[dmy_num - 1] = dmy_status;
3119
3120
3121
3122
3123
3124
3125
3126
3127 }
3128
3129 fclose(inpFile);
3130 edm::LogInfo("EcalTrivialConditionRetriever") << "Read timeCalibrations for " << ii << " xtals ";
3131 if (ii != 1700)
3132 edm::LogWarning("StoreEcalCondition") << "Some crystals missing, set to 1" << std::endl;
3133
3134
3135
3136
3137
3138 int sm_db = 1;
3139
3140 for (int i = 0; i < 1700; i++) {
3141
3142
3143
3144
3145
3146
3147
3148 if (sm_db >= EBDetId::MIN_SM && sm_db <= EBDetId::MAX_SM) {
3149 EBDetId ebid(sm_db, i + 1, EBDetId::SMCRYSTALMODE);
3150 if (calib_status[i])
3151 ical->setValue(ebid.rawId(), calib[i]);
3152 else
3153 ical->setValue(ebid.rawId(), 1.);
3154 }
3155
3156 }
3157
3158
3159 return ical;
3160 }
3161
3162 std::unique_ptr<EcalTimeCalibErrors> EcalTrivialConditionRetriever::getTimeCalibErrorsFromConfiguration(
3163 const EcalTimeCalibErrorsRcd&) {
3164 auto ical = std::make_unique<EcalTimeCalibErrors>();
3165
3166
3167
3168
3169 edm::LogInfo("EcalTrivialConditionRetriever")
3170 << "Reading timeCalibration constants from file " << timeCalibErrorsFile_.c_str();
3171
3172 FILE* inpFile;
3173 inpFile = fopen(timeCalibErrorsFile_.c_str(), "r");
3174 if (!inpFile) {
3175 edm::LogError("EcalTrivialConditionRetriever") << "*** Can not open file: " << timeCalibErrorsFile_;
3176 throw cms::Exception("Cannot open inter-calibration coefficients txt file");
3177 }
3178
3179 char line[256];
3180 std::ostringstream str;
3181 fgets(line, 255, inpFile);
3182 int sm_number = atoi(line);
3183 str << "sm: " << sm_number;
3184
3185 fgets(line, 255, inpFile);
3186
3187
3188 fgets(line, 255, inpFile);
3189 std::string gen_tag = line;
3190 str << "gen tag: " << gen_tag;
3191
3192 fgets(line, 255, inpFile);
3193 std::string cali_method = line;
3194 str << "cali method: " << cali_method << std::endl;
3195
3196 fgets(line, 255, inpFile);
3197 std::string cali_version = line;
3198 str << "cali version: " << cali_version << std::endl;
3199
3200 fgets(line, 255, inpFile);
3201 std::string cali_type = line;
3202 str << "cali type: " << cali_type;
3203
3204 edm::LogInfo("EcalTrivialConditionRetriever") << "TimeCalibration file - " << str.str() << std::endl;
3205
3206 float calib[1700] = {1};
3207 int calib_status[1700] = {0};
3208
3209 int ii = 0;
3210
3211 while (fgets(line, 255, inpFile)) {
3212 ii++;
3213 int dmy_num = 0;
3214 float dmy_calib = 0.;
3215 float dmy_RMS = 0.;
3216 int dmy_events = 0;
3217 int dmy_status = 0;
3218 sscanf(line, "%d %f %f %d %d", &dmy_num, &dmy_calib, &dmy_RMS, &dmy_events, &dmy_status);
3219 assert(dmy_num >= 1);
3220 assert(dmy_num <= 1700);
3221 calib[dmy_num - 1] = dmy_calib;
3222 calib_status[dmy_num - 1] = dmy_status;
3223
3224
3225
3226
3227
3228
3229
3230
3231 }
3232
3233 fclose(inpFile);
3234 edm::LogInfo("EcalTrivialConditionRetriever") << "Read time calibrations for " << ii << " xtals ";
3235 if (ii != 1700)
3236 edm::LogWarning("StoreEcalCondition") << "Some crystals missing, set to 1" << std::endl;
3237
3238
3239
3240
3241
3242 int sm_db = 1;
3243
3244 for (int i = 0; i < 1700; i++) {
3245
3246
3247
3248
3249
3250
3251
3252 if (sm_db >= EBDetId::MIN_SM && sm_db <= EBDetId::MAX_SM) {
3253 EBDetId ebid(sm_db, i + 1, EBDetId::SMCRYSTALMODE);
3254 if (calib_status[i])
3255 ical->setValue(ebid.rawId(), calib[i]);
3256 else
3257 ical->setValue(ebid.rawId(), 1.);
3258 }
3259
3260 }
3261
3262
3263 return ical;
3264 }
3265
3266
3267
3268 std::unique_ptr<EcalMappingElectronics> EcalTrivialConditionRetriever::getMappingFromConfiguration(
3269 const EcalMappingElectronicsRcd&) {
3270 auto mapping = std::make_unique<EcalMappingElectronics>();
3271 edm::LogInfo("EcalTrivialConditionRetriever")
3272 << "Reading mapping from file " << edm::FileInPath(mappingFile_).fullPath().c_str();
3273
3274 std::ifstream f(edm::FileInPath(mappingFile_).fullPath().c_str());
3275 if (!f.good()) {
3276 edm::LogError("EcalTrivialConditionRetriever") << "File not found";
3277 throw cms::Exception("FileNotFound");
3278 }
3279
3280
3281
3282 int ix, iy, iz, CL;
3283
3284
3285 int dccid, towerid, pseudostrip_in_SC, xtal_in_pseudostrip;
3286 int tccid, tower, pseudostrip_in_TCC, pseudostrip_in_TT;
3287
3288 while (!f.eof()) {
3289
3290 f >> ix >> iy >> iz >> CL >> dccid >> towerid >> pseudostrip_in_SC >> xtal_in_pseudostrip >> tccid >> tower >>
3291 pseudostrip_in_TCC >> pseudostrip_in_TT;
3292
3293
3294
3295
3296 EEDetId detid(ix, iy, iz, EEDetId::XYMODE);
3297
3298 EcalElectronicsId elecid(dccid, towerid, pseudostrip_in_SC, xtal_in_pseudostrip);
3299
3300 EcalTriggerElectronicsId triggerid(tccid, tower, pseudostrip_in_TT, xtal_in_pseudostrip);
3301 EcalMappingElement aElement;
3302 aElement.electronicsid = elecid.rawId();
3303 aElement.triggerid = triggerid.rawId();
3304 (*mapping).setValue(detid, aElement);
3305 }
3306
3307 f.close();
3308 return mapping;
3309 }
3310
3311 std::unique_ptr<EcalMappingElectronics> EcalTrivialConditionRetriever::produceEcalMappingElectronics(
3312 const EcalMappingElectronicsRcd&) {
3313 auto ical = std::make_unique<EcalMappingElectronics>();
3314 return ical;
3315 }
3316
3317
3318
3319 std::unique_ptr<Alignments> EcalTrivialConditionRetriever::produceEcalAlignmentEB(const EBAlignmentRcd&) {
3320 double mytrans[3] = {0., 0., 0.};
3321 double myeuler[3] = {0., 0., 0.};
3322 std::ifstream f;
3323 if (getEBAlignmentFromFile_)
3324 f.open(edm::FileInPath(EBAlignmentFile_).fullPath().c_str());
3325 std::vector<AlignTransform> my_align;
3326 int ieta = 1;
3327 int iphi = 0;
3328 for (int SM = 1; SM < 37; SM++) {
3329
3330 if (SM > 18) {
3331 iphi = 1 + (SM - 19) * 20;
3332 ieta = -1;
3333 } else
3334 iphi = SM * 20;
3335 EBDetId ebdetId(ieta, iphi);
3336 if (getEBAlignmentFromFile_) {
3337 f >> myeuler[0] >> myeuler[1] >> myeuler[2] >> mytrans[0] >> mytrans[1] >> mytrans[2];
3338 edm::LogInfo(" translation ") << mytrans[0] << " " << mytrans[1] << " " << mytrans[2] << "\n"
3339 << " euler " << myeuler[0] << " " << myeuler[1] << " " << myeuler[2];
3340 }
3341 CLHEP::Hep3Vector translation(mytrans[0], mytrans[1], mytrans[2]);
3342 CLHEP::HepEulerAngles euler(myeuler[0], myeuler[1], myeuler[2]);
3343 AlignTransform transform(translation, euler, ebdetId);
3344 my_align.push_back(transform);
3345 }
3346
3347
3348
3349
3350
3351
3352
3353
3354
3355
3356
3357
3358
3359
3360
3361
3362
3363
3364
3365
3366
3367 Alignments a;
3368 a.m_align = my_align;
3369
3370 return std::make_unique<Alignments>(a);
3371 }
3372
3373 std::unique_ptr<Alignments> EcalTrivialConditionRetriever::produceEcalAlignmentEE(const EEAlignmentRcd&) {
3374 double mytrans[3] = {0., 0., 0.};
3375 double myeuler[3] = {0., 0., 0.};
3376 std::ifstream f;
3377 if (getEEAlignmentFromFile_)
3378 f.open(edm::FileInPath(EEAlignmentFile_).fullPath().c_str());
3379 std::vector<AlignTransform> my_align;
3380 int ix = 20;
3381 int iy = 50;
3382 int side = -1;
3383 for (int Dee = 0; Dee < 4; Dee++) {
3384
3385 if (Dee == 1 || Dee == 3)
3386 ix = 70;
3387 else
3388 ix = 20;
3389 if (Dee == 2)
3390 side = 1;
3391 EEDetId eedetId(ix, iy, side);
3392 if (getEEAlignmentFromFile_) {
3393 f >> myeuler[0] >> myeuler[1] >> myeuler[2] >> mytrans[0] >> mytrans[1] >> mytrans[2];
3394 edm::LogInfo(" translation ") << mytrans[0] << " " << mytrans[1] << " " << mytrans[2] << "\n"
3395 << " euler " << myeuler[0] << " " << myeuler[1] << " " << myeuler[2];
3396 }
3397 CLHEP::Hep3Vector translation(mytrans[0], mytrans[1], mytrans[2]);
3398 CLHEP::HepEulerAngles euler(myeuler[0], myeuler[1], myeuler[2]);
3399 AlignTransform transform(translation, euler, eedetId);
3400 my_align.push_back(transform);
3401 }
3402 Alignments a;
3403 a.m_align = my_align;
3404 return std::make_unique<Alignments>(a);
3405 }
3406
3407 std::unique_ptr<Alignments> EcalTrivialConditionRetriever::produceEcalAlignmentES(const ESAlignmentRcd&) {
3408 double mytrans[3] = {0., 0., 0.};
3409 double myeuler[3] = {0., 0., 0.};
3410 std::ifstream f;
3411 if (getESAlignmentFromFile_)
3412 f.open(edm::FileInPath(ESAlignmentFile_).fullPath().c_str());
3413 std::vector<AlignTransform> my_align;
3414
3415 int pl_vect[10] = {2, 2, 1, 1, 1, 1, 2, 2};
3416 int iy = 10;
3417 int side = -1;
3418 int strip = 1;
3419 for (int layer = 0; layer < 8; layer++) {
3420
3421 int ix = 10 + (layer % 2) * 20;
3422 int plane = pl_vect[layer];
3423 if (layer > 3)
3424 side = 1;
3425 ESDetId esdetId(strip, ix, iy, plane, side);
3426 if (getESAlignmentFromFile_) {
3427 f >> myeuler[0] >> myeuler[1] >> myeuler[2] >> mytrans[0] >> mytrans[1] >> mytrans[2];
3428 edm::LogInfo(" translation ") << mytrans[0] << " " << mytrans[1] << " " << mytrans[2] << "\n"
3429 << " euler " << myeuler[0] << " " << myeuler[1] << " " << myeuler[2];
3430 }
3431 CLHEP::Hep3Vector translation(mytrans[0], mytrans[1], mytrans[2]);
3432 CLHEP::HepEulerAngles euler(myeuler[0], myeuler[1], myeuler[2]);
3433 AlignTransform transform(translation, euler, esdetId);
3434 my_align.push_back(transform);
3435 }
3436 Alignments a;
3437 a.m_align = my_align;
3438 return std::make_unique<Alignments>(a);
3439 }
3440
3441 std::unique_ptr<EcalSampleMask> EcalTrivialConditionRetriever::produceEcalSampleMask(const EcalSampleMaskRcd&) {
3442 return std::make_unique<EcalSampleMask>(sampleMaskEB_, sampleMaskEE_);
3443 }
3444
3445 std::unique_ptr<EcalTimeBiasCorrections> EcalTrivialConditionRetriever::produceEcalTimeBiasCorrections(
3446 const EcalTimeBiasCorrectionsRcd&) {
3447 auto ipar = std::make_unique<EcalTimeBiasCorrections>();
3448 copy(EBtimeCorrAmplitudeBins_.begin(), EBtimeCorrAmplitudeBins_.end(), back_inserter(ipar->EBTimeCorrAmplitudeBins));
3449 copy(EBtimeCorrShiftBins_.begin(), EBtimeCorrShiftBins_.end(), back_inserter(ipar->EBTimeCorrShiftBins));
3450 copy(EEtimeCorrAmplitudeBins_.begin(), EEtimeCorrAmplitudeBins_.end(), back_inserter(ipar->EETimeCorrAmplitudeBins));
3451 copy(EEtimeCorrShiftBins_.begin(), EEtimeCorrShiftBins_.end(), back_inserter(ipar->EETimeCorrShiftBins));
3452 return ipar;
3453 }
3454
3455 std::unique_ptr<EcalSamplesCorrelation> EcalTrivialConditionRetriever::produceEcalSamplesCorrelation(
3456 const EcalSamplesCorrelationRcd&) {
3457 if (getSamplesCorrelationFromFile_) {
3458 std::ifstream f;
3459 f.open(edm::FileInPath(SamplesCorrelationFile_).fullPath().c_str());
3460 float ww;
3461 for (int j = 0; j < 10; ++j) {
3462 f >> ww;
3463 EBG12samplesCorrelation_.push_back(ww);
3464 }
3465 for (int j = 0; j < 10; ++j) {
3466 f >> ww;
3467 EBG6samplesCorrelation_.push_back(ww);
3468 }
3469 for (int j = 0; j < 10; ++j) {
3470 f >> ww;
3471 EBG1samplesCorrelation_.push_back(ww);
3472 }
3473 for (int j = 0; j < 10; ++j) {
3474 f >> ww;
3475 EEG12samplesCorrelation_.push_back(ww);
3476 }
3477 for (int j = 0; j < 10; ++j) {
3478 f >> ww;
3479 EEG6samplesCorrelation_.push_back(ww);
3480 }
3481 for (int j = 0; j < 10; ++j) {
3482 f >> ww;
3483 EEG1samplesCorrelation_.push_back(ww);
3484 }
3485 f.close();
3486 }
3487 auto ipar = std::make_unique<EcalSamplesCorrelation>();
3488 copy(EBG12samplesCorrelation_.begin(), EBG12samplesCorrelation_.end(), back_inserter(ipar->EBG12SamplesCorrelation));
3489 copy(EBG6samplesCorrelation_.begin(), EBG6samplesCorrelation_.end(), back_inserter(ipar->EBG6SamplesCorrelation));
3490 copy(EBG1samplesCorrelation_.begin(), EBG1samplesCorrelation_.end(), back_inserter(ipar->EBG1SamplesCorrelation));
3491 copy(EEG12samplesCorrelation_.begin(), EEG12samplesCorrelation_.end(), back_inserter(ipar->EEG12SamplesCorrelation));
3492 copy(EEG6samplesCorrelation_.begin(), EEG6samplesCorrelation_.end(), back_inserter(ipar->EEG6SamplesCorrelation));
3493 copy(EEG1samplesCorrelation_.begin(), EEG1samplesCorrelation_.end(), back_inserter(ipar->EEG1SamplesCorrelation));
3494 return ipar;
3495 }
3496
3497 std::unique_ptr<EcalSimPulseShape> EcalTrivialConditionRetriever::getEcalSimPulseShapeFromConfiguration(
3498 const EcalSimPulseShapeRcd&) {
3499 auto result = std::make_unique<EcalSimPulseShape>();
3500
3501
3502 result->time_interval = sim_pulse_shape_TI_;
3503
3504
3505 std::vector<double> EBshape;
3506 std::vector<double> EEshape;
3507 std::vector<double> APDshape;
3508
3509
3510 if (!EBSimPulseShapeFile_.empty()) {
3511 std::ifstream shapeEBFile;
3512 shapeEBFile.open(EBSimPulseShapeFile_.c_str());
3513 double ww;
3514 while (shapeEBFile >> ww)
3515 EBshape.push_back(ww);
3516 shapeEBFile.close();
3517 }
3518 if (!EESimPulseShapeFile_.empty()) {
3519 std::ifstream shapeEEFile;
3520 shapeEEFile.open(EESimPulseShapeFile_.c_str());
3521 double ww;
3522 while (shapeEEFile >> ww)
3523 EEshape.push_back(ww);
3524 shapeEEFile.close();
3525 }
3526 if (!APDSimPulseShapeFile_.empty()) {
3527 std::ifstream shapeAPDFile;
3528 shapeAPDFile.open(APDSimPulseShapeFile_.c_str());
3529 double ww;
3530 while (shapeAPDFile >> ww)
3531 APDshape.push_back(ww);
3532 shapeAPDFile.close();
3533 }
3534
3535
3536 result->barrel_thresh = sim_pulse_shape_EB_thresh_;
3537 result->endcap_thresh = sim_pulse_shape_EE_thresh_;
3538 result->apd_thresh = sim_pulse_shape_APD_thresh_;
3539
3540
3541 copy(EBshape.begin(), EBshape.end(), back_inserter(result->barrel_shape));
3542 copy(EEshape.begin(), EEshape.end(), back_inserter(result->endcap_shape));
3543 copy(APDshape.begin(), APDshape.end(), back_inserter(result->apd_shape));
3544
3545 return result;
3546 }