#include <LaserTask.h>

Inheritance diagram for ecaldqm::LaserTask:

Public Member Functions
void	addDependencies (DependencySet &) override

bool	analyze (void const *, Collections) override

void	beginEvent (edm::Event const &, edm::EventSetup const &) override

void	beginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) override

void	beginRun (edm::Run const &, edm::EventSetup const &) override

bool	filterRunType (short const *) override

	LaserTask ()

template<typename DigiCollection >
void	runOnDigis (DigiCollection const &)

void	runOnPnDigis (EcalPnDiodeDigiCollection const &)

void	runOnRawData (EcalRawDataCollection const &)

void	runOnUncalibRecHits (EcalUncalibratedRecHitCollection const &)

	~LaserTask ()

Public Member Functions inherited from ecaldqm::DQWorkerTask
	DQWorkerTask ()

virtual void	endEvent (edm::Event const &, edm::EventSetup const &)

virtual bool	filterTrigger (edm::TriggerResultsByName const &)

void	recoverStats ()

virtual void	setTokens (edm::ConsumesCollector &)

void	softReset ()

virtual	~DQWorkerTask ()

Public Member Functions inherited from ecaldqm::DQWorker
virtual void	bookMEs (DQMStore::IBooker &)

	DQWorker ()

virtual void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)

virtual void	endRun (edm::Run const &, edm::EventSetup const &)

std::string const &	getName () const

bool	onlineMode () const

virtual void	releaseMEs ()

void	setEventNumber (edm::EventNumber_t _e)

void	setLumiNumber (edm::LuminosityBlockNumber_t _l)

void	setRunNumber (edm::RunNumber_t _r)

void	setTime (time_t _t)

virtual	~DQWorker ()

Private Member Functions
void	setParams (edm::ParameterSet const &) override

Private Attributes
int	emptyLS_

int	emptyLSLimit_

bool	enable_ [nDCC]

int	maxPedestal_

std::map< uint32_t, float >	pnAmp_

unsigned	rtHalf_ [nDCC]

unsigned	wavelength_ [nDCC]

std::map< int, unsigned >	wlToME_

Additional Inherited Members
Public Types inherited from ecaldqm::DQWorkerTask
typedef EcalDCCHeaderBlock::EcalDCCEventSettings	EventSettings

Static Public Member Functions inherited from ecaldqm::DQWorkerTask
static void	fillDescriptions (edm::ParameterSetDescription &)

Static Public Member Functions inherited from ecaldqm::DQWorker
static void	fillDescriptions (edm::ParameterSetDescription &_desc)

Protected Member Functions inherited from ecaldqm::DQWorkerTask
void	setME (edm::ParameterSet const &) final

Protected Member Functions inherited from ecaldqm::DQWorker
void	initialize (std::string const &_name, edm::ParameterSet const &)

void	print_ (std::string const &, int=0) const

virtual void	setSource (edm::ParameterSet const &)

void	setVerbosity (int _verbosity)

Protected Attributes inherited from ecaldqm::DQWorkerTask
std::set< std::string >	resettable_

Protected Attributes inherited from ecaldqm::DQWorker
bool	booked_

MESetCollection	MEs_

std::string	name_

bool	onlineMode_

Timestamp	timestamp_

int	verbosity_

bool	willConvertToEDM_

Detailed Description

Definition at line 14 of file LaserTask.h.

Constructor & Destructor Documentation

ecaldqm::LaserTask::LaserTask ( )

Definition at line 9 of file LaserTask.cc.

References enable_, ecaldqm::nDCC, rtHalf_, and wavelength_.

                        :
     DQWorkerTask(),
     wlToME_(),
     pnAmp_(),
     emptyLS_(0),
     emptyLSLimit_(0),
     maxPedestal_(0)
   {
     std::fill_n(enable_, nDCC, false);
     std::fill_n(wavelength_, nDCC, 0);
     std::fill_n(rtHalf_, nDCC, 0);
   }

ecaldqm::LaserTask::~LaserTask ( )

inline

Definition at line 17 of file LaserTask.h.

17 {}

Member Function Documentation

void ecaldqm::LaserTask::addDependencies ( DependencySet & _dependencies )

overridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 44 of file LaserTask.cc.

References ecaldqm::kEBDigi, ecaldqm::kEBLaserLedUncalibRecHit, ecaldqm::kEcalRawData, ecaldqm::kEEDigi, ecaldqm::kEELaserLedUncalibRecHit, ecaldqm::kPnDiodeDigi, and ecaldqm::DependencySet::push_back().

   {
     _dependencies.push_back(Dependency(kEBDigi, kEcalRawData));
     _dependencies.push_back(Dependency(kEEDigi, kEcalRawData));
     _dependencies.push_back(Dependency(kPnDiodeDigi, kEBDigi, kEEDigi, kEcalRawData));
     _dependencies.push_back(Dependency(kEBLaserLedUncalibRecHit, kPnDiodeDigi, kEBDigi, kEcalRawData));
     _dependencies.push_back(Dependency(kEELaserLedUncalibRecHit, kPnDiodeDigi, kEEDigi, kEcalRawData));
   }

bool ecaldqm::LaserTask::analyze	(	void const *	_p,
		Collections	_collection
	)

inlineoverridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 49 of file LaserTask.h.

References ecaldqm::kEBDigi, ecaldqm::kEBLaserLedUncalibRecHit, ecaldqm::kEcalRawData, ecaldqm::kEEDigi, ecaldqm::kEELaserLedUncalibRecHit, ecaldqm::kPnDiodeDigi, runOnDigis(), runOnPnDigis(), runOnRawData(), and runOnUncalibRecHits().

                                                                        {
     switch(_collection){
     case kEcalRawData:
       if(_p) runOnRawData(*static_cast<EcalRawDataCollection const*>(_p));
       return true;
       break;
     case kEBDigi:
       if(_p) runOnDigis(*static_cast<EBDigiCollection const*>(_p));
       return true;
       break;
     case kEEDigi:
       if(_p) runOnDigis(*static_cast<EEDigiCollection const*>(_p));
       return true;
       break;
     case kPnDiodeDigi:
       if(_p) runOnPnDigis(*static_cast<EcalPnDiodeDigiCollection const*>(_p));
       return true;
       break;
     case kEBLaserLedUncalibRecHit:
     case kEELaserLedUncalibRecHit:
       if(_p) runOnUncalibRecHits(*static_cast<EcalUncalibratedRecHitCollection const*>(_p));
       return true;
       break;
     default:
       break;
     }
 
     return false;
   }

void ecaldqm::LaserTask::beginEvent	(	edm::Event const &	_evt,
		edm::EventSetup const &
	)

overridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 84 of file LaserTask.cc.

References pnAmp_.

   {
     pnAmp_.clear();
   }

void ecaldqm::LaserTask::beginLuminosityBlock	(	edm::LuminosityBlock const &	,
		edm::EventSetup const &
	)

overridevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 78 of file LaserTask.cc.

References emptyLS_, and emptyLSLimit_.

   {
     if(++emptyLS_ > emptyLSLimit_) emptyLS_ = -1;
   }

void ecaldqm::LaserTask::beginRun	(	edm::Run const &	,
		edm::EventSetup const &
	)

overridevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 72 of file LaserTask.cc.

References emptyLS_.

   {
     emptyLS_ = 0;
   }

bool ecaldqm::LaserTask::filterRunType ( short const * _runType )

overridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 54 of file LaserTask.cc.

References enable_, EcalDCCHeaderBlock::LASER_GAP, EcalDCCHeaderBlock::LASER_STD, and ecaldqm::nDCC.

   {
     bool enable(false);
 
     for(unsigned iDCC(0); iDCC < nDCC; iDCC++){
       if(_runType[iDCC] == EcalDCCHeaderBlock::LASER_STD ||
      _runType[iDCC] == EcalDCCHeaderBlock::LASER_GAP){
     enable = true;
     enable_[iDCC] = true;
       }
       else
         enable_[iDCC] = false;
     }
 
     return enable;
   }

template<typename DigiCollection >

void ecaldqm::LaserTask::runOnDigis ( DigiCollection const & _digis )

Definition at line 111 of file LaserTask.cc.

References ecalMGPA::adc(), EcalMGPASample::adc(), ecaldqm::dccId(), emptyLS_, enable_, ecaldqm::MESetMulti::fill(), i, bookConverter::max, maxPedestal_, EcalDataFrame::MAXSAMPLES, ecaldqm::DQWorker::MEs_, min(), ecaldqm::nDCC, DetId::null(), pnAmp_, ecaldqm::pnForCrystal(), DetId::rawId(), ecaldqm::rtHalf(), rtHalf_, EcalDataFrame::sample(), dtDQMClient_cfg::threshold, wavelength_, and wlToME_.

Referenced by analyze().

   {
     MESet& meOccupancy(MEs_.at("Occupancy"));
     MESet& meShape(MEs_.at("Shape"));
     MESet& meSignalRate(MEs_.at("SignalRate"));
 
     bool inData[nDCC];
     int nReadouts[nDCC];
     int maxpos[nDCC][EcalDataFrame::MAXSAMPLES];
     bool largeAmplitude[nDCC];
     for(unsigned iDCC(0); iDCC < nDCC; ++iDCC){
       inData[iDCC] = false;
       nReadouts[iDCC] = 0;
       for(int i(0); i < EcalDataFrame::MAXSAMPLES; i++) maxpos[iDCC][i] = 0;
       largeAmplitude[iDCC] = false;
     }
 
     for(typename DigiCollection::const_iterator digiItr(_digis.begin()); digiItr != _digis.end(); ++digiItr){
       const DetId& id(digiItr->id());
 
       unsigned iDCC(dccId(id) - 1);
 
       inData[iDCC] = true;
 
       if(!enable_[iDCC]) continue;
       if(rtHalf(id) != rtHalf_[iDCC]) continue;
 
       meOccupancy.fill(id);
 
       ++nReadouts[iDCC];
 
       EcalDataFrame dataFrame(*digiItr);
 
       int iMax(-1);
       int max(0);
       int min(4096);
       for (int i(0); i < EcalDataFrame::MAXSAMPLES; i++) {
         int adc(dataFrame.sample(i).adc());
         if(adc > max){
           max = adc;
           iMax = i;
         }
         if(adc < min) min = adc;
     if(adc > maxPedestal_) largeAmplitude[iDCC] = true;
       }
       if(iMax >= 0 && max - min > 3) // normal RMS of pedestal is ~2.5
         maxpos[iDCC][iMax] += 1;
     }
 
     // signal existence check
     bool enable(false);
     bool laserOnExpected(emptyLS_ >= 0);
 
     unsigned iME(-1);
 
     for(int iDCC(0); iDCC < nDCC; ++iDCC){
       if(!inData[iDCC]) continue;
 
       if(nReadouts[iDCC] == 0){
         enable_[iDCC] = false;
         continue;
       }
 
       int threshold(nReadouts[iDCC] / 3);
       if(laserOnExpected) enable_[iDCC] = false;
 
       if(largeAmplitude[iDCC]){
     enable = true;
     enable_[iDCC] = true;
       }
       else{
     for(int i(0); i < EcalDataFrame::MAXSAMPLES; i++){
       if(maxpos[iDCC][i] > threshold){
         enable = true;
         enable_[iDCC] = true;
         break;
       }
     }
       }
 
       if(iME != wlToME_[wavelength_[iDCC]]){
         iME = wlToME_[wavelength_[iDCC]];
         static_cast<MESetMulti&>(meSignalRate).use(iME);
       }
 
       meSignalRate.fill(iDCC + 1, enable_[iDCC] ? 1 : 0);
     }
 
     if(enable) emptyLS_ = 0;
     else if(laserOnExpected) return;
 
     iME = -1;
 
     for(typename DigiCollection::const_iterator digiItr(_digis.begin()); digiItr != _digis.end(); ++digiItr){
       const DetId& id(digiItr->id());
 
       unsigned iDCC(dccId(id) - 1);
 
       if(!enable_[iDCC]) continue;
       if(rtHalf(id) != rtHalf_[iDCC]) continue;
 
       EcalDataFrame dataFrame(*digiItr);
 
       if(iME != wlToME_[wavelength_[iDCC]]){
         iME = wlToME_[wavelength_[iDCC]];
         static_cast<MESetMulti&>(meShape).use(iME);
       }
 
       for(int iSample(0); iSample < EcalDataFrame::MAXSAMPLES; iSample++)
     meShape.fill(id, iSample + 0.5, float(dataFrame.sample(iSample).adc()));
 
       EcalPnDiodeDetId pnidA(pnForCrystal(id, 'a'));
       EcalPnDiodeDetId pnidB(pnForCrystal(id, 'b'));
       if(pnidA.null() || pnidB.null()) continue;
       pnAmp_.insert(std::make_pair(pnidA.rawId(), 0.));
       pnAmp_.insert(std::make_pair(pnidB.rawId(), 0.));
     }
   }

void ecaldqm::LaserTask::runOnPnDigis ( EcalPnDiodeDigiCollection const & _digis )

Definition at line 231 of file LaserTask.cc.

References edm::SortedCollection< T, SORT >::begin(), ecaldqm::dccId(), enable_, edm::SortedCollection< T, SORT >::end(), ecaldqm::MESetMulti::fill(), bookConverter::max, ecaldqm::DQWorker::MEs_, ecaldqm::nDCC, EcalCondDBWriter_cfi::pedestal, pnAmp_, wavelength_, and wlToME_.

Referenced by analyze().

   {
     MESet& mePNAmplitude(MEs_.at("PNAmplitude"));
 
     bool enable(false);
     for(unsigned iDCC(0); iDCC < nDCC; ++iDCC)
       enable |= enable_[iDCC];
     if(!enable) return;
 
     unsigned iME(-1);
 
     for(EcalPnDiodeDigiCollection::const_iterator digiItr(_digis.begin()); digiItr != _digis.end(); ++digiItr){
       if(digiItr->sample(0).gainId() != 0 && digiItr->sample(0).gainId() != 1) continue;
 
       const EcalPnDiodeDetId& id(digiItr->id());
 
       std::map<uint32_t, float>::iterator ampItr(pnAmp_.find(id.rawId()));
       if(ampItr == pnAmp_.end()) continue;
 
       unsigned iDCC(dccId(id) - 1);
 
       double pedestal(0.);
       for(int iSample(0); iSample < 4; iSample++)
     pedestal += digiItr->sample(iSample).adc();
       pedestal /= 4.;
 
       double max(0.);
       for(int iSample(0); iSample < 50; iSample++){
     float amp(digiItr->sample(iSample).adc() - pedestal);
     if(amp > max) max = amp;
       }
 
       if(iME != wlToME_[wavelength_[iDCC]]){
         iME = wlToME_[wavelength_[iDCC]];
         static_cast<MESetMulti&>(mePNAmplitude).use(iME);
       }
 
       mePNAmplitude.fill(id, max);
 
       ampItr->second = max;
     }
   }

void ecaldqm::LaserTask::runOnRawData ( EcalRawDataCollection const & _rawData )

Definition at line 90 of file LaserTask.cc.

References edm::SortedCollection< T, SORT >::begin(), enable_, edm::SortedCollection< T, SORT >::end(), rtHalf_, wavelength_, and wlToME_.

Referenced by analyze().

   {
     for(EcalRawDataCollection::const_iterator rItr(_rawData.begin()); rItr != _rawData.end(); ++rItr){
       unsigned iDCC(rItr->id() - 1);
 
       if(!enable_[iDCC]){
         wavelength_[iDCC] = -1;
         rtHalf_[iDCC] = -1;
         continue;
       }
       wavelength_[iDCC] = rItr->getEventSettings().wavelength + 1;
 
       if(wlToME_.find(wavelength_[iDCC]) == wlToME_.end())
         enable_[iDCC] = false;
 
       rtHalf_[iDCC] = rItr->getRtHalf();
     }
   }

void ecaldqm::LaserTask::runOnUncalibRecHits ( EcalUncalibratedRecHitCollection const & _uhits )

Definition at line 275 of file LaserTask.cc.

References edm::SortedCollection< T, SORT >::begin(), ecaldqm::dccId(), enable_, edm::SortedCollection< T, SORT >::end(), ecaldqm::MESetMulti::fill(), bookConverter::max, ecaldqm::DQWorker::MEs_, ecaldqm::nDCC, pnAmp_, ecaldqm::pnForCrystal(), ecaldqm::rtHalf(), rtHalf_, wavelength_, and wlToME_.

Referenced by analyze().

   {
     MESet& meAmplitude(MEs_.at("Amplitude"));
     MESet& meAmplitudeSummary(MEs_.at("AmplitudeSummary"));
     MESet& meTiming(MEs_.at("Timing"));
     MESet& meAOverP(MEs_.at("AOverP"));
 
     using namespace std;
 
     bool enable(false);
     for(unsigned iDCC(0); iDCC < nDCC; ++iDCC)
       enable |= enable_[iDCC];
     if(!enable) return;
 
     unsigned iME(-1);
 
     for(EcalUncalibratedRecHitCollection::const_iterator uhitItr(_uhits.begin()); uhitItr != _uhits.end(); ++uhitItr){
       const DetId& id(uhitItr->id());
 
       unsigned iDCC(dccId(id) - 1);
 
       if(!enable_[iDCC]) continue;
       if(rtHalf(id) != rtHalf_[iDCC]) continue;
 
       if(iME != wlToME_[wavelength_[iDCC]]){
         iME = wlToME_[wavelength_[iDCC]];
         static_cast<MESetMulti&>(meAmplitude).use(iME);
         static_cast<MESetMulti&>(meAmplitudeSummary).use(iME);
         static_cast<MESetMulti&>(meTiming).use(iME);
         static_cast<MESetMulti&>(meAOverP).use(iME);
       }
 
       float amp(max((double)uhitItr->amplitude(), 0.));
       float jitter(max((double)uhitItr->jitter() + 5.0, 0.));
 
       meAmplitude.fill(id, amp);
       meAmplitudeSummary.fill(id, amp);
       meTiming.fill(id, jitter);
 
       float aop(0.);
 
       map<uint32_t, float>::iterator ampItrA(pnAmp_.find(pnForCrystal(id, 'a')));
       map<uint32_t, float>::iterator ampItrB(pnAmp_.find(pnForCrystal(id, 'b')));
       if(ampItrA == pnAmp_.end() && ampItrB == pnAmp_.end()) continue;
       else if(ampItrB == pnAmp_.end()) aop = amp / ampItrA->second;
       else if(ampItrA == pnAmp_.end()) aop = amp / ampItrB->second;
       else aop = amp / (ampItrA->second + ampItrB->second) * 2.;
 
       meAOverP.fill(id, aop);
     }
   }

void ecaldqm::LaserTask::setParams ( edm::ParameterSet const & _params )

overrideprivatevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 23 of file LaserTask.cc.

References emptyLSLimit_, Exception, ecaldqm::MESetMulti::getIndex(), edm::ParameterSet::getUntrackedParameter(), maxPedestal_, ecaldqm::DQWorker::MEs_, cond::to_string(), and wlToME_.

   {
     emptyLSLimit_ = _params.getUntrackedParameter<int>("emptyLSLimit");
 
     std::vector<int> laserWavelengths(_params.getUntrackedParameter<std::vector<int> >("laserWavelengths"));
 
     MESet::PathReplacements repl;
 
     MESetMulti& amplitude(static_cast<MESetMulti&>(MEs_.at("Amplitude")));
     unsigned nWL(laserWavelengths.size());
     for(unsigned iWL(0); iWL != nWL; ++iWL){
       int wl(laserWavelengths[iWL]);
       if(wl <= 0 || wl >= 5) throw cms::Exception("InvalidConfiguration") << "Laser Wavelength";
       repl["wl"] = std::to_string(wl);
       wlToME_[wl] = amplitude.getIndex(repl);
     }
 
     maxPedestal_ = _params.getUntrackedParameter<int>("maxPedestal");
   }