ecaldqm::LaserTask Class Reference

#include <LaserTask.h>

Inheritance diagram for ecaldqm::LaserTask:

Public Types
enum	Wavelength { kGreen, kBlue, kIRed, nWavelength }
Public Types inherited from ecaldqm::DQWorkerTask
typedef EcalDCCHeaderBlock::EcalDCCEventSettings	EventSettings

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 () override
Public Member Functions inherited from ecaldqm::DQWorkerTask
	DQWorkerTask ()
virtual void	endEvent (edm::Event const &, edm::EventSetup const &)
virtual bool	filterTrigger (edm::TriggerResultsByName const &)
virtual void	setTokens (edm::ConsumesCollector &)
	~DQWorkerTask () override
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 ()(false)

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
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 Types inherited from ecaldqm::DQWorker
typedef dqm::legacy::DQMStore	DQMStore
typedef dqm::legacy::MonitorElement	MonitorElement
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::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.

Member Enumeration Documentation

enum ecaldqm::LaserTask::Wavelength

Enumerator
kGreen
kBlue
kIRed
nWavelength

Definition at line 35 of file LaserTask.h.

{ kGreen, kBlue, kIRed, nWavelength };

Constructor & Destructor Documentation

LaserTask::LaserTask

(

)

Definition at line 8 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 ( )

inlineoverride

Definition at line 17 of file LaserTask.h.

References addDependencies(), analyze(), beginEvent(), beginLuminosityBlock(), beginRun(), siStripShotFilter_cfi::DigiCollection, filterRunType(), runOnDigis(), runOnPnDigis(), runOnRawData(), and runOnUncalibRecHits().

{}

Member Function Documentation

void LaserTask::addDependencies ( DependencySet &  _dependencies )

overridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 34 of file LaserTask.cc.

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

Referenced by ~LaserTask().

                                                              {
    _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 LaserTask::analyze ( void const *  _p, Collections  _collection  )

inlineoverridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 52 of file LaserTask.h.

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

Referenced by ~LaserTask().

                                                                        {
    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 LaserTask::beginEvent ( edm::Event const &  _evt, edm::EventSetup const &    )

overridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 63 of file LaserTask.cc.

References pnAmp_.

Referenced by ~LaserTask().

{ pnAmp_.clear(); }

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

overridevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 58 of file LaserTask.cc.

References emptyLS_, and emptyLSLimit_.

Referenced by ~LaserTask().

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

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

overridevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 56 of file LaserTask.cc.

References emptyLS_.

Referenced by ~LaserTask().

{ emptyLS_ = 0; }

bool LaserTask::filterRunType ( short const *  _runType )

overridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 42 of file LaserTask.cc.

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

Referenced by ~LaserTask().

                                                     {
    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 LaserTask::runOnDigis

(

DigiCollection const &

_digis

)

Definition at line 109 of file LaserTask.cc.

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

Referenced by analyze(), and ~LaserTask().

                                                         {
    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 LaserTask::runOnPnDigis

(

EcalPnDiodeDigiCollection const &

_digis

)

Definition at line 238 of file LaserTask.cc.

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

Referenced by analyze(), and ~LaserTask().

                                                                      {
    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 LaserTask::runOnRawData

(

EcalRawDataCollection const &

_rawData

)

Definition at line 65 of file LaserTask.cc.

References edm::SortedCollection< T, SORT >::begin(), enable_, edm::SortedCollection< T, SORT >::end(), ecaldqm::DQWorker::MEs_, ecaldqm::nDCC, nWavelength, rtHalf_, wavelength_, and wlToME_.

Referenced by analyze(), and ~LaserTask().

                                                                    {
    MESet& meCalibStatus(MEs_.at("CalibStatus"));
    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();
    }
    bool LaserStatus[nWavelength];
    for (unsigned iW(0); iW < nWavelength; iW++) {
      LaserStatus[iW] = false;
    }
    for (unsigned iDCC(0); iDCC < nDCC; iDCC++) {
      switch (wavelength_[iDCC]) {
        case 1:
          break;
        case 2:
          LaserStatus[Wavelength::kGreen] = true;
          break;
        case 3:
          LaserStatus[Wavelength::kBlue] = true;
          break;
        case 4:
          LaserStatus[Wavelength::kIRed] = true;
          break;
        default:
          break;
      }
    }
    for (unsigned iWL(0); iWL < nWavelength; iWL++) {
      meCalibStatus.fill(double(iWL), LaserStatus[iWL] ? 1 : 0);
    }
  }

void LaserTask::runOnUncalibRecHits

(

EcalUncalibratedRecHitCollection const &

_uhits

)

Definition at line 284 of file LaserTask.cc.

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

Referenced by analyze(), and ~LaserTask().

                                                                                    {
    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 LaserTask::setParams ( edm::ParameterSet const &  _params )

overrideprivatevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 14 of file LaserTask.cc.

References CustomPhysics_cfi::amplitude, emptyLSLimit_, Exception, ecaldqm::MESetMulti::getIndex(), edm::ParameterSet::getUntrackedParameter(), CalibrationSummaryClient_cfi::laserWavelengths, maxPedestal_, ecaldqm::DQWorker::MEs_, LaserClient_cfi::wl, 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");
  }

Member Data Documentation

int ecaldqm::LaserTask::emptyLS_

private

Definition at line 47 of file LaserTask.h.

Referenced by beginLuminosityBlock(), beginRun(), and runOnDigis().

int ecaldqm::LaserTask::emptyLSLimit_

private

Definition at line 48 of file LaserTask.h.

Referenced by beginLuminosityBlock(), and setParams().

bool ecaldqm::LaserTask::enable_[nDCC]

private

Definition at line 42 of file LaserTask.h.

Referenced by filterRunType(), LaserTask(), runOnDigis(), runOnPnDigis(), runOnRawData(), and runOnUncalibRecHits().

int ecaldqm::LaserTask::maxPedestal_

private

Definition at line 49 of file LaserTask.h.

Referenced by runOnDigis(), and setParams().

std::map<uint32_t, float> ecaldqm::LaserTask::pnAmp_

private

Definition at line 45 of file LaserTask.h.

Referenced by beginEvent(), runOnDigis(), runOnPnDigis(), and runOnUncalibRecHits().

unsigned ecaldqm::LaserTask::rtHalf_[nDCC]

private

Definition at line 44 of file LaserTask.h.

Referenced by LaserTask(), runOnDigis(), runOnRawData(), and runOnUncalibRecHits().

unsigned ecaldqm::LaserTask::wavelength_[nDCC]

private

Definition at line 43 of file LaserTask.h.

Referenced by LaserTask(), runOnDigis(), runOnPnDigis(), runOnRawData(), and runOnUncalibRecHits().

std::map<int, unsigned> ecaldqm::LaserTask::wlToME_

private

Definition at line 40 of file LaserTask.h.

Referenced by runOnDigis(), runOnPnDigis(), runOnRawData(), runOnUncalibRecHits(), and setParams().