#include <SelectiveReadoutTask.h>

Inheritance diagram for ecaldqm::SelectiveReadoutTask:

Public Types
enum	Constants { nFIRTaps = 6, bytesPerCrystal = 24, nRU = EcalTrigTowerDetId::kEBTotalTowers + EcalScDetId::kSizeForDenseIndexing }

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	beginRun (edm::Run const &, edm::EventSetup const &) override

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

void	runOnRawData (EcalRawDataCollection const &)

void	runOnSource (FEDRawDataCollection const &)

template<typename SRFlagCollection >
void	runOnSrFlags (SRFlagCollection const &, Collections)

	SelectiveReadoutTask ()

	~SelectiveReadoutTask ()

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

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

virtual bool	filterRunType (short 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	beginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)

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	setFIRWeights_ (std::vector< double > const &)

void	setParams (edm::ParameterSet const &) override

Private Attributes
std::vector< short >	flags_

int	iFirstSample_

std::set< std::pair< int, int > >	suppressed_

bool	useCondDb_

std::vector< int >	ZSFIRWeights_

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 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 18 of file SelectiveReadoutTask.h.

Member Enumeration Documentation

enum ecaldqm::SelectiveReadoutTask::Constants

Enumerator
nFIRTaps
bytesPerCrystal
nRU

Definition at line 35 of file SelectiveReadoutTask.h.

                    {
       nFIRTaps = 6,
       bytesPerCrystal = 24,
       nRU = EcalTrigTowerDetId::kEBTotalTowers + EcalScDetId::kSizeForDenseIndexing
     };

Constructor & Destructor Documentation

ecaldqm::SelectiveReadoutTask::SelectiveReadoutTask ( )

Definition at line 20 of file SelectiveReadoutTask.cc.

                                              :
     DQWorkerTask(),
     useCondDb_(false),
     iFirstSample_(0),
     ZSFIRWeights_(nFIRTaps, 0.),
     suppressed_(),
     flags_(nRU, -1)
   {
   }

ecaldqm::SelectiveReadoutTask::~SelectiveReadoutTask ( )

inline

Definition at line 21 of file SelectiveReadoutTask.h.

References addDependencies(), analyze(), beginEvent(), beginRun(), runOnDigis(), runOnRawData(), runOnSource(), and runOnSrFlags().

21 {}

Member Function Documentation

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

overridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 43 of file SelectiveReadoutTask.cc.

References ecaldqm::kEBDigi, ecaldqm::kEBSrFlag, ecaldqm::kEcalRawData, ecaldqm::kEEDigi, ecaldqm::kEESrFlag, and ecaldqm::DependencySet::push_back().

Referenced by ~SelectiveReadoutTask().

   {
     _dependencies.push_back(Dependency(kEBDigi, kEcalRawData, kEBSrFlag));
     _dependencies.push_back(Dependency(kEEDigi, kEcalRawData, kEESrFlag));
   }

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

inlineoverridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 54 of file SelectiveReadoutTask.h.

References ecaldqm::kEBDigi, ecaldqm::kEBSrFlag, ecaldqm::kEcalRawData, ecaldqm::kEEDigi, ecaldqm::kEESrFlag, ecaldqm::kSource, runOnDigis(), runOnRawData(), runOnSource(), and runOnSrFlags().

Referenced by ~SelectiveReadoutTask().

                                                                                   {
     switch(_collection){
     case kSource:
       if(_p) runOnSource(*static_cast<FEDRawDataCollection const*>(_p));
       return true;
       break;
     case kEcalRawData:
       if(_p) runOnRawData(*static_cast<EcalRawDataCollection const*>(_p));
       return true;
       break;
     case kEBSrFlag:
       if(_p) runOnSrFlags(*static_cast<EBSrFlagCollection const*>(_p), _collection);
       return true;
       break;
     case kEESrFlag:
       if(_p) runOnSrFlags(*static_cast<EESrFlagCollection const*>(_p), _collection);
       return true;
       break;
     case kEBDigi:
       if(_p) runOnDigis(*static_cast<EBDigiCollection const*>(_p), _collection);
       return true;
       break;
     case kEEDigi:
       if(_p) runOnDigis(*static_cast<EEDigiCollection const*>(_p), _collection);
       return true;
       break;
     default:
       break;
     }
     return false;
   }

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

overridevirtual

Reimplemented from ecaldqm::DQWorkerTask.

Definition at line 71 of file SelectiveReadoutTask.cc.

References flags_, nRU, and suppressed_.

Referenced by ~SelectiveReadoutTask().

   {
     flags_.assign(nRU, -1);
     suppressed_.clear();
   }

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

overridevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 50 of file SelectiveReadoutTask.cc.

References begin, EcalSRSettings::dccNormalizedWeights_, edm::EventSetup::get(), setFIRWeights_(), useCondDb_, and create_public_lumi_plots::weights.

Referenced by ~SelectiveReadoutTask().

   {
     using namespace std;
 
     if(useCondDb_){
       edm::ESHandle<EcalSRSettings> hSr;
       _es.get<EcalSRSettingsRcd>().get(hSr);
 
       vector<vector<float> > weights(hSr->dccNormalizedWeights_);
       if(weights.size() == 1){
     vector<double> normWeights;
     for(vector<float>::iterator it(weights[0].begin()); it != weights[0].end(); it++)
       normWeights.push_back(*it);
 
     setFIRWeights_(normWeights);
       }
       else edm::LogWarning("EcalDQM") << "SelectiveReadoutTask: DCC weight set is not exactly 1.";
     }
   }

template<typename DigiCollection >

void ecaldqm::SelectiveReadoutTask::runOnDigis	(	DigiCollection const &	_digis,
		Collections	_collection
	)

Definition at line 161 of file SelectiveReadoutTask.cc.

References EcalMGPASample::adc(), bytesPerCrystal, ecaldqm::dccId(), EcalTrigTowerDetId::detIdFromDenseIndex(), EcalBarrel, EcalEndcap, RemoveAddSevLevel::flag, flags_, EcalMGPASample::gainId(), ecaldqm::getElectronicsMap(), EcalTrigTowerDetId::hashedIndex(), EcalScDetId::hashedIndex(), hcalTTPDigis_cfi::id, iFirstSample_, ecaldqm::kEBDigi, EcalTrigTowerDetId::kEBTotalTowers, ecaldqm::kEEmHigh, EcalScDetId::kSizeForDenseIndexing, hpstanc_transforms::max, ecaldqm::DQWorker::MEs_, ecaldqm::nEBDCC, ecaldqm::nEEDCC, nFIRTaps, simplePhotonAnalyzer_cfi::sample, EEDetId::sc(), EcalDataFrame::size(), findQualityFiles::size, EcalSrFlag::SRF_FORCED_MASK, EcalSrFlag::SRF_FULL, EcalSrFlag::SRF_ZS1, EcalSrFlag::SRF_ZS2, suppressed_, EBDetId::tower(), ecaldqm::towerId(), EcalScDetId::unhashIndex(), and ZSFIRWeights_.

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

   {
     MESet& meHighIntOutput(MEs_.at("HighIntOutput"));
     MESet& meLowIntOutput(MEs_.at("LowIntOutput"));
     MESet& meHighIntPayload(MEs_.at("HighIntPayload"));
     MESet& meLowIntPayload(MEs_.at("LowIntPayload"));
     MESet& meTowerSize(MEs_.at("TowerSize"));
     MESet& meZSFullReadoutMap(MEs_.at("ZSFullReadoutMap"));
     MESet& meFRDroppedMap(MEs_.at("FRDroppedMap"));
     MESet& meZSFullReadout(MEs_.at("ZSFullReadout"));
     MESet& meFRDropped(MEs_.at("FRDropped"));
 
     bool isEB(_collection == kEBDigi);
 
     unsigned const nTower(isEB ? unsigned(EcalTrigTowerDetId::kEBTotalTowers) : unsigned(EcalScDetId::kSizeForDenseIndexing));
 
     std::vector<unsigned> sizes(nTower, 0);
 
     int nHighInt[] = {0, 0};
     int nLowInt[] = {0, 0};
 
     for(typename DigiCollection::const_iterator digiItr(_digis.begin()); digiItr != _digis.end(); ++digiItr){
 
       DetId const& id(digiItr->id());
 
       unsigned iTower(-1);
       unsigned iRU(-1);
 
       if(isEB){
         iTower = EBDetId(id).tower().hashedIndex();
         iRU = iTower;
       }
       else{
         iTower = EEDetId(id).sc().hashedIndex();
         iRU = iTower + EcalTrigTowerDetId::kEBTotalTowers;
       }
 
       if(flags_[iRU] < 0) continue;
 
       sizes[iTower] += 1;
 
       // SR filter output calculation
 
       EcalDataFrame frame(*digiItr);
 
       int ZSFIRValue(0); // output
 
       bool gain12saturated(false);
       const int gain12(0x01);
 
       for(int iWeight(0); iWeight < nFIRTaps; ++iWeight){
 
     int iSample(iFirstSample_ + iWeight - 1);
 
     if(iSample >= 0 && iSample < frame.size()){
       EcalMGPASample sample(frame[iSample]);
       if(sample.gainId() != gain12){
         gain12saturated = true;
         break;
       }
       ZSFIRValue += sample.adc() * ZSFIRWeights_[iWeight];
     }else{
       edm::LogWarning("EcalDQM") << "SelectiveReadoutTask: Not enough samples in data frame or 'ecalDccZs1stSample' module parameter is not valid";
     }
 
       }
 
       if(gain12saturated) ZSFIRValue = std::numeric_limits<int>::max();
       else ZSFIRValue /= (0x1 << 8); //discards the 8 LSBs
 
       //ZS passed if weighted sum above ZS threshold or if
       //one sample has a lower gain than gain 12 (that is gain 12 output
       //is saturated)
 
       bool highInterest((flags_[iRU] & ~EcalSrFlag::SRF_FORCED_MASK) == EcalSrFlag::SRF_FULL);
 
       if(highInterest){
     meHighIntOutput.fill(id, ZSFIRValue);
         if(isEB || dccId(id) - 1 <= kEEmHigh)
           nHighInt[0] += 1;
         else
           nHighInt[1] += 1;
       }
       else{
     meLowIntOutput.fill(id, ZSFIRValue);
         if(isEB || dccId(id) - 1 <= kEEmHigh)
           nLowInt[0] += 1;
         else
           nLowInt[1] += 1;
       }
     }
 
     if(isEB){
       meHighIntPayload.fill(EcalBarrel, nHighInt[0] * bytesPerCrystal / 1024. / nEBDCC);
       meLowIntPayload.fill(EcalBarrel, nLowInt[0] * bytesPerCrystal / 1024. / nEBDCC);
     }
     else{
       meHighIntPayload.fill(-EcalEndcap, nHighInt[0] * bytesPerCrystal / 1024. / (nEEDCC / 2));
       meHighIntPayload.fill(EcalEndcap, nHighInt[1] * bytesPerCrystal / 1024. / (nEEDCC / 2));
       meLowIntPayload.fill(-EcalEndcap, nLowInt[0] * bytesPerCrystal / 1024. / (nEEDCC / 2));
       meLowIntPayload.fill(EcalEndcap, nLowInt[1] * bytesPerCrystal / 1024. / (nEEDCC / 2));
     }
 
     unsigned iRU(isEB ? 0 : EcalTrigTowerDetId::kEBTotalTowers);
     for(unsigned iTower(0); iTower < nTower; ++iTower, ++iRU){
       DetId id;
       if(isEB) id = EcalTrigTowerDetId::detIdFromDenseIndex(iTower);
       else id = EcalScDetId::unhashIndex(iTower);
 
       double towerSize(sizes[iTower] * bytesPerCrystal);
 
       meTowerSize.fill(id, towerSize);
 
       if(flags_[iRU] < 0) continue;
 
       int dccid(dccId(id));
       int towerid(towerId(id));
 
       if(suppressed_.find(std::make_pair(dccid, towerid)) != suppressed_.end()) continue;
 
       int flag(flags_[iRU] & ~EcalSrFlag::SRF_FORCED_MASK);
 
       bool ruFullyReadout(sizes[iTower] == getElectronicsMap()->dccTowerConstituents(dccid, towerid).size());
 
       if(ruFullyReadout && (flag == EcalSrFlag::SRF_ZS1 || flag == EcalSrFlag::SRF_ZS2)){
     meZSFullReadoutMap.fill(id);
         meZSFullReadout.fill(id);
       }
 
       if(sizes[iTower] == 0 && flag == EcalSrFlag::SRF_FULL){
         meFRDroppedMap.fill(id);
         meFRDropped.fill(id);
       }
     }
   }

void ecaldqm::SelectiveReadoutTask::runOnRawData ( EcalRawDataCollection const & _dcchs )

Definition at line 102 of file SelectiveReadoutTask.cc.

References edm::SortedCollection< T, SORT >::begin(), ecaldqm::Disabled, edm::SortedCollection< T, SORT >::end(), and suppressed_.

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

   {
     for(EcalRawDataCollection::const_iterator dcchItr(_dcchs.begin()); dcchItr != _dcchs.end(); ++dcchItr){
       std::vector<short> const& feStatus(dcchItr->getFEStatus());
       unsigned nFE(feStatus.size());
       for(unsigned iFE(0); iFE < nFE; ++iFE)
         if(feStatus[iFE] == Disabled) suppressed_.insert(std::make_pair(dcchItr->id(), iFE + 1));
     }
   }

void ecaldqm::SelectiveReadoutTask::runOnSource ( FEDRawDataCollection const & _fedRaw )

Definition at line 78 of file SelectiveReadoutTask.cc.

References EcalBarrel, EcalEndcap, FEDRawDataCollection::FEDData(), ecaldqm::kEEmHigh, ecaldqm::kEEpLow, ecaldqm::DQWorker::MEs_, FEDRawData::size(), and findQualityFiles::size.

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

   {
     MESet& meDCCSize(MEs_.at("DCCSize"));
     MESet& meDCCSizeProf(MEs_.at("DCCSizeProf"));
     MESet& meEventSize(MEs_.at("EventSize"));
 
     float ebSize(0.), eemSize(0.), eepSize(0.);
 
     // DCC event size
     for(int iFED(601); iFED <= 654; iFED++){
       float size(_fedRaw.FEDData(iFED).size() / 1024.);
       meDCCSize.fill(iFED - 600, size);
       meDCCSizeProf.fill(iFED - 600, size);
       if(iFED - 601 <= kEEmHigh) eemSize += size;
       else if(iFED - 601 >= kEEpLow) eepSize += size;
       else ebSize += size;
     }
 
     meEventSize.fill(-EcalEndcap, eemSize / 9.);
     meEventSize.fill(EcalEndcap, eepSize / 9.);
     meEventSize.fill(EcalBarrel, ebSize / 36.);
   }

template<typename SRFlagCollection >

void ecaldqm::SelectiveReadoutTask::runOnSrFlags	(	SRFlagCollection const &	_srfs,
		Collections	_col
	)

Definition at line 114 of file SelectiveReadoutTask.cc.

References EcalBarrel, EcalEndcap, EcalTriggerTower, RemoveAddSevLevel::flag, flags_, EcalTrigTowerDetId::hashedIndex(), EcalScDetId::hashedIndex(), hcalTTPDigis_cfi::id, ecaldqm::kEBSrFlag, EcalTrigTowerDetId::kEBTotalTowers, ecaldqm::DQWorker::MEs_, EcalSrFlag::SRF_FORCED_MASK, EcalSrFlag::SRF_FULL, EcalSrFlag::SRF_ZS1, and EcalSrFlag::SRF_ZS2.

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

   {
     MESet& meFlagCounterMap(MEs_.at("FlagCounterMap"));
     MESet& meFullReadoutMap(MEs_.at("FullReadoutMap"));
     MESet& meZS1Map(MEs_.at("ZS1Map"));
     MESet& meZSMap(MEs_.at("ZSMap"));
     MESet& meRUForcedMap(MEs_.at("RUForcedMap"));
 
     double nFR(0.);
 
     std::for_each(_srfs.begin(), _srfs.end(), [&](typename SRFlagCollection::value_type const& srf){
                     DetId const& id(srf.id());
                     int flag(srf.value());
 
                     meFlagCounterMap.fill(id);
 
                     unsigned iRU(-1);
                     if(id.subdetId() == EcalTriggerTower)
                       iRU = EcalTrigTowerDetId(id).hashedIndex();
                     else
                       iRU = EcalScDetId(id).hashedIndex() + EcalTrigTowerDetId::kEBTotalTowers;
                     flags_[iRU] = flag;
 
                     switch(flag & ~EcalSrFlag::SRF_FORCED_MASK){
                     case EcalSrFlag::SRF_FULL:
                       meFullReadoutMap.fill(id);
                       nFR += 1.;
                       break;
                     case EcalSrFlag::SRF_ZS1:
                       meZS1Map.fill(id);
                       // fallthrough
                     case EcalSrFlag::SRF_ZS2:
                       meZSMap.fill(id);
                       break;
                     default:
                       break;
                     }
 
                     if(flag & EcalSrFlag::SRF_FORCED_MASK)
                       meRUForcedMap.fill(id);
                   });
 
     MEs_.at("FullReadout").fill(_col == kEBSrFlag ? EcalBarrel : EcalEndcap, nFR);
   }

void ecaldqm::SelectiveReadoutTask::setFIRWeights_ ( std::vector< double > const & _normWeights )

private

Definition at line 298 of file SelectiveReadoutTask.cc.

References funct::abs(), DEFINE_ECALDQM_WORKER, Exception, mps_fire::i, nFIRTaps, and ZSFIRWeights_.

Referenced by beginRun(), and setParams().

   {
     if(_normWeights.size() < nFIRTaps)
       throw cms::Exception("InvalidConfiguration") << "weightsForZsFIR" << std::endl;
 
     bool notNormalized(false), notInt(false);
     for(std::vector<double>::const_iterator it(_normWeights.begin()); it != _normWeights.end(); ++it){
       if(*it > 1.) notNormalized = true;
       if(int(*it) != *it) notInt = true;
     }
     if(notInt && notNormalized){
       throw cms::Exception("InvalidConfiguration")
     << "weigtsForZsFIR paramater values are not valid: they "
     << "must either be integer and uses the hardware representation "
     << "of the weights or less or equal than 1 and used the normalized "
     << "representation.";
     }
 
     ZSFIRWeights_.clear();
     ZSFIRWeights_.resize(_normWeights.size());
 
     if(notNormalized){
       for(unsigned i(0); i< ZSFIRWeights_.size(); ++i)
     ZSFIRWeights_[i] = int(_normWeights[i]);
     }
     else{
       const int maxWeight(0xEFF); //weights coded on 11+1 signed bits
       for(unsigned i(0); i < ZSFIRWeights_.size(); ++i){
     ZSFIRWeights_[i] = lround(_normWeights[i] * (0x1 << 10));
     if(std::abs(ZSFIRWeights_[i]) > maxWeight) //overflow
       ZSFIRWeights_[i] = ZSFIRWeights_[i] < 0 ? -maxWeight : maxWeight;
       }
     }
   }

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

overrideprivatevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 31 of file SelectiveReadoutTask.cc.

References edm::ParameterSet::getUntrackedParameter(), iFirstSample_, setFIRWeights_(), and useCondDb_.

   {
     useCondDb_ = _params.getUntrackedParameter<bool>("useCondDb");
     iFirstSample_ = _params.getUntrackedParameter<int>("DCCZS1stSample");
 
     if(!useCondDb_){
       std::vector<double> normWeights(_params.getUntrackedParameter<std::vector<double> >("ZSFIRWeights"));
       setFIRWeights_(normWeights);
     }
   }