#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 final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const 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

bool	wantsStreamRuns () const

	~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

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

std::vector< ESProxyIndex > 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

bool	registeredToConsumeMany (TypeID const &, 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::ESRecordsToProxyIndices 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 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<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 ( 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, GlobalPosition_Frontier_DevDB_cff::record, AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::tag, and copyEcalPFRecHitThresholds_cfg::toCopy.

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

override

Definition at line 44 of file EcalTestDevDB.cc.

44 {}

Member Function Documentation

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, GlobalPosition_Frontier_DevDB_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 << "...";
       }
     }
   }
 }

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

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

Definition at line 319 of file EcalTestDevDB.cc.

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

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

Definition at line 239 of file EcalTestDevDB.cc.

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

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

Definition at line 613 of file EcalTestDevDB.cc.

References EBDetId::hashedIndex(), EEDetId::hashedIndex(), 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;
 }

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

Definition at line 408 of file EcalTestDevDB.cc.

References funct::exp(), EBDetId::hashedIndex(), EEDetId::hashedIndex(), mps_fire::i, EEDetId::IX_MAX, EEDetId::IX_MIN, EEDetId::IY_MAX, EEDetId::IY_MIN, EcalCondDBWriter_cfi::laser, 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;
 }

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

Definition at line 556 of file EcalTestDevDB.cc.

References EBDetId::hashedIndex(), EEDetId::hashedIndex(), 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;
 }

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

Definition at line 258 of file EcalTestDevDB.cc.

References edm::Timestamp::endOfTime(), mps_fire::i, 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;
 }

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

Definition at line 206 of file EcalTestDevDB.cc.

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

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, and alignCSCRings::r.

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

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

Definition at line 345 of file EcalTestDevDB.cc.

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