#include <DQM/SiStripMonitorHardware/plugins/SiStripFEDMonitor.cc>

Inheritance diagram for SiStripFEDMonitorPlugin:

Public Member Functions
	SiStripFEDMonitorPlugin (const edm::ParameterSet &)

	~SiStripFEDMonitorPlugin () override

Public Member Functions inherited from one::DQMEDAnalyzer< T >
	DQMEDAnalyzer ()=default

	DQMEDAnalyzer (DQMEDAnalyzer< T... > const &)=delete

	DQMEDAnalyzer (DQMEDAnalyzer< T... > &&)=delete

	~DQMEDAnalyzer () override=default

Private Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

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

void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override

void	endLuminosityBlock (const edm::LuminosityBlock &lumiSeg, const edm::EventSetup &context) override

void	getMajority (const std::vector< std::pair< unsigned int, unsigned int > > &aFeMajVec, unsigned int &aMajorityCounter, std::vector< unsigned int > &afedIds)

void	updateCabling (const edm::EventSetup &eventSetup)

Static Private Member Functions
static bool	pairComparison (const std::pair< unsigned int, unsigned int > &pair1, const std::pair< unsigned int, unsigned int > &pair2)

Private Attributes
const SiStripFedCabling *	cabling_

uint32_t	cablingCacheId_

bool	doFEMajorityCheck_

bool	doMedHists_

bool	doTkHistoMap_

FEDErrors	fedErrors_

FEDHistograms	fedHists_

bool	fillAllDetailedHistograms_

bool	fillWithEvtNum_

std::string	folderName_

bool	fullDebugMode_

edm::EDGetTokenT< EventWithHistory >	heToken_

unsigned int	maxFedBufferSize_

unsigned int	nEvt_

unsigned int	printDebug_

edm::InputTag	rawDataTag_

edm::EDGetTokenT< FEDRawDataCollection >	rawDataToken_

std::string	topFolderName_

Detailed Description

Description: DQM source application to produce data integrety histograms for SiStrip data

Definition at line 61 of file SiStripFEDMonitor.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 124 of file SiStripFEDMonitor.cc.

References doFEMajorityCheck_, doMedHists_, doTkHistoMap_, fedHists_, fillAllDetailedHistograms_, fillWithEvtNum_, folderName_, edm::ParameterSet::getUntrackedParameter(), heToken_, LogTrace, nEvt_, printDebug_, rawDataTag_, rawDataToken_, AlCaHLTBitMon_QueryRunRegistry::string, and topFolderName_.

   : rawDataTag_(iConfig.getUntrackedParameter<edm::InputTag>("RawDataTag",edm::InputTag("source",""))),
     topFolderName_(iConfig.getUntrackedParameter<std::string>("TopFolderName","SiStrip")),
     fillAllDetailedHistograms_(iConfig.getUntrackedParameter<bool>("FillAllDetailedHistograms",false)),
     fillWithEvtNum_(iConfig.getUntrackedParameter<bool>("FillWithEventNumber",false)),
     printDebug_(iConfig.getUntrackedParameter<unsigned int>("PrintDebugMessages",1)),
     cablingCacheId_(0),
     maxFedBufferSize_(0),
     fullDebugMode_(iConfig.getUntrackedParameter<bool>("FullDebugMode",false))
 {
   std::string subFolderName = iConfig.getUntrackedParameter<std::string>("HistogramFolderName","ReadoutView");
   folderName_ = topFolderName_ + "/" + subFolderName;
 
 
   rawDataToken_ = consumes<FEDRawDataCollection>(rawDataTag_);
   heToken_      = consumes<EventWithHistory>(edm::InputTag("consecutiveHEs") );
 
   //print config to debug log
   std::ostringstream debugStream;
   if (printDebug_>1) {
     debugStream << "[SiStripFEDMonitorPlugin]Configuration for SiStripFEDMonitorPlugin: " << std::endl
                 << "[SiStripFEDMonitorPlugin]\tRawDataTag: " << rawDataTag_ << std::endl
                 << "[SiStripFEDMonitorPlugin]\tHistogramFolderName: " << folderName_ << std::endl
                 << "[SiStripFEDMonitorPlugin]\tFillAllDetailedHistograms? " << (fillAllDetailedHistograms_ ? "yes" : "no") << std::endl
         << "[SiStripFEDMonitorPlugin]\tFillWithEventNumber?" << (fillWithEvtNum_ ? "yes" : "no") << std::endl
                 << "[SiStripFEDMonitorPlugin]\tPrintDebugMessages? " << (printDebug_ ? "yes" : "no") << std::endl;
   }
 
   //don;t generate debug mesages if debug is disabled
   std::ostringstream* pDebugStream = (printDebug_>1 ? &debugStream : nullptr);
 
   fedHists_.initialise(iConfig,pDebugStream);
 
   doTkHistoMap_ = fedHists_.tkHistoMapEnabled();
 
   doMedHists_ = fedHists_.cmHistosEnabled();
 
   doFEMajorityCheck_ = fedHists_.feMajHistosEnabled();
 
   if (printDebug_) {
     LogTrace("SiStripMonitorHardware") << debugStream.str();
   }
 
   nEvt_ = 0;
 }

SiStripFEDMonitorPlugin::~SiStripFEDMonitorPlugin ( )

override

Definition at line 170 of file SiStripFEDMonitor.cc.

171 {

172 }

Member Function Documentation

void SiStripFEDMonitorPlugin::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 181 of file SiStripFEDMonitor.cc.

References begin, cabling_, EventWithHistory::deltaBX(), doFEMajorityCheck_, doMedHists_, doTkHistoMap_, relativeConstraints::empty, end, edm::EventID::event(), edm::HandleBase::failedToGet(), FEDRawDataCollection::FEDData(), fedErrors_, fedHists_, l1t::stage2::layer2::fedId, fillWithEvtNum_, fullDebugMode_, edm::EventSetup::get(), edm::Event::getByToken(), getMajority(), hcalSimParameters_cfi::he, heToken_, edm::EventBase::id(), edm::HandleBase::isValid(), maxFedBufferSize_, FEDNumbering::MAXSiStripFEDID, FEDNumbering::MINSiStripFEDID, nEvt_, edm::EventBase::orbitNumber(), pairComparison(), printDebug_, edm::ESHandle< T >::product(), rawDataToken_, FEDRawData::size(), findQualityFiles::size, and updateCabling().

 {
   //Retrieve tracker topology from geometry
   edm::ESHandle<TrackerTopology> tTopoHandle;
   iSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
   const TrackerTopology* const tTopo = tTopoHandle.product();
 
   //update cabling
   updateCabling(iSetup);
 
   //get raw data
   edm::Handle<FEDRawDataCollection> rawDataCollectionHandle;
   iEvent.getByToken(rawDataToken_,rawDataCollectionHandle);
   const FEDRawDataCollection& rawDataCollection = *rawDataCollectionHandle;
 
   fedErrors_.initialiseEvent();
 
   //add the deltaBX value if the product exist
 
   edm::Handle<EventWithHistory> he;
   iEvent.getByToken(heToken_,he);
 
   if(he.isValid() && !he.failedToGet()) {
     fedErrors_.fillEventProperties(he->deltaBX());
   }
 
   //initialise map of fedId/bad channel number
   std::map<unsigned int,std::pair<unsigned short,unsigned short> > badChannelFraction;
 
   unsigned int lNFEDMonitoring = 0;
   unsigned int lNFEDUnpacker = 0;
   unsigned int lNChannelMonitoring = 0;
   unsigned int lNChannelUnpacker = 0;
 
   unsigned int lNTotBadFeds = 0;
   unsigned int lNTotBadChannels = 0;
   unsigned int lNTotBadActiveChannels = 0;
 
   std::vector<std::vector<std::pair<unsigned int,unsigned int> > > lFeMajFrac;
   const unsigned int nParts = 4;
   if (doFEMajorityCheck_){
     lFeMajFrac.resize(nParts);
     //max nFE per partition
     lFeMajFrac[0].reserve(912);
     lFeMajFrac[1].reserve(1080);
     lFeMajFrac[2].reserve(768);
     lFeMajFrac[3].reserve(760);
   }
 
   maxFedBufferSize_ = 0;
 
   //loop over siStrip FED IDs
   for (unsigned int fedId = FEDNumbering::MINSiStripFEDID;
        fedId <= FEDNumbering::MAXSiStripFEDID;
        fedId++) {//loop over FED IDs
     unsigned int lNBadChannels_perFEDID = 0;
     const FEDRawData& fedData = rawDataCollection.FEDData(fedId);
 
     //create an object to fill all errors
     fedErrors_.initialiseFED(fedId,cabling_,tTopo);
 
     double aLumiSection = iEvent.orbitNumber()/262144.0;
 
     //Do detailed check
     //first check if data exists
     bool lDataExist = fedErrors_.checkDataPresent(fedData);
     if (!lDataExist) {
       fedHists_.fillFEDHistograms(fedErrors_,0,fullDebugMode_,aLumiSection, lNBadChannels_perFEDID);
       continue;
     }
 
 
 
     //check for problems and fill detailed histograms
     fedErrors_.fillFEDErrors(fedData,
                  fullDebugMode_,
                  printDebug_,
                  lNChannelMonitoring,
                  lNChannelUnpacker,
                  doMedHists_,
                  fedHists_.cmHistPointer(false),
                  fedHists_.cmHistPointer(true),
                  doFEMajorityCheck_,
                  lFeMajFrac
                  );
 
     //check filled in previous method.
     bool lFailUnpackerFEDcheck = fedErrors_.failUnpackerFEDCheck();
 
     fedErrors_.incrementFEDCounters();
     unsigned int lSize = fedData.size();
     if (lSize > maxFedBufferSize_){
       maxFedBufferSize_ = lSize;
     }
     //std::cout << " -- " << fedId << " " << lSize << std::endl;
 
     //fedHists_.fillFEDHistograms(fedErrors_,lSize,fullDebugMode_);
 
     bool lFailMonitoringFEDcheck = fedErrors_.failMonitoringFEDCheck();
     if (lFailMonitoringFEDcheck) lNTotBadFeds++;
 
 
     //sanity check: if something changed in the unpacking code
     //but wasn't propagated here
     //print only the summary, and more info if printDebug>1
     if (lFailMonitoringFEDcheck != lFailUnpackerFEDcheck) {
       if (printDebug_>1) {
     std::ostringstream debugStream;
     debugStream << " --- WARNING: FED " << fedId << std::endl
             << " ------ Monitoring FED check " ;
     if (lFailMonitoringFEDcheck) debugStream << "failed." << std::endl;
     else debugStream << "passed." << std::endl ;
     debugStream << " ------ Unpacker FED check " ;
     if (lFailUnpackerFEDcheck) debugStream << "failed." << std::endl;
     else debugStream << "passed." << std::endl ;
     edm::LogError("SiStripMonitorHardware") << debugStream.str();
       }
 
       if (lFailMonitoringFEDcheck) lNFEDMonitoring++;
       else if (lFailUnpackerFEDcheck) lNFEDUnpacker++;
     }
 
 
     //Fill TkHistoMap:
     //add an entry for all channels (good = 0),
     //so that tkHistoMap knows which channels should be there.
     if (doTkHistoMap_ && !fedHists_.tkHistoMapPointer()) {
       edm::LogWarning("SiStripMonitorHardware") << " -- Fedid " << fedId
                         << ", TkHistoMap enabled but pointer is null." << std::endl;
     }
 
     fedErrors_.fillBadChannelList(doTkHistoMap_,
                   fedHists_.tkHistoMapPointer(),
                   fedHists_.getFedvsAPVpointer(),
                   lNTotBadChannels,
                   lNTotBadActiveChannels,
           lNBadChannels_perFEDID
         );
     fedHists_.fillFEDHistograms(fedErrors_,lSize,fullDebugMode_,aLumiSection, lNBadChannels_perFEDID);
   }//loop over FED IDs
 
 
   if (doFEMajorityCheck_){
     for (unsigned int iP(0); iP<nParts; ++iP){
       //std::cout << " -- Partition " << iP << std::endl;
       //std::cout << " --- Number of elements in vec = " << lFeMajFrac[iP].size() << std::endl;
       if (lFeMajFrac[iP].empty()) continue;
       std::sort(lFeMajFrac[iP].begin(),lFeMajFrac[iP].end(),SiStripFEDMonitorPlugin::pairComparison);
 
       unsigned int lMajorityCounter = 0;
       std::vector<unsigned int> lfedIds;
 
       getMajority(lFeMajFrac[iP],lMajorityCounter,lfedIds);
       //std::cout << " -- Found " << lfedIds.size() << " unique elements not matching the majority." << std::endl;
       fedHists_.fillMajorityHistograms(iP,static_cast<float>(lMajorityCounter)/lFeMajFrac[iP].size(),lfedIds);
     }
   }
 
   if ((lNTotBadFeds> 0 || lNTotBadChannels>0) && printDebug_>1) {
     std::ostringstream debugStream;
     debugStream << "[SiStripFEDMonitorPlugin] --- Total number of bad feds = "
         << lNTotBadFeds << std::endl
         << "[SiStripFEDMonitorPlugin] --- Total number of bad channels = "
         << lNTotBadChannels << std::endl
         << "[SiStripFEDMonitorPlugin] --- Total number of bad active channels = "
         << lNTotBadActiveChannels << std::endl;
     edm::LogInfo("SiStripMonitorHardware") << debugStream.str();
   }
 
   if ((lNFEDMonitoring > 0 || lNFEDUnpacker > 0 || lNChannelMonitoring > 0 || lNChannelUnpacker > 0) && printDebug_) {
     std::ostringstream debugStream;
     debugStream
       << "[SiStripFEDMonitorPlugin]-------------------------------------------------------------------------" << std::endl
       << "[SiStripFEDMonitorPlugin]-------------------------------------------------------------------------" << std::endl
       << "[SiStripFEDMonitorPlugin]-- Summary of differences between unpacker and monitoring at FED level : " << std::endl
       << "[SiStripFEDMonitorPlugin] ---- Number of times monitoring fails but not unpacking = " << lNFEDMonitoring << std::endl
       << "[SiStripFEDMonitorPlugin] ---- Number of times unpacking fails but not monitoring = " << lNFEDUnpacker << std::endl
       << "[SiStripFEDMonitorPlugin]-------------------------------------------------------------------------" << std::endl
       << "[SiStripFEDMonitorPlugin]-- Summary of differences between unpacker and monitoring at Channel level : " << std::endl
       << "[SiStripFEDMonitorPlugin] ---- Number of times monitoring fails but not unpacking = " << lNChannelMonitoring << std::endl
       << "[SiStripFEDMonitorPlugin] ---- Number of times unpacking fails but not monitoring = " << lNChannelUnpacker << std::endl
       << "[SiStripFEDMonitorPlugin]-------------------------------------------------------------------------" << std::endl
       << "[SiStripFEDMonitorPlugin]-------------------------------------------------------------------------" << std::endl ;
     edm::LogError("SiStripMonitorHardware") << debugStream.str();
 
   }
 
   fedErrors_.getFEDErrorsCounters().nTotalBadChannels = lNTotBadChannels;
   fedErrors_.getFEDErrorsCounters().nTotalBadActiveChannels = lNTotBadActiveChannels;
 
   //time in seconds since beginning of the run or event number
   if (fillWithEvtNum_) {
     // explicitely casting the event number unsigned long long to double here
     double eventNumber = static_cast<double>(iEvent.id().event());
     fedHists_.fillCountersHistograms(
         fedErrors_.getFEDErrorsCounters(),
         fedErrors_.getChannelErrorsCounters(),
         maxFedBufferSize_,
         eventNumber);
   } else {
     double aTime = iEvent.orbitNumber()/11223.;
     fedHists_.fillCountersHistograms(
         fedErrors_.getFEDErrorsCounters(),
         fedErrors_.getChannelErrorsCounters(),
         maxFedBufferSize_,
         aTime);
   }
 
   nEvt_++;
 
 }//analyze method

void SiStripFEDMonitorPlugin::beginLuminosityBlock	(	const edm::LuminosityBlock &	lumiSeg,
		const edm::EventSetup &	context
	)

overrideprivate

Definition at line 481 of file SiStripFEDMonitor.cc.

References fedErrors_.

 {
 
   fedErrors_.initialiseLumiBlock();
 
 }

void SiStripFEDMonitorPlugin::bookHistograms	(	DQMStore::IBooker &	,
		edm::Run const &	,
		edm::EventSetup const &
	)

overrideprivate

Definition at line 467 of file SiStripFEDMonitor.cc.

References fedHists_, fillAllDetailedHistograms_, folderName_, fullDebugMode_, edm::EventSetup::get(), edm::ESHandle< T >::product(), and DQMStore::IBooker::setCurrentFolder().

 {
   ibooker.setCurrentFolder(folderName_);
 
   edm::ESHandle<TkDetMap> tkDetMapHandle;
   eSetup.get<TrackerTopologyRcd>().get(tkDetMapHandle);
   const TkDetMap* tkDetMap = tkDetMapHandle.product();
 
   fedHists_.bookTopLevelHistograms(ibooker, tkDetMap);
 
   if (fillAllDetailedHistograms_) fedHists_.bookAllFEDHistograms(ibooker , fullDebugMode_ );
 }

void SiStripFEDMonitorPlugin::endLuminosityBlock	(	const edm::LuminosityBlock &	lumiSeg,
		const edm::EventSetup &	context
	)

overrideprivate

Definition at line 491 of file SiStripFEDMonitor.cc.

References fedErrors_, and fedHists_.

 {
   fedHists_.fillLumiHistograms(fedErrors_.getLumiErrors());
 }

void SiStripFEDMonitorPlugin::getMajority	(	const std::vector< std::pair< unsigned int, unsigned int > > &	aFeMajVec,
		unsigned int &	aMajorityCounter,
		std::vector< unsigned int > &	afedIds
	)

private

Definition at line 400 of file SiStripFEDMonitor.cc.

References gather_cfg::cout, and tier0::unique().

Referenced by analyze().

                                                          {
 
 
   unsigned int lMajAddress = 0;
   std::vector<std::pair<unsigned int,unsigned int> >::const_iterator lIter = aFeMajVec.begin();
   unsigned int lMajAddr = (*lIter).second;
   unsigned int lCounter = 0;
 
   //std::cout << " --- First element: addr = " << lMajAddr << " counter = " << lCounter << std::endl;
   unsigned int iele=0;
   //bool foundMaj = false;
   for ( ; lIter != aFeMajVec.end(); ++lIter,++iele) {
     //std::cout << " ---- Ele " << iele << " " << (*lIter).first << " " << (*lIter).second << " ref " << lMajAddr << std::endl;
     if ((*lIter).second == lMajAddr) {
       ++lCounter;
       //std::cout << " ----- =ref: Counter = " << lCounter << std::endl;
     }
     else {
       //std::cout << " ----- !=ref: Counter = " << lCounter << " Majority = " << aMajorityCounter << std::endl;
       if (lCounter > aMajorityCounter) {
     //std::cout << " ------ >Majority: " << std::endl;
     aMajorityCounter = lCounter;
     // AV bug here??
     lMajAddress = lMajAddr;
     //  lMajAddress = (*lIter).second;
     //foundMaj=true;
       }
       lCounter = 0;
       lMajAddr = (*lIter).second;
       --lIter;
       --iele;
     }
   }
   // AV Bug here? The check has to be done regardless foundMaj == false or true
   //  if (!foundMaj) {
     if (lCounter > aMajorityCounter) {
       //std::cout << " ------ >Majority: " << std::endl;
       aMajorityCounter = lCounter;
       lMajAddress = lMajAddr;
     }
     //  }
   //std::cout << " -- found majority value for " << aMajorityCounter << " elements out of " << aFeMajVec.size() << "." << std::endl;
   //get list of feds with address different from majority in partition:
   lIter = aFeMajVec.begin();
   afedIds.reserve(135);
   for ( ; lIter != aFeMajVec.end(); ++lIter ) {
     if((*lIter).second != lMajAddress) {
       afedIds.push_back((*lIter).first);
     }
     else {
       lIter += aMajorityCounter-1;
       if(lIter >= aFeMajVec.end()) {
     std::cout << "Here it is a bug: " << aMajorityCounter << " " << aFeMajVec.size() << " " << lIter - aFeMajVec.end() << std::endl;
       }
     }
   }
   //std::cout << " -- Found " << lfedIds.size() << " elements not matching the majority." << std::endl;
   if (!afedIds.empty()) {
     std::sort(afedIds.begin(),afedIds.end());
     std::vector<unsigned int>::iterator lIt = std::unique(afedIds.begin(),afedIds.end());
     afedIds.erase(lIt,afedIds.end());
   }
 
 }

bool SiStripFEDMonitorPlugin::pairComparison	(	const std::pair< unsigned int, unsigned int > &	pair1,
		const std::pair< unsigned int, unsigned int > &	pair2
	)

staticprivate

Definition at line 395 of file SiStripFEDMonitor.cc.

Referenced by analyze().

                                                                            {
   return (pair1.second < pair2.second) ;
 }

void SiStripFEDMonitorPlugin::updateCabling ( const edm::EventSetup & eventSetup )

private

Definition at line 500 of file SiStripFEDMonitor.cc.

References cabling_, cablingCacheId_, DEFINE_FWK_MODULE, edm::EventSetup::get(), and edm::ESHandle< T >::product().

Referenced by analyze().

 {
   uint32_t currentCacheId = eventSetup.get<SiStripFedCablingRcd>().cacheIdentifier();
   if (cablingCacheId_ != currentCacheId) {
     edm::ESHandle<SiStripFedCabling> cablingHandle;
     eventSetup.get<SiStripFedCablingRcd>().get(cablingHandle);
     cabling_ = cablingHandle.product();
     cablingCacheId_ = currentCacheId;
   }
 }