EcalTestDevDB Class Reference

#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)
EcalADCToGeVConstant *	generateEcalADCToGeVConstant ()
EcalGainRatios *	generateEcalGainRatios ()
EcalIntercalibConstants *	generateEcalIntercalibConstants ()
EcalLaserAlphas *	generateEcalLaserAlphas ()
EcalLaserAPDPNRatios *	generateEcalLaserAPDPNRatios (uint32_t i_run)
EcalLaserAPDPNRatiosRef *	generateEcalLaserAPDPNRatiosRef ()
EcalLinearCorrections *	generateEcalLinearCorrections ()
EcalPedestals *	generateEcalPedestals ()
EcalTBWeights *	generateEcalTBWeights ()
EcalWeightXtalGroups *	generateEcalWeightXtalGroups ()
	~EcalTestDevDB () 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 &&)=default
	EDConsumerBase (EDConsumerBase const &)=delete
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 &	operator= (EDConsumerBase &&)=default
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
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::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	wantsInputProcessBlocks ()
static bool	wantsProcessBlocks ()
static bool	wantsStreamLuminosityBlocks ()
static bool	wantsStreamRuns ()
Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept
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<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept
template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

Definition at line 40 of file EcalTestDevDB.h.

Constructor & Destructor Documentation

EcalTestDevDB()

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

explicit

Definition at line 25 of file EcalTestDevDB.cc.

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

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.

~EcalTestDevDB()

EcalTestDevDB::~EcalTestDevDB ( )

override

Definition at line 45 of file EcalTestDevDB.cc.

{}

Member Function Documentation

analyze()

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

overridevirtual

Implements edm::EDAnalyzer.

Definition at line 47 of file EcalTestDevDB.cc.

                                                                              {
  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) {
        std::cout << "Infinite IOV mode" << std::endl;
        irun = edm::IOVSyncValue::endOfTime().eventID().run();
      }
 
      std::cout << "Starting Transaction for run " << irun << "..." << std::flush;
 
      if (container == "EcalPedestals") {
        EcalPedestals* condObject = generateEcalPedestals();
 
        if (irun == m_firstRun && dbOutput->isNewTagRequest(recordName)) {
          // create new
          std::cout << "First One " << std::endl;
          dbOutput->createNewIOV<const EcalPedestals>(
              condObject, dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);
        } else {
          // append
          std::cout << "Old One " << std::endl;
          dbOutput->appendSinceTime<const EcalPedestals>(condObject, irun, recordName);
        }
 
      } else if (container == "EcalADCToGeVConstant") {
        EcalADCToGeVConstant* condObject = generateEcalADCToGeVConstant();
        if (irun == m_firstRun && dbOutput->isNewTagRequest(recordName)) {
          // create new
          std::cout << "First One " << std::endl;
          dbOutput->createNewIOV<const EcalADCToGeVConstant>(
              condObject, dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);
        } else {
          // append
          std::cout << "Old One " << std::endl;
          dbOutput->appendSinceTime<const EcalADCToGeVConstant>(condObject, irun, recordName);
        }
 
      } else if (container == "EcalIntercalibConstants") {
        EcalIntercalibConstants* condObject = generateEcalIntercalibConstants();
        if (irun == m_firstRun && dbOutput->isNewTagRequest(recordName)) {
          // create new
          std::cout << "First One " << std::endl;
          dbOutput->createNewIOV<const EcalIntercalibConstants>(
              condObject, dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);
        } else {
          // append
          std::cout << "Old One " << std::endl;
          dbOutput->appendSinceTime<const EcalIntercalibConstants>(condObject, irun, recordName);
        }
      } else if (container == "EcalLinearCorrections") {
        EcalLinearCorrections* condObject = generateEcalLinearCorrections();
        if (irun == m_firstRun && dbOutput->isNewTagRequest(recordName)) {
          // create new
          std::cout << "First One " << std::endl;
          dbOutput->createNewIOV<const EcalLinearCorrections>(
              condObject, dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);
        } else {
          // append
          std::cout << "Old One " << std::endl;
          dbOutput->appendSinceTime<const EcalLinearCorrections>(condObject, irun, recordName);
        }
 
      } else if (container == "EcalGainRatios") {
        EcalGainRatios* condObject = generateEcalGainRatios();
        if (irun == m_firstRun && dbOutput->isNewTagRequest(recordName)) {
          // create new
          std::cout << "First One " << std::endl;
          dbOutput->createNewIOV<const EcalGainRatios>(
              condObject, dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);
        } else {
          // append
          std::cout << "Old One " << std::endl;
          dbOutput->appendSinceTime<const EcalGainRatios>(condObject, irun, recordName);
        }
 
      } else if (container == "EcalWeightXtalGroups") {
        EcalWeightXtalGroups* condObject = generateEcalWeightXtalGroups();
        if (irun == m_firstRun && dbOutput->isNewTagRequest(recordName)) {
          // create new
          std::cout << "First One " << std::endl;
          dbOutput->createNewIOV<const EcalWeightXtalGroups>(
              condObject, dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);
        } else {
          // append
          std::cout << "Old One " << std::endl;
          dbOutput->appendSinceTime<const EcalWeightXtalGroups>(condObject, irun, recordName);
        }
 
      } else if (container == "EcalTBWeights") {
        EcalTBWeights* condObject = generateEcalTBWeights();
        if (irun == m_firstRun && dbOutput->isNewTagRequest(recordName)) {
          // create new
          std::cout << "First One " << std::endl;
          dbOutput->createNewIOV<const EcalTBWeights>(
              condObject, dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);
        } else {
          // append
          std::cout << "Old One " << std::endl;
          dbOutput->appendSinceTime<const EcalTBWeights>(condObject, irun, recordName);
        }
 
      } else if (container == "EcalLaserAPDPNRatios") {
        EcalLaserAPDPNRatios* condObject = generateEcalLaserAPDPNRatios(irun);
        if (irun == m_firstRun && dbOutput->isNewTagRequest(recordName)) {
          // create new
          std::cout << "First One " << std::endl;
          dbOutput->createNewIOV<const EcalLaserAPDPNRatios>(
              condObject, dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);
        } else {
          // append
          std::cout << "Old One " << std::endl;
          dbOutput->appendSinceTime<const EcalLaserAPDPNRatios>(condObject, irun, recordName);
        }
      } else if (container == "EcalLaserAPDPNRatiosRef") {
        EcalLaserAPDPNRatiosRef* condObject = generateEcalLaserAPDPNRatiosRef();
        if (irun == m_firstRun && dbOutput->isNewTagRequest(recordName)) {
          // create new
          std::cout << "First One " << std::endl;
          dbOutput->createNewIOV<const EcalLaserAPDPNRatiosRef>(
              condObject, dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);
        } else {
          // append
          std::cout << "Old One " << std::endl;
          dbOutput->appendSinceTime<const EcalLaserAPDPNRatiosRef>(condObject, irun, recordName);
        }
      } else if (container == "EcalLaserAlphas") {
        EcalLaserAlphas* condObject = generateEcalLaserAlphas();
        if (irun == m_firstRun && dbOutput->isNewTagRequest(recordName)) {
          // create new
          std::cout << "First One " << std::endl;
          dbOutput->createNewIOV<const EcalLaserAlphas>(
              condObject, dbOutput->beginOfTime(), dbOutput->endOfTime(), recordName);
        } else {
          // append
          std::cout << "Old One " << std::endl;
          dbOutput->appendSinceTime<const EcalLaserAlphas>(condObject, irun, recordName);
        }
      } else {
        std::cout << "it does not work yet for " << container << "..." << std::flush;
      }
    }
  }
}

References cond::service::PoolDBOutputService::appendSinceTime(), cond::service::PoolDBOutputService::beginOfTime(), gather_cfg::cout, cond::service::PoolDBOutputService::createNewIOV(), edm::IOVSyncValue::endOfTime(), cond::service::PoolDBOutputService::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.

generateEcalADCToGeVConstant()

EcalADCToGeVConstant * EcalTestDevDB::generateEcalADCToGeVConstant

(

)

Definition at line 242 of file EcalTestDevDB.cc.

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

References alignCSCRings::r.

Referenced by analyze().

generateEcalGainRatios()

EcalGainRatios * EcalTestDevDB::generateEcalGainRatios

(

)

Definition at line 331 of file EcalTestDevDB.cc.

                                                      {
  //-------------------------------------------------------------
 
  // create gain ratios
  EcalGainRatios* gratio = new 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;
}

References LEDCalibrationChannels::ieta, LEDCalibrationChannels::iphi, EBDetId::MAX_IETA, EBDetId::MAX_IPHI, EBDetId::MIN_IPHI, alignCSCRings::r, DetId::rawId(), EcalMGPAGainRatio::setGain12Over6(), EcalMGPAGainRatio::setGain6Over1(), and EcalCondObjectContainer< T >::setValue().

Referenced by analyze().

generateEcalIntercalibConstants()

EcalIntercalibConstants * EcalTestDevDB::generateEcalIntercalibConstants

(

)

Definition at line 251 of file EcalTestDevDB.cc.

                                                                        {
  //-------------------------------------------------------------
 
  EcalIntercalibConstants* ical = new 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;
}

References LEDCalibrationChannels::ieta, LEDCalibrationChannels::iphi, EBDetId::MAX_IETA, EBDetId::MAX_IPHI, EBDetId::MIN_IPHI, alignCSCRings::r, DetId::rawId(), and EcalCondObjectContainer< T >::setValue().

Referenced by analyze().

generateEcalLaserAlphas()

EcalLaserAlphas * EcalTestDevDB::generateEcalLaserAlphas

(

)

Definition at line 630 of file EcalTestDevDB.cc.

                                                        {
  //--------------------------------------------------------------
 
  EcalLaserAlphas* laser = new 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)!" << std::endl;
      }
    }
  }
 
  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)!" << std::endl;
      }
 
      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)!" << std::endl;
      }
    }
  }
 
  return laser;
}

References VtxSmearedParameters_cfi::Alpha, EBDetId::hashedIndex(), EEDetId::hashedIndex(), L1TowerCalibrationProducer_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().

generateEcalLaserAPDPNRatios()

EcalLaserAPDPNRatios * EcalTestDevDB::generateEcalLaserAPDPNRatios

(

uint32_t

i_run

)

Definition at line 421 of file EcalTestDevDB.cc.

                                                                                {
  //--------------------------------------------------------------
 
  EcalLaserAPDPNRatios* laser = new EcalLaserAPDPNRatios();
 
  EcalLaserAPDPNRatios::EcalLaserAPDPNpair APDPNpair;
  EcalLaserAPDPNRatios::EcalLaserTimeStamp TimeStamp;
 
  //  if((m_firstRun == 0 && i_run == 0) || (m_firstRun == 1 && i_run == 1)){
 
  std::cout << "First & last run: " << i_run << " " << m_firstRun << " " << m_lastRun << " " << std::endl;
  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);
    std::cout << i_run << " " << m_firstRun << " " << APDPNpair.p1 << " " << APDPNpair.p2 << std::endl;
 
    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)!" << std::endl;
          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)!" << std::endl;
          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)!" << std::endl;
          continue;
        }
      }
    }
 
    std::cout << std::endl;
    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);
        //std::cout << " Timestamp for " << i << " : " << TimeStamp.t1.value() << " , " << TimeStamp.t2.value() << std::endl;
      } else {
        edm::LogError("EcalTestDevDB") << "error with laser Map (time)!" << std::endl;
        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);
    std::cout << i_run << " " << m_firstRun << " " << APDPNpair.p1 << " " << APDPNpair.p2 << std::endl;
 
    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)!" << std::endl;
        }
      }
    }
    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)!" << std::endl;
          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)!" << std::endl;
          continue;
        }
      }
    }
 
    std::cout << std::endl;
    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);
        //std::cout << " Timestamp for " << i << " : " << TimeStamp.t1.value() << " , " << TimeStamp.t2.value() << std::endl;
      } else {
        edm::LogError("EcalTestDevDB") << "error with laser Map (time)!" << std::endl;
        continue;
      }
    }
  }
 
  return laser;
}

References gather_cfg::cout, JetChargeProducer_cfi::exp, EBDetId::hashedIndex(), EEDetId::hashedIndex(), mps_fire::i, L1TowerCalibrationProducer_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::EcalLaserAPDPNpair::p1, EcalLaserAPDPNRatios::EcalLaserAPDPNpair::p2, EcalLaserAPDPNRatios::EcalLaserAPDPNpair::p3, EcalLaserAPDPNRatios::EcalLaserTimeStamp::t1, EcalLaserAPDPNRatios::EcalLaserTimeStamp::t2, and EEDetId::validDetId().

Referenced by analyze().

generateEcalLaserAPDPNRatiosRef()

EcalLaserAPDPNRatiosRef * EcalTestDevDB::generateEcalLaserAPDPNRatiosRef

(

)

Definition at line 573 of file EcalTestDevDB.cc.

                                                                        {
  //--------------------------------------------------------------
 
  EcalLaserAPDPNRatiosRef* laser = new 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)!" << std::endl;
      }
    }
  }
 
  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)!" << std::endl;
      }
 
      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)!" << std::endl;
      }
    }
  }
 
  return laser;
}

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

generateEcalLinearCorrections()

EcalLinearCorrections * EcalTestDevDB::generateEcalLinearCorrections

(

)

Definition at line 270 of file EcalTestDevDB.cc.

                                                                    {
  //-------------------------------------------------------------
 
  EcalLinearCorrections* ical = new 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;
}

References edm::Timestamp::endOfTime(), mps_fire::i, LEDCalibrationChannels::ieta, LEDCalibrationChannels::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::setTime(), EcalTimeDependentCorrections::setValue(), EcalTimeDependentCorrections::Times::t1, EcalTimeDependentCorrections::Times::t2, EcalTimeDependentCorrections::Times::t3, EBDetId::validDetId(), EEDetId::validDetId(), and relativeConstraints::value.

Referenced by analyze().

generateEcalPedestals()

EcalPedestals * EcalTestDevDB::generateEcalPedestals

(

)

Definition at line 218 of file EcalTestDevDB.cc.

                                                    {
  //-------------------------------------------------------------
 
  EcalPedestals* peds = new 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;
}

References L1TowerCalibrationProducer_cfi::iEta, EcalCondObjectContainer< T >::insert(), B2GTnPMonitor_cfi::item, EBDetId::MAX_IETA, EBDetId::MAX_IPHI, EBDetId::MIN_IPHI, and DetId::rawId().

Referenced by analyze().

generateEcalTBWeights()

EcalTBWeights * EcalTestDevDB::generateEcalTBWeights

(

)

Definition at line 373 of file EcalTestDevDB.cc.

                                                    {
  //-------------------------------------------------------------
 
  EcalTBWeights* tbwgt = new 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;
          //std::cout << "row: " << i << " col: " << j << " -  val: " << ww  << std::endl;
          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;
}

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

Referenced by analyze().

generateEcalWeightXtalGroups()

EcalWeightXtalGroups * EcalTestDevDB::generateEcalWeightXtalGroups

(

)

Definition at line 357 of file EcalTestDevDB.cc.

                                                                  {
  //-------------------------------------------------------------
 
  EcalWeightXtalGroups* xtalGroups = new 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;
}

References LEDCalibrationChannels::ieta, LEDCalibrationChannels::iphi, EBDetId::MAX_IETA, EBDetId::MAX_IPHI, EBDetId::MIN_IPHI, DetId::rawId(), and EcalCondObjectContainer< T >::setValue().

Referenced by analyze().

Member Data Documentation

m_cacheIDs

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

private

Definition at line 60 of file EcalTestDevDB.h.

Referenced by EcalTestDevDB().

m_firstRun

unsigned long EcalTestDevDB::m_firstRun

private

Definition at line 62 of file EcalTestDevDB.h.

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

m_interval

unsigned int EcalTestDevDB::m_interval

private

Definition at line 64 of file EcalTestDevDB.h.

Referenced by analyze(), and EcalTestDevDB().

m_lastRun

unsigned long EcalTestDevDB::m_lastRun

private

Definition at line 63 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 61 of file EcalTestDevDB.h.

Referenced by analyze(), and EcalTestDevDB().

m_timetype

std::string EcalTestDevDB::m_timetype

private

Definition at line 59 of file EcalTestDevDB.h.