#include <EcalTestDevDB.h>

Inheritance diagram for EcalTestDevDB:

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

	EcalTestDevDB (const edm::ParameterSet &iConfig)

std::shared_ptr< EcalADCToGeVConstant >	generateEcalADCToGeVConstant ()

std::shared_ptr< EcalGainRatios >	generateEcalGainRatios ()

std::shared_ptr< EcalIntercalibConstants >	generateEcalIntercalibConstants ()

std::shared_ptr< EcalLaserAlphas >	generateEcalLaserAlphas ()

std::shared_ptr< EcalLaserAPDPNRatios >	generateEcalLaserAPDPNRatios (uint32_t i_run)

std::shared_ptr< EcalLaserAPDPNRatiosRef >	generateEcalLaserAPDPNRatiosRef ()

std::shared_ptr< EcalLinearCorrections >	generateEcalLinearCorrections ()

std::shared_ptr< EcalPedestals >	generateEcalPedestals ()

std::shared_ptr< EcalTBWeights >	generateEcalTBWeights ()

std::shared_ptr< EcalWeightXtalGroups >	generateEcalWeightXtalGroups ()

	~EcalTestDevDB () override

Public Member Functions inherited from edm::one::EDAnalyzer<>
	EDAnalyzer ()=default

	EDAnalyzer (const EDAnalyzer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

const EDAnalyzer &	operator= (const EDAnalyzer &)=delete

bool	wantsGlobalLuminosityBlocks () const noexcept final

bool	wantsGlobalRuns () const noexcept final

bool	wantsInputProcessBlocks () const noexcept final

bool	wantsProcessBlocks () const noexcept final

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const noexcept

bool	wantsStreamRuns () const noexcept

	~EDAnalyzerBase () 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

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

std::vector< ESResolverIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (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::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, 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

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)

virtual	~EDConsumerBase () noexcept(false)

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

unsigned long	m_firstRun

unsigned int	m_interval

unsigned long	m_lastRun

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

std::string	m_timetype

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

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

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

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)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Definition at line 41 of file EcalTestDevDB.h.

Constructor & Destructor Documentation

◆ EcalTestDevDB()

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

explicit

Definition at line 24 of file EcalTestDevDB.cc.

References edm::ParameterSet::getParameter(), mps_fire::i, m_cacheIDs, m_firstRun, m_interval, m_lastRun, m_records, AlCaHarvesting_cff::record, AlCaHLTBitMon_QueryRunRegistry::string, and makeGlobalPositionRcd_cfg::tag.

     : m_timetype(iConfig.getParameter<std::string>("timetype")), m_cacheIDs(), m_records() {
   std::string container;
   std::string tag;
   std::string record;
 
   m_firstRun = static_cast<unsigned long>(atoi(iConfig.getParameter<std::string>("firstRun").c_str()));
   m_lastRun = static_cast<unsigned long>(atoi(iConfig.getParameter<std::string>("lastRun").c_str()));
   m_interval = static_cast<unsigned long>(atoi(iConfig.getParameter<std::string>("interval").c_str()));
 
   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));
   }
 }

◆ ~EcalTestDevDB()

EcalTestDevDB::~EcalTestDevDB ( )

override

Definition at line 44 of file EcalTestDevDB.cc.

44 {}

Member Function Documentation

◆ analyze()

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

overridevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 46 of file EcalTestDevDB.cc.

References cond::service::PoolDBOutputService::appendOneIOV(), cond::service::PoolDBOutputService::beginOfTime(), cond::service::PoolDBOutputService::createOneIOV(), edm::IOVSyncValue::endOfTime(), edm::IOVSyncValue::eventID(), Exception, generateEcalADCToGeVConstant(), generateEcalGainRatios(), generateEcalIntercalibConstants(), generateEcalLaserAlphas(), generateEcalLaserAPDPNRatios(), generateEcalLaserAPDPNRatiosRef(), generateEcalLinearCorrections(), generateEcalPedestals(), generateEcalTBWeights(), generateEcalWeightXtalGroups(), mps_fire::i, edm::Service< T >::isAvailable(), cond::service::PoolDBOutputService::isNewTagRequest(), m_firstRun, m_interval, m_lastRun, m_records, AlCaHarvesting_cff::record, align_cfg::recordName, edm::EventID::run(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                               {
   edm::Service<cond::service::PoolDBOutputService> dbOutput;
   if (!dbOutput.isAvailable()) {
     throw cms::Exception("PoolDBOutputService is not available");
   }
 
   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;
 
     std::string recordName = m_records[container];
 
     // Loop through each of the runs
 
     unsigned long nrec = (m_lastRun - m_firstRun) / m_interval + 1;
     unsigned long nstart = 0;
     if (m_firstRun == 0 && m_lastRun == 0) {
       // it should do at least once the loop
       nstart = 0;
       nrec = 1;
     }
 
     for (unsigned long i = nstart; i < nrec; i++) {
       unsigned long irun = m_firstRun + i * m_interval;
 
       // Arguments 0 0 mean infinite IOV
       if (m_firstRun == 0 && m_lastRun == 0) {
         edm::LogInfo("EcalTestDevDB") << "Infinite IOV mode";
         irun = edm::IOVSyncValue::endOfTime().eventID().run();
       }
 
       edm::LogInfo("EcalTestDevDB") << "Starting Transaction for run " << irun << "...";
 
       if (container == "EcalPedestals") {
         const auto condObject = generateEcalPedestals();
         if (irun == m_firstRun && dbOutput->isNewTagRequest(recordName)) {
           // create new
           edm::LogInfo("EcalTestDevDB") << "First One ";
           dbOutput->createOneIOV<const EcalPedestals>(*condObject, dbOutput->beginOfTime(), recordName);
         } else {
           // append
           edm::LogInfo("EcalTestDevDB") << "Old One ";
           dbOutput->appendOneIOV<const EcalPedestals>(*condObject, irun, recordName);
         }
 
       } else if (container == "EcalADCToGeVConstant") {
         const auto condObject = generateEcalADCToGeVConstant();
         if (irun == m_firstRun && dbOutput->isNewTagRequest(recordName)) {
           // create new
           edm::LogInfo("EcalTestDevDB") << "First One ";
           dbOutput->createOneIOV<const EcalADCToGeVConstant>(*condObject, dbOutput->beginOfTime(), recordName);
         } else {
           // append
           edm::LogInfo("EcalTestDevDB") << "Old One ";
           dbOutput->appendOneIOV<const EcalADCToGeVConstant>(*condObject, irun, recordName);
         }
 
       } else if (container == "EcalIntercalibConstants") {
         const auto condObject = generateEcalIntercalibConstants();
         if (irun == m_firstRun && dbOutput->isNewTagRequest(recordName)) {
           // create new
           edm::LogInfo("EcalTestDevDB") << "First One ";
           dbOutput->createOneIOV<const EcalIntercalibConstants>(*condObject, dbOutput->beginOfTime(), recordName);
         } else {
           // append
           edm::LogInfo("EcalTestDevDB") << "Old One ";
           dbOutput->appendOneIOV<const EcalIntercalibConstants>(*condObject, irun, recordName);
         }
       } else if (container == "EcalLinearCorrections") {
         const auto condObject = generateEcalLinearCorrections();
         if (irun == m_firstRun && dbOutput->isNewTagRequest(recordName)) {
           // create new
           edm::LogInfo("EcalTestDevDB") << "First One ";
           dbOutput->createOneIOV<const EcalLinearCorrections>(*condObject, dbOutput->beginOfTime(), recordName);
         } else {
           // append
           edm::LogInfo("EcalTestDevDB") << "Old One ";
           dbOutput->appendOneIOV<const EcalLinearCorrections>(*condObject, irun, recordName);
         }
 
       } else if (container == "EcalGainRatios") {
         const auto condObject = generateEcalGainRatios();
         if (irun == m_firstRun && dbOutput->isNewTagRequest(recordName)) {
           // create new
           edm::LogInfo("EcalTestDevDB") << "First One ";
           dbOutput->createOneIOV<const EcalGainRatios>(*condObject, dbOutput->beginOfTime(), recordName);
         } else {
           // append
           edm::LogInfo("EcalTestDevDB") << "Old One ";
           dbOutput->appendOneIOV<const EcalGainRatios>(*condObject, irun, recordName);
         }
 
       } else if (container == "EcalWeightXtalGroups") {
         const auto condObject = generateEcalWeightXtalGroups();
         if (irun == m_firstRun && dbOutput->isNewTagRequest(recordName)) {
           // create new
           edm::LogInfo("EcalTestDevDB") << "First One ";
           dbOutput->createOneIOV<const EcalWeightXtalGroups>(*condObject, dbOutput->beginOfTime(), recordName);
         } else {
           // append
           edm::LogInfo("EcalTestDevDB") << "Old One ";
           dbOutput->appendOneIOV<const EcalWeightXtalGroups>(*condObject, irun, recordName);
         }
 
       } else if (container == "EcalTBWeights") {
         const auto condObject = generateEcalTBWeights();
         if (irun == m_firstRun && dbOutput->isNewTagRequest(recordName)) {
           // create new
           edm::LogInfo("EcalTestDevDB") << "First One ";
           dbOutput->createOneIOV<const EcalTBWeights>(*condObject, dbOutput->beginOfTime(), recordName);
         } else {
           // append
           edm::LogInfo("EcalTestDevDB") << "Old One ";
           dbOutput->appendOneIOV<const EcalTBWeights>(*condObject, irun, recordName);
         }
 
       } else if (container == "EcalLaserAPDPNRatios") {
         const auto condObject = generateEcalLaserAPDPNRatios(irun);
         if (irun == m_firstRun && dbOutput->isNewTagRequest(recordName)) {
           // create new
           edm::LogInfo("EcalTestDevDB") << "First One ";
           dbOutput->createOneIOV<const EcalLaserAPDPNRatios>(*condObject, dbOutput->beginOfTime(), recordName);
         } else {
           // append
           edm::LogInfo("EcalTestDevDB") << "Old One ";
           dbOutput->appendOneIOV<const EcalLaserAPDPNRatios>(*condObject, irun, recordName);
         }
       } else if (container == "EcalLaserAPDPNRatiosRef") {
         const auto condObject = generateEcalLaserAPDPNRatiosRef();
         if (irun == m_firstRun && dbOutput->isNewTagRequest(recordName)) {
           // create new
           edm::LogInfo("EcalTestDevDB") << "First One ";
           dbOutput->createOneIOV<const EcalLaserAPDPNRatiosRef>(*condObject, dbOutput->beginOfTime(), recordName);
         } else {
           // append
           edm::LogInfo("EcalTestDevDB") << "Old One ";
           dbOutput->appendOneIOV<const EcalLaserAPDPNRatiosRef>(*condObject, irun, recordName);
         }
       } else if (container == "EcalLaserAlphas") {
         const auto condObject = generateEcalLaserAlphas();
         if (irun == m_firstRun && dbOutput->isNewTagRequest(recordName)) {
           // create new
           edm::LogInfo("EcalTestDevDB") << "First One ";
           dbOutput->createOneIOV<const EcalLaserAlphas>(*condObject, dbOutput->beginOfTime(), recordName);
         } else {
           // append
           edm::LogInfo("EcalTestDevDB") << "Old One ";
           dbOutput->appendOneIOV<const EcalLaserAlphas>(*condObject, irun, recordName);
         }
       } else {
         edm::LogWarning("EcalTestDevDB") << "it does not work yet for " << container << "...";
       }
     }
   }
 }

◆ generateEcalADCToGeVConstant()

std::shared_ptr< EcalADCToGeVConstant > EcalTestDevDB::generateEcalADCToGeVConstant ( )

Definition at line 230 of file EcalTestDevDB.cc.

References alignCSCRings::r.

Referenced by analyze().

                                                                                 {
   //-------------------------------------------------------------
 
   double r = (double)std::rand() / (double(RAND_MAX) + double(1));
   auto agc = std::make_shared<EcalADCToGeVConstant>(36. + r * 4., 60. + r * 4);
   return agc;
 }

◆ generateEcalGainRatios()

std::shared_ptr< EcalGainRatios > EcalTestDevDB::generateEcalGainRatios ( )

Definition at line 319 of file EcalTestDevDB.cc.

References hcalRecHitTable_cff::ieta, hcalRecHitTable_cff::iphi, EBDetId::MAX_IETA, EBDetId::MAX_IPHI, EBDetId::MIN_IPHI, alignCSCRings::r, DetId::rawId(), EcalMGPAGainRatio::setGain12Over6(), and EcalMGPAGainRatio::setGain6Over1().

Referenced by analyze().

                                                                     {
   //-------------------------------------------------------------
 
   // create gain ratios
   auto gratio = std::make_shared<EcalGainRatios>();
 
   for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
     if (ieta == 0)
       continue;
     for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
       EBDetId ebid(ieta, iphi);
 
       double r = (double)std::rand() / (double(RAND_MAX) + double(1));
 
       EcalMGPAGainRatio gr;
       gr.setGain12Over6(1.9 + r * 0.2);
       gr.setGain6Over1(5.9 + r * 0.2);
 
       gratio->setValue(ebid.rawId(), gr);
 
     }  // loop over phi
   }    // loop over eta
   return gratio;
 }

◆ generateEcalIntercalibConstants()

std::shared_ptr< EcalIntercalibConstants > EcalTestDevDB::generateEcalIntercalibConstants ( )

Definition at line 239 of file EcalTestDevDB.cc.

References hcalRecHitTable_cff::ieta, hcalRecHitTable_cff::iphi, EBDetId::MAX_IETA, EBDetId::MAX_IPHI, EBDetId::MIN_IPHI, alignCSCRings::r, and DetId::rawId().

Referenced by analyze().

                                                                                       {
   //-------------------------------------------------------------
 
   auto ical = std::make_shared<EcalIntercalibConstants>();
 
   for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
     if (ieta == 0)
       continue;
     for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
       EBDetId ebid(ieta, iphi);
 
       double r = (double)std::rand() / (double(RAND_MAX) + double(1));
       ical->setValue(ebid.rawId(), 0.85 + r * 0.3);
     }  // loop over phi
   }    // loop over eta
   return ical;
 }

◆ generateEcalLaserAlphas()

std::shared_ptr< EcalLaserAlphas > EcalTestDevDB::generateEcalLaserAlphas ( )

Definition at line 613 of file EcalTestDevDB.cc.

References VtxSmearedParameters_cfi::Alpha, EBDetId::hashedIndex(), EEDetId::hashedIndex(), l1tPhase2CaloJetEmulator_cfi::iEta, EEDetId::IX_MAX, EEDetId::IX_MIN, EEDetId::IY_MAX, EEDetId::IY_MIN, EcalCondDBWriter_cfi::laser, EBDetId::MAX_HASH, EBDetId::MAX_IETA, EBDetId::MAX_IPHI, EBDetId::MIN_IPHI, and EEDetId::validDetId().

Referenced by analyze().

                                                                       {
   //--------------------------------------------------------------
 
   auto laser = std::make_shared<EcalLaserAlphas>();
 
   EcalLaserAlpha Alpha;
 
   for (int iEta = -EBDetId::MAX_IETA; iEta <= EBDetId::MAX_IETA; ++iEta) {
     if (iEta == 0)
       continue;
     for (int iPhi = EBDetId::MIN_IPHI; iPhi <= EBDetId::MAX_IPHI; ++iPhi) {
       Alpha = double(1.55);
       EBDetId ebid(iEta, iPhi);
 
       int hi = ebid.hashedIndex();
       if (hi < static_cast<int>(laser->getMap().size())) {
         laser->setValue(hi, Alpha);
       } else {
         edm::LogError("EcalTestDevDB") << "error with laser Map (alpha)!";
       }
     }
   }
 
   for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
     for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
       if (!EEDetId::validDetId(iX, iY, 1))
         continue;
 
       EEDetId eedetidpos(iX, iY, 1);
       Alpha = double(1.55);
 
       int hi = eedetidpos.hashedIndex() + EBDetId::MAX_HASH + 1;
       if (hi < static_cast<int>(laser->getMap().size())) {
         laser->setValue(hi, Alpha);
       } else {
         edm::LogError("EcalTestDevDB") << "error with laser Map (alpha)!";
       }
 
       if (!EEDetId::validDetId(iX, iY, -1))
         continue;
       EEDetId eedetidneg(iX, iY, -1);
       Alpha = double(1.55);
 
       hi = eedetidneg.hashedIndex() + EBDetId::MAX_HASH + 1;
       if (hi < static_cast<int>(laser->getMap().size())) {
         laser->setValue(hi, Alpha);
       } else {
         edm::LogError("EcalTestDevDB") << "error with laser Map (alpha)!";
       }
     }
   }
 
   return laser;
 }

◆ generateEcalLaserAPDPNRatios()

std::shared_ptr< EcalLaserAPDPNRatios > EcalTestDevDB::generateEcalLaserAPDPNRatios ( uint32_t i_run )

Definition at line 408 of file EcalTestDevDB.cc.

References JetChargeProducer_cfi::exp, EBDetId::hashedIndex(), EEDetId::hashedIndex(), mps_fire::i, l1tPhase2CaloJetEmulator_cfi::iEta, EEDetId::IX_MAX, EEDetId::IX_MIN, EEDetId::IY_MAX, EEDetId::IY_MIN, EcalCondDBWriter_cfi::laser, dqm-mbProfile::log, m_firstRun, m_lastRun, EBDetId::MAX_HASH, EBDetId::MAX_IETA, EBDetId::MAX_IPHI, EBDetId::MIN_IPHI, EcalLaserAPDPNRatios::EcalLaserTimeStamp::t1, EcalLaserAPDPNRatios::EcalLaserTimeStamp::t2, and EEDetId::validDetId().

Referenced by analyze().

                                                                                               {
   //--------------------------------------------------------------
 
   auto laser = std::make_shared<EcalLaserAPDPNRatios>();
 
   EcalLaserAPDPNRatios::EcalLaserAPDPNpair APDPNpair;
   EcalLaserAPDPNRatios::EcalLaserTimeStamp TimeStamp;
 
   //  if((m_firstRun == 0 && i_run == 0) || (m_firstRun == 1 && i_run == 1)){
 
   edm::LogInfo("EcalTestDevDB") << "First & last run: " << i_run << " " << m_firstRun << " " << m_lastRun;
   if (m_firstRun == i_run && (i_run == 0 || i_run == 1)) {
     APDPNpair.p1 = (double(1) + 1 / double(log(exp(1) + double((i_run - m_firstRun) * 10)))) / double(2);
     APDPNpair.p2 = (double(1) + 1 / double(log(exp(1) + double((i_run - m_firstRun) * 10) + double(10)))) / double(2);
     APDPNpair.p3 = double(0);
     edm::LogInfo("EcalTestDevDB") << i_run << " " << m_firstRun << " " << APDPNpair.p1 << " " << APDPNpair.p2;
 
     for (int iEta = -EBDetId::MAX_IETA; iEta <= EBDetId::MAX_IETA; ++iEta) {
       if (iEta == 0)
         continue;
       for (int iPhi = EBDetId::MIN_IPHI; iPhi <= EBDetId::MAX_IPHI; ++iPhi) {
         //APDPNpair.p1= double(1);
         //APDPNpair.p2= double(1);
 
         EBDetId ebid(iEta, iPhi);
         int hi = ebid.hashedIndex();
 
         if (hi < static_cast<int>(laser->getLaserMap().size())) {
           laser->setValue(hi, APDPNpair);
         } else {
           edm::LogError("EcalTestDevDB") << "error with laser Map (ratio)!";
           continue;
         }
       }
     }
 
     for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
       for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
         // make an EEDetId since we need EEDetId::rawId() to be used as the key for the pedestals
 
         if (!EEDetId::validDetId(iX, iY, 1))
           continue;
 
         EEDetId eedetidpos(iX, iY, 1);
         //APDPNpair.p1 = double(1);
         //APDPNpair.p2 = double(1);
 
         int hi = eedetidpos.hashedIndex() + EBDetId::MAX_HASH + 1;
         if (hi < static_cast<int>(laser->getLaserMap().size())) {
           laser->setValue(hi, APDPNpair);
         } else {
           edm::LogError("EcalTestDevDB") << "error with laser Map (ratio)!";
           continue;
         }
 
         if (!EEDetId::validDetId(iX, iY, -1))
           continue;
 
         EEDetId eedetidneg(iX, iY, -1);
         //APDPNpair.p1 = double(1);
         //APDPNpair.p2 = double(1);
         hi = eedetidneg.hashedIndex() + EBDetId::MAX_HASH + 1;
         if (hi < static_cast<int>(laser->getLaserMap().size())) {
           laser->setValue(hi, APDPNpair);
         } else {
           edm::LogError("EcalTestDevDB") << "error with laser Map (ratio)!";
           continue;
         }
       }
     }
 
     for (int i = 0; i < 92; i++) {
       if (i < static_cast<int>(laser->getTimeMap().size())) {
         TimeStamp.t1 = edm::Timestamp(1380 * (i_run - m_firstRun) + 15 * i);
         TimeStamp.t2 = edm::Timestamp(1380 * (i_run - m_firstRun + 1) + 15 * i);
         laser->setTime(i, TimeStamp);
       } else {
         edm::LogError("EcalTestDevDB") << "error with laser Map (time)!";
         continue;
       }
     }
 
   } else {
     APDPNpair.p1 = (double(1) + 1 / double(log(exp(1) + double((i_run - m_firstRun) * 10)))) / double(2);
     APDPNpair.p2 = (double(1) + 1 / double(log(exp(1) + double((i_run - m_firstRun) * 10) + double(10)))) / double(2);
     APDPNpair.p3 = double(0);
     edm::LogInfo("EcalTestDevDB") << i_run << " " << m_firstRun << " " << APDPNpair.p1 << " " << APDPNpair.p2;
 
     for (int iEta = -EBDetId::MAX_IETA; iEta <= EBDetId::MAX_IETA; ++iEta) {
       if (iEta == 0)
         continue;
       for (int iPhi = EBDetId::MIN_IPHI; iPhi <= EBDetId::MAX_IPHI; ++iPhi) {
         EBDetId ebid(iEta, iPhi);
         int hi = ebid.hashedIndex();
 
         if (hi < static_cast<int>(laser->getLaserMap().size())) {
           laser->setValue(hi, APDPNpair);
         } else {
           edm::LogError("EcalTestDevDB") << "error with laser Map (ratio)!";
         }
       }
     }
     for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
       for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
         // make an EEDetId since we need EEDetId::rawId() to be used as the key for the pedestals
 
         if (!EEDetId::validDetId(iX, iY, 1))
           continue;
 
         EEDetId eedetidpos(iX, iY, 1);
         int hi = eedetidpos.hashedIndex() + EBDetId::MAX_HASH + 1;
         if (hi < static_cast<int>(laser->getLaserMap().size())) {
           laser->setValue(hi, APDPNpair);
         } else {
           edm::LogError("EcalTestDevDB") << "error with laser Map (ratio)!";
           continue;
         }
 
         if (!EEDetId::validDetId(iX, iY, -1))
           continue;
 
         EEDetId eedetidneg(iX, iY, -1);
         hi = eedetidneg.hashedIndex() + EBDetId::MAX_HASH + 1;
         if (hi < static_cast<int>(laser->getLaserMap().size())) {
           laser->setValue(hi, APDPNpair);
         } else {
           edm::LogError("EcalTestDevDB") << "error with laser Map (ratio)!";
           continue;
         }
       }
     }
 
     for (int i = 0; i < 92; i++) {
       if (i < static_cast<int>(laser->getTimeMap().size())) {
         TimeStamp.t1 = edm::Timestamp(1380 * (i_run - m_firstRun) + 15 * i);
         TimeStamp.t2 = edm::Timestamp(1380 * (i_run - m_firstRun + 1) + 15 * i);
         laser->setTime(i, TimeStamp);
       } else {
         edm::LogError("EcalTestDevDB") << "error with laser Map (time)!";
         continue;
       }
     }
   }
 
   return laser;
 }

◆ generateEcalLaserAPDPNRatiosRef()

std::shared_ptr< EcalLaserAPDPNRatiosRef > EcalTestDevDB::generateEcalLaserAPDPNRatiosRef ( )

Definition at line 556 of file EcalTestDevDB.cc.

References EBDetId::hashedIndex(), EEDetId::hashedIndex(), l1tPhase2CaloJetEmulator_cfi::iEta, EEDetId::IX_MAX, EEDetId::IX_MIN, EEDetId::IY_MAX, EEDetId::IY_MIN, EcalCondDBWriter_cfi::laser, EBDetId::MAX_HASH, EBDetId::MAX_IETA, EBDetId::MAX_IPHI, EBDetId::MIN_IPHI, and EEDetId::validDetId().

Referenced by analyze().

                                                                                       {
   //--------------------------------------------------------------
 
   auto laser = std::make_shared<EcalLaserAPDPNRatiosRef>();
 
   EcalLaserAPDPNref APDPNref;
 
   for (int iEta = -EBDetId::MAX_IETA; iEta <= EBDetId::MAX_IETA; ++iEta) {
     if (iEta == 0)
       continue;
     for (int iPhi = EBDetId::MIN_IPHI; iPhi <= EBDetId::MAX_IPHI; ++iPhi) {
       APDPNref = double(1.5);
       EBDetId ebid(iEta, iPhi);
 
       int hi = ebid.hashedIndex();
       if (hi < static_cast<int>(laser->getMap().size())) {
         laser->setValue(hi, APDPNref);
       } else {
         edm::LogError("EcalTestDevDB") << "error with laser Map (ref)!";
       }
     }
   }
 
   for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
     for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
       if (!EEDetId::validDetId(iX, iY, 1))
         continue;
 
       EEDetId eedetidpos(iX, iY, 1);
       APDPNref = double(1.5);
 
       int hi = eedetidpos.hashedIndex() + EBDetId::MAX_HASH + 1;
       if (hi < static_cast<int>(laser->getMap().size())) {
         laser->setValue(hi, APDPNref);
       } else {
         edm::LogError("EcalTestDevDB") << "error with laser Map (ref)!";
       }
 
       if (!EEDetId::validDetId(iX, iY, -1))
         continue;
 
       EEDetId eedetidneg(iX, iY, -1);
       APDPNref = double(1.5);
 
       hi = eedetidneg.hashedIndex() + EBDetId::MAX_HASH + 1;
       if (hi < static_cast<int>(laser->getMap().size())) {
         laser->setValue(hi, APDPNref);
       } else {
         edm::LogError("EcalTestDevDB") << "error with laser Map (ref)!";
       }
     }
   }
 
   return laser;
 }

◆ generateEcalLinearCorrections()

std::shared_ptr< EcalLinearCorrections > EcalTestDevDB::generateEcalLinearCorrections ( )

Definition at line 258 of file EcalTestDevDB.cc.

References edm::Timestamp::endOfTime(), mps_fire::i, hcalRecHitTable_cff::ieta, hcalRecHitTable_cff::iphi, EEDetId::IX_MAX, EEDetId::IX_MIN, EEDetId::IY_MAX, EEDetId::IY_MIN, EBDetId::MAX_IETA, EBDetId::MAX_IPHI, EBDetId::MIN_IPHI, EcalTimeDependentCorrections::Values::p1, EcalTimeDependentCorrections::Values::p2, EcalTimeDependentCorrections::Values::p3, EcalTimeDependentCorrections::Times::t1, EcalTimeDependentCorrections::Times::t2, EcalTimeDependentCorrections::Times::t3, EBDetId::validDetId(), EEDetId::validDetId(), and relativeConstraints::value.

Referenced by analyze().

                                                                                   {
   //-------------------------------------------------------------
 
   auto ical = std::make_shared<EcalLinearCorrections>();
 
   for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
     if (ieta == 0)
       continue;
     for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
       if (EBDetId::validDetId(ieta, iphi)) {
         EBDetId ebid(ieta, iphi);
 
         EcalLinearCorrections::Values pairAPDPN;
         pairAPDPN.p1 = 1.0;
         pairAPDPN.p2 = 1.0;
         pairAPDPN.p3 = 1.0;
         ical->setValue(ebid, pairAPDPN);
       }
     }
   }
 
   for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
     for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
       // make an EEDetId since we need EEDetId::rawId() to be used as the key for the pedestals
       if (EEDetId::validDetId(iX, iY, 1)) {
         EEDetId eedetidpos(iX, iY, 1);
 
         EcalLinearCorrections::Values pairAPDPN;
         pairAPDPN.p1 = 1.0;
         pairAPDPN.p2 = 1.0;
         pairAPDPN.p3 = 1.0;
 
         ical->setValue(eedetidpos, pairAPDPN);
       }
 
       if (EEDetId::validDetId(iX, iY, -1)) {
         EEDetId eedetidneg(iX, iY, -1);
 
         EcalLinearCorrections::Values pairAPDPN;
         pairAPDPN.p1 = 1.0;
         pairAPDPN.p2 = 1.0;
         pairAPDPN.p3 = 1.0;
 
         ical->setValue(eedetidneg, pairAPDPN);
       }
     }
   }
 
   EcalLinearCorrections::Times TimeStamp;
   for (int i = 0; i < 92; i++) {
     TimeStamp.t1 = edm::Timestamp(0);
     TimeStamp.t2 = edm::Timestamp(edm::Timestamp::endOfTime().value());
     TimeStamp.t3 = edm::Timestamp(edm::Timestamp::endOfTime().value());
 
     ical->setTime(i, TimeStamp);
   }
 
   return ical;
 }

◆ generateEcalPedestals()

std::shared_ptr< EcalPedestals > EcalTestDevDB::generateEcalPedestals ( )

Definition at line 206 of file EcalTestDevDB.cc.

References l1tPhase2CaloJetEmulator_cfi::iEta, B2GTnPMonitor_cfi::item, EBDetId::MAX_IETA, EBDetId::MAX_IPHI, EBDetId::MIN_IPHI, and DetId::rawId().

Referenced by analyze().

                                                                   {
   //-------------------------------------------------------------
 
   auto peds = std::make_shared<EcalPedestals>();
   EcalPedestals::Item item;
   for (int iEta = -EBDetId::MAX_IETA; iEta <= EBDetId::MAX_IETA; ++iEta) {
     if (iEta == 0)
       continue;
     for (int iPhi = EBDetId::MIN_IPHI; iPhi <= EBDetId::MAX_IPHI; ++iPhi) {
       item.mean_x1 = 200. * ((double)std::rand() / (double(RAND_MAX) + double(1)));
       item.rms_x1 = (double)std::rand() / (double(RAND_MAX) + double(1));
       item.mean_x6 = 1200. * ((double)std::rand() / (double(RAND_MAX) + double(1)));
       item.rms_x6 = 6. * ((double)std::rand() / (double(RAND_MAX) + double(1)));
       item.mean_x12 = 2400. * ((double)std::rand() / (double(RAND_MAX) + double(1)));
       item.rms_x12 = 12. * ((double)std::rand() / (double(RAND_MAX) + double(1)));
 
       EBDetId ebdetid(iEta, iPhi);
       peds->insert(std::make_pair(ebdetid.rawId(), item));
     }
   }
   return peds;
 }

◆ generateEcalTBWeights()

std::shared_ptr< EcalTBWeights > EcalTestDevDB::generateEcalTBWeights ( )

Definition at line 361 of file EcalTestDevDB.cc.

References EcalWeightSet::getChi2WeightsAfterGainSwitch(), EcalWeightSet::getChi2WeightsBeforeGainSwitch(), EcalWeightSet::getWeightsAfterGainSwitch(), EcalWeightSet::getWeightsBeforeGainSwitch(), mps_fire::i, dqmiolumiharvest::j, EBDetId::MAX_IETA, alignCSCRings::r, and ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::ww.

Referenced by analyze().

                                                                   {
   //-------------------------------------------------------------
 
   auto tbwgt = std::make_shared<EcalTBWeights>();
 
   // create weights for each distinct group ID
   int nMaxTDC = 10;
   for (int igrp = -EBDetId::MAX_IETA; igrp <= EBDetId::MAX_IETA; ++igrp) {
     if (igrp == 0)
       continue;
     for (int itdc = 1; itdc <= nMaxTDC; ++itdc) {
       // generate random number
       double r = (double)std::rand() / (double(RAND_MAX) + double(1));
 
       // make a new set of weights
       EcalWeightSet wgt;
       EcalWeightSet::EcalWeightMatrix& mat1 = wgt.getWeightsBeforeGainSwitch();
       EcalWeightSet::EcalWeightMatrix& mat2 = wgt.getWeightsAfterGainSwitch();
 
       for (size_t i = 0; i < 3; ++i) {
         for (size_t j = 0; j < 10; ++j) {
           double ww = igrp * itdc * r + i * 10. + j;
           mat1(i, j) = ww;
           mat2(i, j) = 100 + ww;
         }
       }
 
       // fill the chi2 matrcies
       r = (double)std::rand() / (double(RAND_MAX) + double(1));
       EcalWeightSet::EcalChi2WeightMatrix& mat3 = wgt.getChi2WeightsBeforeGainSwitch();
       EcalWeightSet::EcalChi2WeightMatrix& mat4 = wgt.getChi2WeightsAfterGainSwitch();
       for (size_t i = 0; i < 10; ++i) {
         for (size_t j = 0; j < 10; ++j) {
           double ww = igrp * itdc * r + i * 10. + j;
           mat3(i, j) = 1000 + ww;
           mat4(i, j) = 1000 + 100 + ww;
         }
       }
 
       // put the weight in the container
       tbwgt->setValue(std::make_pair(igrp, itdc), wgt);
     }
   }
   return tbwgt;
 }

◆ generateEcalWeightXtalGroups()

std::shared_ptr< EcalWeightXtalGroups > EcalTestDevDB::generateEcalWeightXtalGroups ( )

Definition at line 345 of file EcalTestDevDB.cc.

References hcalRecHitTable_cff::ieta, hcalRecHitTable_cff::iphi, EBDetId::MAX_IETA, EBDetId::MAX_IPHI, EBDetId::MIN_IPHI, and DetId::rawId().

Referenced by analyze().

                                                                                 {
   //-------------------------------------------------------------
 
   auto xtalGroups = std::make_shared<EcalWeightXtalGroups>();
   for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
     if (ieta == 0)
       continue;
     for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
       EBDetId ebid(ieta, iphi);
       xtalGroups->setValue(ebid.rawId(), EcalXtalGroupId(ieta));  // define rings in eta
     }
   }
   return xtalGroups;
 }

Member Data Documentation

◆ m_cacheIDs

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

private

Definition at line 61 of file EcalTestDevDB.h.

Referenced by EcalTestDevDB().

◆ m_firstRun

unsigned long EcalTestDevDB::m_firstRun

private

Definition at line 63 of file EcalTestDevDB.h.

Referenced by analyze(), EcalTestDevDB(), and generateEcalLaserAPDPNRatios().

◆ m_interval

unsigned int EcalTestDevDB::m_interval

private

Definition at line 65 of file EcalTestDevDB.h.

Referenced by analyze(), and EcalTestDevDB().

◆ m_lastRun

unsigned long EcalTestDevDB::m_lastRun

private

Definition at line 64 of file EcalTestDevDB.h.

Referenced by analyze(), EcalTestDevDB(), and generateEcalLaserAPDPNRatios().

◆ m_records

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

private

Definition at line 62 of file EcalTestDevDB.h.

Referenced by analyze(), and EcalTestDevDB().

◆ m_timetype

std::string EcalTestDevDB::m_timetype

private

Definition at line 60 of file EcalTestDevDB.h.

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ EcalTestDevDB()

◆ ~EcalTestDevDB()

Member Function Documentation

◆ analyze()

◆ generateEcalADCToGeVConstant()

◆ generateEcalGainRatios()

◆ generateEcalIntercalibConstants()

◆ generateEcalLaserAlphas()

◆ generateEcalLaserAPDPNRatios()

◆ generateEcalLaserAPDPNRatiosRef()

◆ generateEcalLinearCorrections()

◆ generateEcalPedestals()

◆ generateEcalTBWeights()

◆ generateEcalWeightXtalGroups()

Member Data Documentation

◆ m_cacheIDs

◆ m_firstRun

◆ m_interval

◆ m_lastRun

◆ m_records

◆ m_timetype