#include <EcalDBCopy.h>

Inheritance diagram for EcalDBCopy:

Public Member Functions
void	analyze (const edm::Event &evt, const edm::EventSetup &evtSetup) override

	EcalDBCopy (const edm::ParameterSet &iConfig)

	~EcalDBCopy () override

Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

	~EDAnalyzer () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	copyToDB (const edm::EventSetup &evtSetup, std::string container)

bool	shouldCopy (const edm::EventSetup &evtSetup, std::string container)

Private Attributes
std::map< std::string, unsigned long long >	m_cacheIDs

std::map< std::string, std::string >	m_records

std::string	m_timetype

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 18 of file EcalDBCopy.h.

Constructor & Destructor Documentation

EcalDBCopy::EcalDBCopy ( const edm::ParameterSet & iConfig )

explicit

Definition at line 88 of file EcalDBCopy.cc.

References edm::ParameterSet::getParameter(), mps_fire::i, m_cacheIDs, m_records, record, AlCaHLTBitMon_QueryRunRegistry::string, and GlobalPosition_Frontier_DevDB_cff::tag.

     : 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 ( )

override

Definition at line 103 of file EcalDBCopy.cc.

103 {}

Member Function Documentation

void EcalDBCopy::analyze	(	const edm::Event &	evt,
		const edm::EventSetup &	evtSetup
	)

override

Definition at line 105 of file EcalDBCopy.cc.

References copyToDB(), mps_fire::i, m_records, record, shouldCopy(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                            {
   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);
     }
   }
 }

void EcalDBCopy::copyToDB	(	const edm::EventSetup &	evtSetup,
		std::string	container
	)

private

Definition at line 202 of file EcalDBCopy.cc.

References cond::service::PoolDBOutputService::beginOfTime(), filterCSVwithJSON::copy, gather_cfg::cout, cond::service::PoolDBOutputService::createNewIOV(), EcalSamplesCorrelation::EBG12SamplesCorrelation, EcalSamplesCorrelation::EBG1SamplesCorrelation, EcalSamplesCorrelation::EBG6SamplesCorrelation, EcalTimeBiasCorrections::EBTimeCorrAmplitudeBins, EcalTimeBiasCorrections::EBTimeCorrShiftBins, EcalSamplesCorrelation::EEG12SamplesCorrelation, EcalSamplesCorrelation::EEG1SamplesCorrelation, EcalSamplesCorrelation::EEG6SamplesCorrelation, EcalTimeBiasCorrections::EETimeCorrAmplitudeBins, EcalTimeBiasCorrections::EETimeCorrShiftBins, cond::service::PoolDBOutputService::endOfTime(), Exception, edm::EventSetup::get(), patZpeak::handle, edm::Service< T >::isAvailable(), m_records, getGTfromDQMFile::obj, edm::ESHandle< T >::product(), align_cfg::recordName, AlCaHLTBitMon_QueryRunRegistry::string, and cond::service::PoolDBOutputService::writeOne().

Referenced by analyze().

                                                                             {
   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;
 }

bool EcalDBCopy::shouldCopy	(	const edm::EventSetup &	evtSetup,
		std::string	container
	)

private

Definition at line 118 of file EcalDBCopy.cc.

References Exception, edm::EventSetup::get(), and m_cacheIDs.

Referenced by analyze().

                                                                               {
   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;
   }
 }

Member Data Documentation

std::map<std::string, unsigned long long> EcalDBCopy::m_cacheIDs

private

Definition at line 30 of file EcalDBCopy.h.

Referenced by EcalDBCopy(), and shouldCopy().

std::map<std::string, std::string> EcalDBCopy::m_records

private

Definition at line 31 of file EcalDBCopy.h.

Referenced by analyze(), copyToDB(), and EcalDBCopy().

std::string EcalDBCopy::m_timetype

private

Definition at line 29 of file EcalDBCopy.h.

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation