#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 &)

const std::string &	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 () noexcept(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

◆ Wavelength

enum ecaldqm::LaserTask::Wavelength

Enumerator
kGreen
kBlue
kIRed
nWavelength

Definition at line 35 of file LaserTask.h.

35 { kGreen, kBlue, kIRed, nWavelength };

Constructor & Destructor Documentation

◆ LaserTask()

LaserTask::LaserTask ( )

Definition at line 8 of file LaserTask.cc.

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

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

◆ ~LaserTask()

ecaldqm::LaserTask::~LaserTask ( )

inlineoverride

Definition at line 17 of file LaserTask.h.

17 {}

Member Function Documentation

◆ addDependencies()

void LaserTask::addDependencies ( DependencySet & _dependencies )

overridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 34 of file LaserTask.cc.

                                                               {
     _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));
   }

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

◆ analyze()

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

inlineoverridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 52 of file LaserTask.h.

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

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

◆ beginEvent()

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

overridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 63 of file LaserTask.cc.

63 { pnAmp_.clear(); }

References pnAmp_.

◆ beginLuminosityBlock()

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

overridevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 58 of file LaserTask.cc.

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

References emptyLS_, and emptyLSLimit_.

◆ beginRun()

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

overridevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 56 of file LaserTask.cc.

56 { emptyLS_ = 0; }

References emptyLS_.

◆ filterRunType()

bool LaserTask::filterRunType ( short const * _runType )

overridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 42 of file LaserTask.cc.

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

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

◆ runOnDigis()

template<typename DigiCollection >

void LaserTask::runOnDigis ( DigiCollection const & _digis )

Definition at line 109 of file LaserTask.cc.

                                                          {
     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.));
     }
   }

References ecalMGPA::adc(), EcalMGPASample::adc(), ecaldqm::dccId(), emptyLS_, Reconstruction_hiPF_cff::enable, enable_, 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(), remoteMonitoring_LED_IterMethod_cfg::threshold, wavelength_, and wlToME_.

Referenced by analyze().

◆ runOnPnDigis()

void LaserTask::runOnPnDigis ( EcalPnDiodeDigiCollection const & _digis )

Definition at line 238 of file LaserTask.cc.

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

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

Referenced by analyze().

◆ runOnRawData()

void LaserTask::runOnRawData ( EcalRawDataCollection const & _rawData )

Definition at line 65 of file LaserTask.cc.

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

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

◆ runOnUncalibRecHits()

void LaserTask::runOnUncalibRecHits ( EcalUncalibratedRecHitCollection const & _uhits )

Definition at line 284 of file LaserTask.cc.

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

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

Referenced by analyze().

◆ setParams()

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

overrideprivatevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 14 of file LaserTask.cc.

                                                           {
     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");
   }

References l1extraParticles_cfi::_params, CustomPhysics_cfi::amplitude, emptyLSLimit_, Exception, CalibrationSummaryClient_cfi::laserWavelengths, maxPedestal_, ecaldqm::DQWorker::MEs_, LaserClient_cfi::wl, and wlToME_.

Member Data Documentation

◆ emptyLS_

int ecaldqm::LaserTask::emptyLS_

private

Definition at line 47 of file LaserTask.h.

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

◆ emptyLSLimit_

int ecaldqm::LaserTask::emptyLSLimit_

private

Definition at line 48 of file LaserTask.h.

Referenced by beginLuminosityBlock(), and setParams().

◆ enable_

bool ecaldqm::LaserTask::enable_[nDCC]

private

Definition at line 42 of file LaserTask.h.

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

◆ maxPedestal_

int ecaldqm::LaserTask::maxPedestal_

private

Definition at line 49 of file LaserTask.h.

Referenced by runOnDigis(), and setParams().

◆ pnAmp_

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

private

Definition at line 45 of file LaserTask.h.

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

◆ rtHalf_

unsigned ecaldqm::LaserTask::rtHalf_[nDCC]

private

Definition at line 44 of file LaserTask.h.

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

◆ wavelength_

unsigned ecaldqm::LaserTask::wavelength_[nDCC]

private

Definition at line 43 of file LaserTask.h.

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

◆ wlToME_

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

private

Definition at line 40 of file LaserTask.h.

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

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ Wavelength

Constructor & Destructor Documentation

◆ LaserTask()

◆ ~LaserTask()

Member Function Documentation

◆ addDependencies()

◆ analyze()

◆ beginEvent()

◆ beginLuminosityBlock()

◆ beginRun()

◆ filterRunType()

◆ runOnDigis()

◆ runOnPnDigis()

◆ runOnRawData()

◆ runOnUncalibRecHits()

◆ setParams()

Member Data Documentation

◆ emptyLS_

◆ emptyLSLimit_

◆ enable_

◆ maxPedestal_

◆ pnAmp_

◆ rtHalf_

◆ wavelength_

◆ wlToME_