#include <EcalTestDevDB.h>

Inheritance diagram for EcalTestDevDB:

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

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

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

	EDAnalyzer ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

virtual	~EDAnalyzer ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

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

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

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

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

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

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

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

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

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

void	consumesMany (const TypeToGet &id)

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

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

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

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

Detailed Description

Definition at line 40 of file EcalTestDevDB.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 25 of file EcalTestDevDB.cc.

References edm::ParameterSet::getParameter(), 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 copyFileAlignEB_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 ( )

Definition at line 51 of file EcalTestDevDB.cc.

 {
   
 }

Member Function Documentation

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

virtual

Implements edm::EDAnalyzer.

Definition at line 56 of file EcalTestDevDB.cc.

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(), edm::hlt::Exception, generateEcalADCToGeVConstant(), generateEcalGainRatios(), generateEcalIntercalibConstants(), generateEcalLaserAlphas(), generateEcalLaserAPDPNRatios(), generateEcalLaserAPDPNRatiosRef(), generateEcalLinearCorrections(), generateEcalPedestals(), generateEcalTBWeights(), generateEcalWeightXtalGroups(), i, edm::Service< T >::isAvailable(), cond::service::PoolDBOutputService::isNewTagRequest(), m_firstRun, m_interval, m_lastRun, m_records, GlobalPosition_Frontier_DevDB_cff::record, ecalTPGAnalyzer_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) {
     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;
     
       }
       
       
     }
     
     
   }
   
   
 }

EcalADCToGeVConstant * EcalTestDevDB::generateEcalADCToGeVConstant ( )

Definition at line 258 of file EcalTestDevDB.cc.

References alignCSCRings::r, and rand().

Referenced by analyze().

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

EcalGainRatios * EcalTestDevDB::generateEcalGainRatios ( )

Definition at line 358 of file EcalTestDevDB.cc.

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

Referenced by analyze().

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

EcalIntercalibConstants * EcalTestDevDB::generateEcalIntercalibConstants ( )

Definition at line 268 of file EcalTestDevDB.cc.

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

Referenced by analyze().

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

EcalLaserAlphas * EcalTestDevDB::generateEcalLaserAlphas ( )

Definition at line 666 of file EcalTestDevDB.cc.

References EcalCondObjectContainer< T >::getMap(), EBDetId::hashedIndex(), EEDetId::hashedIndex(), EEDetId::IX_MAX, EEDetId::IX_MIN, EEDetId::IY_MAX, EEDetId::IY_MIN, EBDetId::MAX_HASH, EBDetId::MAX_IETA, EBDetId::MAX_IPHI, EBDetId::MIN_IPHI, EcalCondObjectContainer< T >::setValue(), EcalCondObjectContainer< T >::size(), and EEDetId::validDetId().

Referenced by analyze().

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

EcalLaserAPDPNRatios * EcalTestDevDB::generateEcalLaserAPDPNRatios ( uint32_t i_run )

Definition at line 451 of file EcalTestDevDB.cc.

Referenced by analyze().

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

EcalLaserAPDPNRatiosRef * EcalTestDevDB::generateEcalLaserAPDPNRatiosRef ( )

Definition at line 606 of file EcalTestDevDB.cc.

References EcalCondObjectContainer< T >::getMap(), EBDetId::hashedIndex(), EEDetId::hashedIndex(), EEDetId::IX_MAX, EEDetId::IX_MIN, EEDetId::IY_MAX, EEDetId::IY_MIN, EBDetId::MAX_HASH, EBDetId::MAX_IETA, EBDetId::MAX_IPHI, EBDetId::MIN_IPHI, EcalCondObjectContainer< T >::setValue(), EcalCondObjectContainer< T >::size(), and EEDetId::validDetId().

Referenced by analyze().

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

EcalLinearCorrections * EcalTestDevDB::generateEcalLinearCorrections ( )

Definition at line 288 of file EcalTestDevDB.cc.

Referenced by analyze().

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

EcalPedestals * EcalTestDevDB::generateEcalPedestals ( )

Definition at line 234 of file EcalTestDevDB.cc.

References EcalCondObjectContainer< T >::insert(), EBDetId::MAX_IETA, EBDetId::MAX_IPHI, EcalPedestal::mean_x1, EcalPedestal::mean_x12, EcalPedestal::mean_x6, EBDetId::MIN_IPHI, rand(), DetId::rawId(), EcalPedestal::rms_x1, EcalPedestal::rms_x12, and EcalPedestal::rms_x6.

Referenced by analyze().

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

EcalTBWeights * EcalTestDevDB::generateEcalTBWeights ( )

Definition at line 401 of file EcalTestDevDB.cc.

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

Referenced by analyze().

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

EcalWeightXtalGroups * EcalTestDevDB::generateEcalWeightXtalGroups ( )

Definition at line 385 of file EcalTestDevDB.cc.

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

Referenced by analyze().

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