EcalDBCopy.cc

Go to the documentation of this file.

#include "FWCore/ServiceRegistry/interface/Service.h"
#include "CondCore/DBOutputService/interface/PoolDBOutputService.h"

#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/EventSetup.h"

#include "CondTools/Ecal/interface/EcalDBCopy.h"
#include "CondFormats/EcalObjects/interface/EcalPedestals.h"
#include "CondFormats/DataRecord/interface/EcalPedestalsRcd.h"
#include "CondFormats/EcalObjects/interface/EcalADCToGeVConstant.h"
#include "CondFormats/DataRecord/interface/EcalADCToGeVConstantRcd.h"
#include "CondFormats/EcalObjects/interface/EcalTimeCalibConstants.h"
#include "CondFormats/DataRecord/interface/EcalTimeCalibConstantsRcd.h"
#include "CondFormats/EcalObjects/interface/EcalChannelStatus.h"
#include "CondFormats/DataRecord/interface/EcalChannelStatusRcd.h"
#include "CondFormats/EcalObjects/interface/EcalLinearCorrections.h"
#include "CondFormats/DataRecord/interface/EcalLinearCorrectionsRcd.h"
#include "CondFormats/EcalObjects/interface/EcalIntercalibConstants.h"
#include "CondFormats/DataRecord/interface/EcalIntercalibConstantsRcd.h"
#include "CondFormats/EcalObjects/interface/EcalIntercalibConstantsMC.h"
#include "CondFormats/DataRecord/interface/EcalIntercalibConstantsMCRcd.h"
#include "CondFormats/EcalObjects/interface/EcalIntercalibErrors.h"
#include "CondFormats/DataRecord/interface/EcalIntercalibErrorsRcd.h"
#include "CondFormats/EcalObjects/interface/EcalGainRatios.h"
#include "CondFormats/DataRecord/interface/EcalGainRatiosRcd.h"
#include "CondFormats/EcalObjects/interface/EcalWeightXtalGroups.h"
#include "CondFormats/DataRecord/interface/EcalWeightXtalGroupsRcd.h"
#include "CondFormats/EcalObjects/interface/EcalTBWeights.h"
#include "CondFormats/DataRecord/interface/EcalTBWeightsRcd.h"
#include "CondFormats/EcalObjects/interface/EcalLaserAlphas.h"
#include "CondFormats/DataRecord/interface/EcalLaserAlphasRcd.h"
#include "CondFormats/EcalObjects/interface/EcalLaserAPDPNRatios.h"
#include "CondFormats/DataRecord/interface/EcalLaserAPDPNRatiosRcd.h"
#include "CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosRef.h"
#include "CondFormats/DataRecord/interface/EcalLaserAPDPNRatiosRefRcd.h"
#include "CondFormats/EcalObjects/interface/EcalTPGCrystalStatus.h"
#include "CondFormats/DataRecord/interface/EcalTPGCrystalStatusRcd.h"
#include "CondFormats/EcalObjects/interface/EcalTPGTowerStatus.h"
#include "CondFormats/DataRecord/interface/EcalTPGTowerStatusRcd.h"

#include "CondFormats/EcalObjects/interface/EcalDCSTowerStatus.h"
#include "CondFormats/DataRecord/interface/EcalDCSTowerStatusRcd.h"
#include "CondFormats/EcalObjects/interface/EcalDAQTowerStatus.h"
#include "CondFormats/DataRecord/interface/EcalDAQTowerStatusRcd.h"
#include "CondFormats/EcalObjects/interface/EcalDQMTowerStatus.h"
#include "CondFormats/DataRecord/interface/EcalDQMTowerStatusRcd.h"
#include "CondFormats/EcalObjects/interface/EcalDQMChannelStatus.h"
#include "CondFormats/DataRecord/interface/EcalDQMChannelStatusRcd.h"

#include "CondFormats/EcalObjects/interface/EcalClusterCrackCorrParameters.h"
#include "CondFormats/DataRecord/interface/EcalClusterCrackCorrParametersRcd.h"

#include "CondFormats/EcalObjects/interface/EcalPFRecHitThresholds.h"
#include "CondFormats/DataRecord/interface/EcalPFRecHitThresholdsRcd.h"

#include "CondFormats/EcalObjects/interface/EcalClusterEnergyCorrectionParameters.h"
#include "CondFormats/DataRecord/interface/EcalClusterEnergyCorrectionParametersRcd.h"
#include "CondFormats/EcalObjects/interface/EcalClusterEnergyUncertaintyParameters.h"
#include "CondFormats/DataRecord/interface/EcalClusterEnergyUncertaintyParametersRcd.h"
#include "CondFormats/EcalObjects/interface/EcalClusterEnergyCorrectionObjectSpecificParameters.h"
#include "CondFormats/DataRecord/interface/EcalClusterEnergyCorrectionObjectSpecificParametersRcd.h"
#include "CondFormats/EcalObjects/interface/EcalClusterLocalContCorrParameters.h"
#include "CondFormats/DataRecord/interface/EcalClusterLocalContCorrParametersRcd.h"

#include "CondFormats/Alignment/interface/Alignments.h"
#include "CondFormats/AlignmentRecord/interface/EBAlignmentRcd.h"
#include "CondFormats/AlignmentRecord/interface/EEAlignmentRcd.h"
#include "CondFormats/AlignmentRecord/interface/ESAlignmentRcd.h"
#include "CondFormats/EcalObjects/interface/EcalTimeOffsetConstant.h"
#include "CondFormats/DataRecord/interface/EcalTimeOffsetConstantRcd.h"

#include "CondFormats/EcalObjects/interface/EcalSampleMask.h"
#include "CondFormats/DataRecord/interface/EcalSampleMaskRcd.h"

#include "CondFormats/EcalObjects/interface/EcalTimeBiasCorrections.h"
#include "CondFormats/DataRecord/interface/EcalTimeBiasCorrectionsRcd.h"

#include "CondFormats/EcalObjects/interface/EcalSamplesCorrelation.h"
#include "CondFormats/DataRecord/interface/EcalSamplesCorrelationRcd.h"

#include "CondFormats/EcalObjects/interface/EcalSimPulseShape.h"
#include "CondFormats/DataRecord/interface/EcalSimPulseShapeRcd.h"

#include <vector>

EcalDBCopy::EcalDBCopy(const edm::ParameterSet& iConfig)
    : m_timetype(iConfig.getParameter<std::string>("timetype")), m_cacheIDs(), m_records() {
  std::string container;
  std::string tag;
  std::string record;
  typedef std::vector<edm::ParameterSet> Parameters;
  Parameters toCopy = iConfig.getParameter<Parameters>("toCopy");
  for (Parameters::iterator i = toCopy.begin(); i != toCopy.end(); ++i) {
    container = i->getParameter<std::string>("container");
    record = i->getParameter<std::string>("record");
    m_cacheIDs.insert(std::make_pair(container, 0));
    m_records.insert(std::make_pair(container, record));
  }
}

EcalDBCopy::~EcalDBCopy() {}

void EcalDBCopy::analyze(const edm::Event& evt, const edm::EventSetup& evtSetup) {
  std::string container;
  std::string record;
  typedef std::map<std::string, std::string>::const_iterator recordIter;
  for (recordIter i = m_records.begin(); i != m_records.end(); ++i) {
    container = (*i).first;
    record = (*i).second;
    if (shouldCopy(evtSetup, container)) {
      copyToDB(evtSetup, container);
    }
  }
}

bool EcalDBCopy::shouldCopy(const edm::EventSetup& evtSetup, std::string container) {
  unsigned long long cacheID = 0;
  if (container == "EcalPedestals") {
    cacheID = evtSetup.get<EcalPedestalsRcd>().cacheIdentifier();
  } else if (container == "EcalADCToGeVConstant") {
    cacheID = evtSetup.get<EcalADCToGeVConstantRcd>().cacheIdentifier();
  } else if (container == "EcalLinearCorrections") {
    cacheID = evtSetup.get<EcalLinearCorrectionsRcd>().cacheIdentifier();
  } else if (container == "EcalIntercalibConstants") {
    cacheID = evtSetup.get<EcalIntercalibConstantsRcd>().cacheIdentifier();
  } else if (container == "EcalIntercalibConstantsMC") {
    cacheID = evtSetup.get<EcalIntercalibConstantsMCRcd>().cacheIdentifier();
  } else if (container == "EcalIntercalibErrors") {
    cacheID = evtSetup.get<EcalIntercalibErrorsRcd>().cacheIdentifier();
  } else if (container == "EcalGainRatios") {
    cacheID = evtSetup.get<EcalGainRatiosRcd>().cacheIdentifier();
  } else if (container == "EcalWeightXtalGroups") {
    cacheID = evtSetup.get<EcalWeightXtalGroupsRcd>().cacheIdentifier();
  } else if (container == "EcalTBWeights") {
    cacheID = evtSetup.get<EcalTBWeightsRcd>().cacheIdentifier();
  } else if (container == "EcalLaserAPDPNRatios") {
    cacheID = evtSetup.get<EcalLaserAPDPNRatiosRcd>().cacheIdentifier();
  } else if (container == "EcalLaserAPDPNRatiosRef") {
    cacheID = evtSetup.get<EcalTBWeightsRcd>().cacheIdentifier();
  } else if (container == "EcalLaserAlphas") {
    cacheID = evtSetup.get<EcalTBWeightsRcd>().cacheIdentifier();
  } else if (container == "EcalChannelStatus") {
    cacheID = evtSetup.get<EcalChannelStatusRcd>().cacheIdentifier();
  } else if (container == "EcalDQMTowerStatus") {
    cacheID = evtSetup.get<EcalDQMTowerStatusRcd>().cacheIdentifier();
  } else if (container == "EcalDQMChannelStatus") {
    cacheID = evtSetup.get<EcalDQMChannelStatusRcd>().cacheIdentifier();
  } else if (container == "EcalDCSTowerStatus") {
    cacheID = evtSetup.get<EcalDCSTowerStatusRcd>().cacheIdentifier();
  } else if (container == "EcalDAQTowerStatus") {
    cacheID = evtSetup.get<EcalDAQTowerStatusRcd>().cacheIdentifier();
  } else if (container == "EcalTimeCalibConstants") {
    cacheID = evtSetup.get<EcalTimeCalibConstantsRcd>().cacheIdentifier();
  } else if (container == "EcalClusterCrackCorrParameters") {
    cacheID = evtSetup.get<EcalClusterCrackCorrParametersRcd>().cacheIdentifier();
  } else if (container == "EcalPFRecHitThresholds") {
    cacheID = evtSetup.get<EcalPFRecHitThresholdsRcd>().cacheIdentifier();
  } else if (container == "EcalClusterEnergyUncertaintyParameters") {
    cacheID = evtSetup.get<EcalClusterEnergyUncertaintyParametersRcd>().cacheIdentifier();
  } else if (container == "EcalClusterEnergyCorrectionParameters") {
    cacheID = evtSetup.get<EcalClusterEnergyCorrectionParametersRcd>().cacheIdentifier();
  } else if (container == "EcalClusterEnergyCorrectionObjectSpecificParameters") {
    cacheID = evtSetup.get<EcalClusterEnergyCorrectionObjectSpecificParametersRcd>().cacheIdentifier();
  } else if (container == "EcalClusterLocalContCorrParameters") {
    cacheID = evtSetup.get<EcalClusterLocalContCorrParametersRcd>().cacheIdentifier();
  } else if (container == "EcalTPGCrystalStatus") {
    cacheID = evtSetup.get<EcalTPGCrystalStatusRcd>().cacheIdentifier();
  } else if (container == "EcalTPGTowerStatus") {
    cacheID = evtSetup.get<EcalTPGTowerStatusRcd>().cacheIdentifier();
  } else if (container == "EBAlignment") {
    cacheID = evtSetup.get<EBAlignmentRcd>().cacheIdentifier();
  } else if (container == "EEAlignment") {
    cacheID = evtSetup.get<EEAlignmentRcd>().cacheIdentifier();
  } else if (container == "ESAlignment") {
    cacheID = evtSetup.get<ESAlignmentRcd>().cacheIdentifier();
  } else if (container == "EcalTimeOffsetConstant") {
    cacheID = evtSetup.get<EcalTimeOffsetConstantRcd>().cacheIdentifier();
  } else if (container == "EcalSampleMask") {
    cacheID = evtSetup.get<EcalSampleMaskRcd>().cacheIdentifier();
  } else if (container == "EcalTimeBiasCorrections") {
    cacheID = evtSetup.get<EcalTimeBiasCorrectionsRcd>().cacheIdentifier();
  } else if (container == "EcalSimPulseShape") {
    cacheID = evtSetup.get<EcalSimPulseShapeRcd>().cacheIdentifier();
  } else if (container == "EcalSamplesCorrelation") {
    cacheID = evtSetup.get<EcalSamplesCorrelationRcd>().cacheIdentifier();
  }

  else {
    throw cms::Exception("Unknown container");
  }

  if (m_cacheIDs[container] == cacheID) {
    return false;
  } else {
    m_cacheIDs[container] = cacheID;
    return true;
  }
}

void EcalDBCopy::copyToDB(const edm::EventSetup& evtSetup, std::string container) {
  edm::Service<cond::service::PoolDBOutputService> dbOutput;
  if (!dbOutput.isAvailable()) {
    throw cms::Exception("PoolDBOutputService is not available");
  }

  std::string recordName = m_records[container];

  if (container == "EcalPedestals") {
    edm::ESHandle<EcalPedestals> handle;
    evtSetup.get<EcalPedestalsRcd>().get(handle);
    const EcalPedestals* obj = handle.product();
    std::cout << "ped pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const EcalPedestals>(
        new EcalPedestals(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalADCToGeVConstant") {
    edm::ESHandle<EcalADCToGeVConstant> handle;
    evtSetup.get<EcalADCToGeVConstantRcd>().get(handle);
    const EcalADCToGeVConstant* obj = handle.product();
    std::cout << "adc pointer is: " << obj << std::endl;

    dbOutput->createNewIOV<const EcalADCToGeVConstant>(
        new EcalADCToGeVConstant(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalTimeCalibConstants") {
    edm::ESHandle<EcalTimeCalibConstants> handle;
    evtSetup.get<EcalTimeCalibConstantsRcd>().get(handle);
    const EcalTimeCalibConstants* obj = handle.product();
    std::cout << "adc pointer is: " << obj << std::endl;

    dbOutput->createNewIOV<const EcalTimeCalibConstants>(
        new EcalTimeCalibConstants(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalChannelStatus") {
    edm::ESHandle<EcalChannelStatus> handle;
    evtSetup.get<EcalChannelStatusRcd>().get(handle);
    const EcalChannelStatus* obj = handle.product();
    std::cout << "channel status pointer is: " << obj << std::endl;

    dbOutput->createNewIOV<const EcalChannelStatus>(
        new EcalChannelStatus(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalDQMChannelStatus") {
    edm::ESHandle<EcalDQMChannelStatus> handle;
    evtSetup.get<EcalDQMChannelStatusRcd>().get(handle);
    const EcalDQMChannelStatus* obj = handle.product();
    std::cout << "DQM channel status pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const EcalDQMChannelStatus>(
        new EcalDQMChannelStatus(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalDQMTowerStatus") {
    edm::ESHandle<EcalDQMTowerStatus> handle;
    evtSetup.get<EcalDQMTowerStatusRcd>().get(handle);
    const EcalDQMTowerStatus* obj = handle.product();
    std::cout << "DQM Tower status pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const EcalDQMTowerStatus>(
        new EcalDQMTowerStatus(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalDCSTowerStatus") {
    edm::ESHandle<EcalDCSTowerStatus> handle;
    evtSetup.get<EcalDCSTowerStatusRcd>().get(handle);
    const EcalDCSTowerStatus* obj = handle.product();
    std::cout << "channel status pointer is: " << obj << std::endl;

    dbOutput->createNewIOV<const EcalDCSTowerStatus>(
        new EcalDCSTowerStatus(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalDAQTowerStatus") {
    edm::ESHandle<EcalDAQTowerStatus> handle;
    evtSetup.get<EcalDAQTowerStatusRcd>().get(handle);
    const EcalDAQTowerStatus* obj = handle.product();
    std::cout << "DAQ channel status pointer is: " << obj << std::endl;

    dbOutput->createNewIOV<const EcalDAQTowerStatus>(
        new EcalDAQTowerStatus(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalTPGCrystalStatus") {
    edm::ESHandle<EcalTPGCrystalStatus> handle;
    evtSetup.get<EcalTPGCrystalStatusRcd>().get(handle);
    const EcalTPGCrystalStatus* obj = handle.product();
    std::cout << "TPG channel status pointer is: " << obj << std::endl;

    dbOutput->createNewIOV<const EcalTPGCrystalStatus>(
        new EcalTPGCrystalStatus(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalTPGTowerStatus") {
    edm::ESHandle<EcalTPGTowerStatus> handle;
    evtSetup.get<EcalTPGTowerStatusRcd>().get(handle);
    const EcalTPGTowerStatus* obj = handle.product();
    std::cout << "TPG tower status pointer is: " << obj << std::endl;

    dbOutput->createNewIOV<const EcalTPGTowerStatus>(
        new EcalTPGTowerStatus(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalIntercalibConstants") {
    edm::ESHandle<EcalIntercalibConstants> handle;
    evtSetup.get<EcalIntercalibConstantsRcd>().get(handle);
    const EcalIntercalibConstants* obj = handle.product();
    std::cout << "inter pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const EcalIntercalibConstants>(
        new EcalIntercalibConstants(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalLinearCorrections") {
    edm::ESHandle<EcalLinearCorrections> handle;
    evtSetup.get<EcalLinearCorrectionsRcd>().get(handle);
    const EcalLinearCorrections* obj = handle.product();
    std::cout << "inter pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const EcalLinearCorrections>(
        new EcalLinearCorrections(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalIntercalibConstantsMC") {
    edm::ESHandle<EcalIntercalibConstantsMC> handle;
    evtSetup.get<EcalIntercalibConstantsMCRcd>().get(handle);
    const EcalIntercalibConstantsMC* obj = handle.product();
    std::cout << "intercalib MC pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const EcalIntercalibConstantsMC>(
        new EcalIntercalibConstantsMC(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalIntercalibErrors") {
    edm::ESHandle<EcalIntercalibErrors> handle;
    evtSetup.get<EcalIntercalibErrorsRcd>().get(handle);
    const EcalIntercalibErrors* obj = handle.product();
    std::cout << "inter pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const EcalIntercalibErrors>(
        new EcalIntercalibErrors(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalGainRatios") {
    edm::ESHandle<EcalGainRatios> handle;
    evtSetup.get<EcalGainRatiosRcd>().get(handle);
    const EcalGainRatios* obj = handle.product();
    std::cout << "gain pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const EcalGainRatios>(
        new EcalGainRatios(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalWeightXtalGroups") {
    edm::ESHandle<EcalWeightXtalGroups> handle;
    evtSetup.get<EcalWeightXtalGroupsRcd>().get(handle);
    const EcalWeightXtalGroups* obj = handle.product();
    std::cout << "weight pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const EcalWeightXtalGroups>(
        new EcalWeightXtalGroups(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalTBWeights") {
    edm::ESHandle<EcalTBWeights> handle;
    evtSetup.get<EcalTBWeightsRcd>().get(handle);
    const EcalTBWeights* obj = handle.product();
    std::cout << "tbweight pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const EcalTBWeights>(
        new EcalTBWeights(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalLaserAlphas") {
    edm::ESHandle<EcalLaserAlphas> handle;
    evtSetup.get<EcalLaserAlphasRcd>().get(handle);
    const EcalLaserAlphas* obj = handle.product();
    std::cout << "ecalLaserAlpha pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const EcalLaserAlphas>(
        new EcalLaserAlphas(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalLaserAPDPNRatios") {
    edm::ESHandle<EcalLaserAPDPNRatios> handle;
    evtSetup.get<EcalLaserAPDPNRatiosRcd>().get(handle);
    const EcalLaserAPDPNRatios* obj = handle.product();
    std::cout << "tbweight pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const EcalLaserAPDPNRatios>(
        new EcalLaserAPDPNRatios(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalLaserAPDPNRatiosRef") {
    edm::ESHandle<EcalLaserAPDPNRatiosRef> handle;
    evtSetup.get<EcalLaserAPDPNRatiosRefRcd>().get(handle);
    const EcalLaserAPDPNRatiosRef* obj = handle.product();
    std::cout << "tbweight pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const EcalLaserAPDPNRatiosRef>(
        new EcalLaserAPDPNRatiosRef(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalClusterCrackCorrParameters") {
    edm::ESHandle<EcalClusterCrackCorrParameters> handle;
    evtSetup.get<EcalClusterCrackCorrParametersRcd>().get(handle);
    const EcalClusterCrackCorrParameters* obj = handle.product();
    std::cout << "cluster crack pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const EcalClusterCrackCorrParameters>(
        new EcalClusterCrackCorrParameters(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalPFRecHitThresholds") {
    edm::ESHandle<EcalPFRecHitThresholds> handle;
    evtSetup.get<EcalPFRecHitThresholdsRcd>().get(handle);
    const EcalPFRecHitThresholds* obj = handle.product();
    std::cout << "Ecal PF rec hit thresholds pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const EcalPFRecHitThresholds>(
        new EcalPFRecHitThresholds(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalClusterEnergyUncertaintyParameters") {
    edm::ESHandle<EcalClusterEnergyUncertaintyParameters> handle;
    evtSetup.get<EcalClusterEnergyUncertaintyParametersRcd>().get(handle);
    const EcalClusterEnergyUncertaintyParameters* obj = handle.product();
    std::cout << "tbweight pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const EcalClusterEnergyUncertaintyParameters>(
        new EcalClusterEnergyUncertaintyParameters(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalClusterEnergyCorrectionParameters") {
    edm::ESHandle<EcalClusterEnergyCorrectionParameters> handle;
    evtSetup.get<EcalClusterEnergyCorrectionParametersRcd>().get(handle);
    const EcalClusterEnergyCorrectionParameters* obj = handle.product();
    std::cout << "tbweight pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const EcalClusterEnergyCorrectionParameters>(
        new EcalClusterEnergyCorrectionParameters(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalClusterEnergyCorrectionObjectSpecificParameters") {
    edm::ESHandle<EcalClusterEnergyCorrectionObjectSpecificParameters> handle;
    evtSetup.get<EcalClusterEnergyCorrectionObjectSpecificParametersRcd>().get(handle);
    const EcalClusterEnergyCorrectionObjectSpecificParameters* obj = handle.product();
    std::cout << "tbweight pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const EcalClusterEnergyCorrectionObjectSpecificParameters>(
        new EcalClusterEnergyCorrectionObjectSpecificParameters(*obj),
        dbOutput->beginOfTime(),
        dbOutput->endOfTime(),
        recordName);

  } else if (container == "EcalClusterLocalContCorrParameters") {
    edm::ESHandle<EcalClusterLocalContCorrParameters> handle;
    evtSetup.get<EcalClusterLocalContCorrParametersRcd>().get(handle);
    const EcalClusterLocalContCorrParameters* obj = handle.product();
    std::cout << "tbweight pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const EcalClusterLocalContCorrParameters>(
        new EcalClusterLocalContCorrParameters(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EBAlignment") {
    edm::ESHandle<Alignments> handle;
    evtSetup.get<EBAlignmentRcd>().get(handle);
    const Alignments* obj = handle.product();
    std::cout << "EB alignment pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const Alignments>(
        new Alignments(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EEAlignment") {
    edm::ESHandle<Alignments> handle;
    evtSetup.get<EEAlignmentRcd>().get(handle);
    const Alignments* obj = handle.product();
    std::cout << "EE alignment pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const Alignments>(
        new Alignments(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "ESAlignment") {
    edm::ESHandle<Alignments> handle;
    evtSetup.get<ESAlignmentRcd>().get(handle);
    const Alignments* obj = handle.product();
    std::cout << "ES alignment pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const Alignments>(
        new Alignments(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalTimeOffsetConstant") {
    edm::ESHandle<EcalTimeOffsetConstant> handle;
    evtSetup.get<EcalTimeOffsetConstantRcd>().get(handle);
    const EcalTimeOffsetConstant* obj = handle.product();
    std::cout << "TimeOffset pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const EcalTimeOffsetConstant>(
        new EcalTimeOffsetConstant(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalSampleMask") {
    edm::ESHandle<EcalSampleMask> handle;
    evtSetup.get<EcalSampleMaskRcd>().get(handle);
    const EcalSampleMask* obj = handle.product();
    std::cout << "sample mask pointer is: " << obj << std::endl;
    dbOutput->createNewIOV<const EcalSampleMask>(
        new EcalSampleMask(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalSimPulseShape") {
    edm::ESHandle<EcalSimPulseShape> handle;
    evtSetup.get<EcalSimPulseShapeRcd>().get(handle);
    const EcalSimPulseShape* obj = handle.product();
    dbOutput->createNewIOV<const EcalSimPulseShape>(
        new EcalSimPulseShape(*obj), dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);

  } else if (container == "EcalTimeBiasCorrections") {
    edm::ESHandle<EcalTimeBiasCorrections> handle;
    evtSetup.get<EcalTimeBiasCorrectionsRcd>().get(handle);
    const EcalTimeBiasCorrections* obj = handle.product();
    std::cout << "TimeBiasCorrections pointer is: " << obj << std::endl;
    EcalTimeBiasCorrections* bias_;
    bias_ = new EcalTimeBiasCorrections();
    std::vector<float> vect = obj->EBTimeCorrAmplitudeBins;
    copy(vect.begin(), vect.end(), back_inserter(bias_->EBTimeCorrAmplitudeBins));
    vect = obj->EBTimeCorrShiftBins;
    copy(vect.begin(), vect.end(), back_inserter(bias_->EBTimeCorrShiftBins));
    vect = obj->EETimeCorrAmplitudeBins;
    copy(vect.begin(), vect.end(), back_inserter(bias_->EETimeCorrAmplitudeBins));
    vect = obj->EETimeCorrShiftBins;
    copy(vect.begin(), vect.end(), back_inserter(bias_->EETimeCorrShiftBins));
    dbOutput->writeOne(bias_, dbOutput->beginOfTime(), "EcalTimeBiasCorrectionsRcd");

  } else if (container == "EcalSamplesCorrelation") {
    edm::ESHandle<EcalSamplesCorrelation> handle;
    evtSetup.get<EcalSamplesCorrelationRcd>().get(handle);
    const EcalSamplesCorrelation* obj = handle.product();
    std::cout << "SamplesCorrelation pointer is: " << obj << std::endl;
    EcalSamplesCorrelation* correl_;
    correl_ = new EcalSamplesCorrelation();
    std::vector<double> vect = obj->EBG12SamplesCorrelation;
    copy(vect.begin(), vect.end(), back_inserter(correl_->EBG12SamplesCorrelation));
    vect = obj->EBG6SamplesCorrelation;
    copy(vect.begin(), vect.end(), back_inserter(correl_->EBG6SamplesCorrelation));
    vect = obj->EBG1SamplesCorrelation;
    copy(vect.begin(), vect.end(), back_inserter(correl_->EBG1SamplesCorrelation));
    vect = obj->EEG12SamplesCorrelation;
    copy(vect.begin(), vect.end(), back_inserter(correl_->EEG12SamplesCorrelation));
    vect = obj->EEG6SamplesCorrelation;
    copy(vect.begin(), vect.end(), back_inserter(correl_->EEG6SamplesCorrelation));
    vect = obj->EEG1SamplesCorrelation;
    copy(vect.begin(), vect.end(), back_inserter(correl_->EEG1SamplesCorrelation));
    dbOutput->writeOne(correl_, dbOutput->beginOfTime(), "EcalSamplesCorrelationRcd");

  } else {
    throw cms::Exception("Unknown container");
  }

  std::cout << "EcalDBCopy wrote " << recordName << std::endl;
}