#include <RawRunSummary.h>

Inheritance diagram for hcaldqm::RawRunSummary:

Public Member Functions
virtual void	beginRun (edm::Run const &, edm::EventSetup const &)

virtual std::vector< flag::Flag >	endJob (DQMStore::IBooker &, DQMStore::IGetter &)

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

	RawRunSummary (std::string const &, std::string const &, edm::ParameterSet const &)

virtual	~RawRunSummary ()

Public Member Functions inherited from hcaldqm::DQClient
	DQClient (std::string const &, std::string const &, edm::ParameterSet const &)

virtual	~DQClient ()

Public Member Functions inherited from hcaldqm::DQModule
	DQModule (edm::ParameterSet const &)

virtual	~DQModule ()

Protected Types
enum	RawLSFlag { fEvnMsm =0, fBcnMsm =1, fBadQ =2, nRawFlag =3 }

Protected Attributes
bool	_booked

Container2D	_cBadQuality_depth

Container2D	_cBcnMsm_ElectronicsuTCA

Container2D	_cBcnMsm_ElectronicsVME

Container2D	_cEvnMsm_ElectronicsuTCA

Container2D	_cEvnMsm_ElectronicsVME

electronicsmap::ElectronicsMap	_ehashmap

filter::HashFilter	_filter_uTCA

filter::HashFilter	_filter_VME

std::vector< int >	_vFEDsuTCA

std::vector< int >	_vFEDsVME

std::vector< LSSummary >	_vflagsLS

std::vector< uint32_t >	_vhashuTCA

std::vector< uint32_t >	_vhashVME

ContainerXXX< uint32_t >	_xBadQ

ContainerXXX< uint32_t >	_xBcn

ContainerXXX< uint32_t >	_xEvn

Protected Attributes inherited from hcaldqm::DQClient
HcalElectronicsMap const *	_emap

int	_maxProcessedLS

std::string	_taskname

int	_totalLS

std::vector< uint32_t >	_vcdaqEids

std::vector< int >	_vFEDs

std::vector< uint32_t >	_vhashFEDs

ContainerXXX< uint32_t >	_xQuality

Protected Attributes inherited from hcaldqm::DQModule
int	_currentLS

int	_debug

int	_evsPerLS

int	_evsTotal

Logger	_logger

int	_maxLS

ModuleType	_mtype

std::string	_name

ProcessingType	_ptype

std::string	_runkeyName

int	_runkeyVal

std::string	_subsystem

Detailed Description

Definition at line 9 of file RawRunSummary.h.

Member Enumeration Documentation

enum hcaldqm::RawRunSummary::RawLSFlag

protected

Enumerator
fEvnMsm
fBcnMsm
fBadQ
nRawFlag

Definition at line 44 of file RawRunSummary.h.

             {
                 fEvnMsm=0,
                 fBcnMsm=1,
                 fBadQ=2,
                 nRawFlag=3
             };

Constructor & Destructor Documentation

hcaldqm::RawRunSummary::RawRunSummary	(	std::string const &	name,
		std::string const &	taskname,
		edm::ParameterSet const &	ps
	)

Definition at line 5 of file RawRunSummary.cc.

                                                               :
         DQClient(name, taskname, ps), _booked(false)
     {}

virtual hcaldqm::RawRunSummary::~RawRunSummary ( )

inlinevirtual

Definition at line 14 of file RawRunSummary.h.

14 {}

Member Function Documentation

void hcaldqm::RawRunSummary::beginRun	(	edm::Run const &	r,
		edm::EventSetup const &	es
	)

virtual

Reimplemented from hcaldqm::DQClient.

Definition at line 10 of file RawRunSummary.cc.

References _cBadQuality_depth, _cBcnMsm_ElectronicsuTCA, _cBcnMsm_ElectronicsVME, _cEvnMsm_ElectronicsuTCA, _cEvnMsm_ElectronicsVME, _ehashmap, hcaldqm::DQClient::_emap, _filter_uTCA, _filter_VME, hcaldqm::DQModule::_name, hcaldqm::DQModule::_ptype, _vFEDsuTCA, _vFEDsVME, _vhashuTCA, _vhashVME, _xBadQ, _xBcn, _xEvn, hcaldqm::DQClient::beginRun(), hcaldqm::ContainerXXX< STDTYPE >::book(), hcaldqm::constants::CRATE_uTCA_MIN, hcaldqm::constants::CRATE_VME_MIN, hcaldqm::electronicsmap::fD2EHashMap, hcaldqm::hashfunctions::fdepth, hcaldqm::hashfunctions::fElectronics, hcaldqm::hashfunctions::fFED, hcaldqm::filter::fFilter, hcaldqm::constants::FIBER_uTCA_MIN1, hcaldqm::constants::FIBER_VME_MIN, hcaldqm::constants::FIBERCH_MIN, hcaldqm::quantity::fieta, hcaldqm::quantity::fiphi, hcaldqm::quantity::fN, hcaldqm::fOffline, hcaldqm::quantity::fSlotuTCA, hcaldqm::quantity::fSpigot, hcaldqm::Container2D::initialize(), hcaldqm::ContainerXXX< STDTYPE >::initialize(), hcaldqm::filter::HashFilter::initialize(), hcaldqm::electronicsmap::ElectronicsMap::initialize(), hcaldqm::constants::SLOT_uTCA_MIN, and hcaldqm::constants::SPIGOT_MIN.

     {
         DQClient::beginRun(r,es);
         
         if (_ptype!=fOffline)
             return;
 
         //  INITIALIZE WHAT NEEDS TO BE INITIALIZE ONLY ONCE!
         _ehashmap.initialize(_emap, electronicsmap::fD2EHashMap);
         _vhashVME.push_back(HcalElectronicsId(constants::FIBERCH_MIN,
             constants::FIBER_VME_MIN, SPIGOT_MIN, CRATE_VME_MIN).rawId());
         _vhashuTCA.push_back(HcalElectronicsId(CRATE_uTCA_MIN, SLOT_uTCA_MIN,
             FIBER_uTCA_MIN1, FIBERCH_MIN, false).rawId());
         _filter_VME.initialize(filter::fFilter, hashfunctions::fElectronics,
             _vhashVME); // filter out VME 
         _filter_uTCA.initialize(filter::fFilter, hashfunctions::fElectronics,
             _vhashuTCA); // filter out uTCA
 
         //  INTIALIZE CONTAINERS ACTING AS HOLDERS OF RUN INFORAMTION
         _cEvnMsm_ElectronicsVME.initialize(_name, "EvnMsm",
             hashfunctions::fElectronics,
             new quantity::FEDQuantity(_vFEDsVME),
             new quantity::ElectronicsQuantity(quantity::fSpigot),
             new quantity::ValueQuantity(quantity::fN));
         _cBcnMsm_ElectronicsVME.initialize(_name, "BcnMsm",
             hashfunctions::fElectronics,
             new quantity::FEDQuantity(_vFEDsVME),
             new quantity::ElectronicsQuantity(quantity::fSpigot),
             new quantity::ValueQuantity(quantity::fN));
         _cEvnMsm_ElectronicsuTCA.initialize(_name, "EvnMsm",
             hashfunctions::fElectronics,
             new quantity::FEDQuantity(_vFEDsuTCA),
             new quantity::ElectronicsQuantity(quantity::fSlotuTCA),
             new quantity::ValueQuantity(quantity::fN));
         _cBcnMsm_ElectronicsuTCA.initialize(_name, "BcnMsm",
             hashfunctions::fElectronics,
             new quantity::FEDQuantity(_vFEDsuTCA),
             new quantity::ElectronicsQuantity(quantity::fSlotuTCA),
             new quantity::ValueQuantity(quantity::fN));
         _cBadQuality_depth.initialize(_name, "BadQuality",
              hashfunctions::fdepth,
              new quantity::DetectorQuantity(quantity::fieta),
              new quantity::DetectorQuantity(quantity::fiphi),
              new quantity::ValueQuantity(quantity::fN));
 
         _xEvn.initialize(hashfunctions::fFED);
         _xBcn.initialize(hashfunctions::fFED);
         _xBadQ.initialize(hashfunctions::fFED);
         //  BOOK CONTAINERSXXX
         _xEvn.book(_emap); _xBcn.book(_emap); _xBadQ.book(_emap);
     }

std::vector< flag::Flag > hcaldqm::RawRunSummary::endJob	(	DQMStore::IBooker &	ib,
		DQMStore::IGetter &	ig
	)

virtual

Reimplemented from hcaldqm::DQClient.

Definition at line 235 of file RawRunSummary.cc.

References hcaldqm::DQClient::_emap, hcaldqm::DQClient::_maxProcessedLS, hcaldqm::DQModule::_name, hcaldqm::DQModule::_ptype, hcaldqm::flag::Flag::_state, hcaldqm::DQModule::_subsystem, hcaldqm::DQClient::_vFEDs, _vflagsLS, hcaldqm::DQClient::_vhashFEDs, hcaldqm::ContainerSingle2D::book(), hcaldqm::Container2D::book(), fBadQ, fBcnMsm, fEvnMsm, hcaldqm::hashfunctions::fFED, hcaldqm::fOffline, hcaldqm::quantity::fState, hcaldqm::Container2D::initialize(), hcaldqm::ContainerSingle2D::initialize(), nRawFlag, hcaldqm::Container2D::setBinContent(), and hcaldqm::ContainerSingle2D::setBinContent().

     {
 
         if (_ptype!=fOffline)
             return std::vector<flag::Flag>();
 
 
         //  PREPARE LS BASED FLAGS to use it for booking
         std::vector<flag::Flag> vflagsLS;
         vflagsLS.resize(nRawFlag);
         vflagsLS[fEvnMsm]=flag::Flag("EvnMsm");
         vflagsLS[fBcnMsm]=flag::Flag("BcnMsm");
         vflagsLS[fBadQ]=flag::Flag("BadQ");
 
 
         //  INITIALIZE AND BOOK SUMMARY CONTAINERS
         ContainerSingle2D cSummaryvsLS; // summary per FED: flag vs LS
         Container2D cSummaryvsLS_FED; // LS based flags vs LS for each FED
         cSummaryvsLS.initialize(_name, "SummaryvsLS",
             new quantity::LumiSection(_maxProcessedLS),
             new quantity::FEDQuantity(_vFEDs),
             new quantity::ValueQuantity(quantity::fState));
         cSummaryvsLS_FED.initialize(_name, "SummaryvsLS",
             hashfunctions::fFED,
             new quantity::LumiSection(_maxProcessedLS),
             new quantity::FlagQuantity(vflagsLS),
             new quantity::ValueQuantity(quantity::fState));
         cSummaryvsLS_FED.book(ib, _emap, _subsystem);
         cSummaryvsLS.book(ib, _subsystem);
 
         /*
          *  Iterate over each FED
          *      Iterate over each LS SUmmary
          *          Iterate over all flags
          *              set...
          */
 
         std::vector<flag::Flag> sumflags; // flag per FED
         int ifed=0;
         for (std::vector<uint32_t>::const_iterator it=_vhashFEDs.begin();
             it!=_vhashFEDs.end(); ++it)
         {
             flag::Flag fSumRun("RAW"); // summary flag for this FED
             HcalElectronicsId eid(*it);
 
             //  ITERATE OVER EACH LS
             for (std::vector<LSSummary>::const_iterator itls=_vflagsLS.begin();
                 itls!=_vflagsLS.end(); ++itls)
             {
                 //  fill histograms per LS
                 int iflag=0;
                 flag::Flag fSumLS("RAW");
                 for (std::vector<flag::Flag>::const_iterator ft=
                     itls->_vflags[ifed].begin(); ft!=itls->_vflags[ifed].end();
                     ++ft)
                 {
                     //  Flag vs LS per FEd
                     cSummaryvsLS_FED.setBinContent(eid, itls->_LS, int(iflag),
                         ft->_state);
                     fSumLS+=(*ft);
                     iflag++;
                 }
                 //  FED vs LS
                 cSummaryvsLS.setBinContent(eid, itls->_LS, fSumLS._state);
                 fSumRun+=fSumLS;
             }
             
             //  push the summary flag for this FED for the whole RUN
             sumflags.push_back(fSumRun);
             
             //  increment the fed counter
             ifed++;
         }
     
         return sumflags;
     }

void hcaldqm::RawRunSummary::endLuminosityBlock	(	DQMStore::IBooker &	ib,
		DQMStore::IGetter &	ig,
		edm::LuminosityBlock const &	lb,
		edm::EventSetup const &	es
	)

virtual

Reimplemented from hcaldqm::DQClient.

Definition at line 71 of file RawRunSummary.cc.

References _booked, _cBadQuality_depth, _cBcnMsm_ElectronicsuTCA, _cBcnMsm_ElectronicsVME, _cEvnMsm_ElectronicsuTCA, _cEvnMsm_ElectronicsVME, hcaldqm::DQModule::_currentLS, _ehashmap, hcaldqm::DQClient::_emap, _filter_uTCA, _filter_VME, hcaldqm::DQClient::LSSummary::_LS, hcaldqm::DQModule::_ptype, hcaldqm::DQModule::_subsystem, hcaldqm::DQClient::_taskname, hcaldqm::DQClient::_vcdaqEids, _vFEDsuTCA, _vFEDsVME, hcaldqm::DQClient::LSSummary::_vflags, _vflagsLS, hcaldqm::DQClient::_vhashFEDs, _xBadQ, _xBcn, _xEvn, HcalElectronicsMap::allPrecisionId(), hcaldqm::Container2D::book(), hcaldqm::DQClient::endLuminosityBlock(), hcaldqm::flag::fBAD, fBadQ, fBcnMsm, hcaldqm::hashfunctions::fdepth, hcaldqm::hashfunctions::fElectronics, fEvnMsm, hcaldqm::flag::fGOOD, hcaldqm::quantity::fieta, hcaldqm::Container2D::fill(), spr::find(), hcaldqm::quantity::fiphi, hcaldqm::quantity::fN, hcaldqm::flag::fNCDAQ, hcaldqm::fOffline, hcaldqm::quantity::fSlotuTCA, hcaldqm::quantity::fSpigot, hcaldqm::ContainerXXX< STDTYPE >::get(), hcaldqm::Container2D::getBinContent(), hcaldqm::Container2D::initialize(), hcaldqm::utilities::isFEDHBHE(), hcaldqm::utilities::isFEDHF(), hcaldqm::utilities::isFEDHO(), hcaldqm::Container1D::load(), hcaldqm::electronicsmap::ElectronicsMap::lookup(), nRawFlag, and hcaldqm::ContainerXXX< STDTYPE >::reset().

     {
         DQClient::endLuminosityBlock(ib, ig, lb, es);
         
         if (_ptype!=fOffline)
             return;
 
         //  INITIALIZE WHAT YOU NEED
         LSSummary lssum; // summary for this LS
         lssum._LS = _currentLS; // set the LS
 
         //  RESET CONTAINERS USED FOR ANALYSIS OF THIS LS
         _xEvn.reset(); _xBcn.reset(); _xBadQ.reset();
         
         //  INITIALIZE LUMI BASED HISTOGRAMS
         Container2D cEvnMsm_ElectronicsVME,cEvnMsm_ElectronicsuTCA;
         Container2D cBcnMsm_ElectronicsVME,cBcnMsm_ElectronicsuTCA;
         Container2D cBadQuality_depth;
         cEvnMsm_ElectronicsVME.initialize(_taskname, "EvnMsm",
             hashfunctions::fElectronics,
             new quantity::FEDQuantity(_vFEDsVME),
             new quantity::ElectronicsQuantity(quantity::fSpigot),
             new quantity::ValueQuantity(quantity::fN));
         cBcnMsm_ElectronicsVME.initialize(_taskname, "BcnMsm",
             hashfunctions::fElectronics,
             new quantity::FEDQuantity(_vFEDsVME),
             new quantity::ElectronicsQuantity(quantity::fSpigot),
             new quantity::ValueQuantity(quantity::fN));
         cEvnMsm_ElectronicsuTCA.initialize(_taskname, "EvnMsm",
             hashfunctions::fElectronics,
             new quantity::FEDQuantity(_vFEDsuTCA),
             new quantity::ElectronicsQuantity(quantity::fSlotuTCA),
             new quantity::ValueQuantity(quantity::fN));
         cBcnMsm_ElectronicsuTCA.initialize(_taskname, "BcnMsm",
             hashfunctions::fElectronics,
             new quantity::FEDQuantity(_vFEDsuTCA),
             new quantity::ElectronicsQuantity(quantity::fSlotuTCA),
             new quantity::ValueQuantity(quantity::fN));
         cBadQuality_depth.initialize(_taskname, "BadQuality",
              hashfunctions::fdepth,
              new quantity::DetectorQuantity(quantity::fieta),
              new quantity::DetectorQuantity(quantity::fiphi),
              new quantity::ValueQuantity(quantity::fN));
 
         //  LOAD LUMI BASED HISTOGRAMS
         cEvnMsm_ElectronicsVME.load(ig, _emap, _filter_uTCA, _subsystem);
         cBcnMsm_ElectronicsVME.load(ig, _emap, _filter_uTCA, _subsystem);
         cEvnMsm_ElectronicsuTCA.load(ig, _emap, _filter_VME, _subsystem);
         cBcnMsm_ElectronicsuTCA.load(ig, _emap, _filter_VME, _subsystem);
         cBadQuality_depth.load(ig, _emap, _subsystem);
 
         //  BOOK for the very first time
         if (!_booked)
         {
             _cEvnMsm_ElectronicsVME.book(ib, _emap, _filter_uTCA, _subsystem);
             _cBcnMsm_ElectronicsVME.book(ib, _emap, _filter_uTCA, _subsystem);
             _cEvnMsm_ElectronicsuTCA.book(ib, _emap, _filter_VME, _subsystem);
             _cBcnMsm_ElectronicsuTCA.book(ib, _emap, _filter_VME, _subsystem);
             _cBadQuality_depth.book(ib, _emap, _subsystem);
             _booked=true;
         }
 
         // ANALYZE THIS LS
         // iterate over all channels    
         std::vector<HcalGenericDetId> gids = _emap->allPrecisionId();
         for (std::vector<HcalGenericDetId>::const_iterator it=gids.begin();
             it!=gids.end(); ++it)
         {
             if (!it->isHcalDetId())
                 continue;
             HcalDetId did = HcalDetId(it->rawId());
             HcalElectronicsId eid = HcalElectronicsId(_ehashmap.lookup(did));
 
             _xBadQ.get(eid)+=cBadQuality_depth.getBinContent(did);
             _cBadQuality_depth.fill(did, cBadQuality_depth.getBinContent(did));
             if (eid.isVMEid())
             {
                 _xEvn.get(eid)+=cEvnMsm_ElectronicsVME.getBinContent(eid);
                 _xBcn.get(eid)+=cBcnMsm_ElectronicsVME.getBinContent(eid);
 
                 _cEvnMsm_ElectronicsVME.fill(eid, 
                     cEvnMsm_ElectronicsVME.getBinContent(eid));
                 _cBcnMsm_ElectronicsVME.fill(eid, 
                     cBcnMsm_ElectronicsVME.getBinContent(eid));
             }
             else
             {
                 _xEvn.get(eid)+=cEvnMsm_ElectronicsuTCA.getBinContent(eid);
                 _xBcn.get(eid)+=cBcnMsm_ElectronicsuTCA.getBinContent(eid);
 
                 _cEvnMsm_ElectronicsuTCA.fill(eid, 
                     cEvnMsm_ElectronicsuTCA.getBinContent(eid));
                 _cBcnMsm_ElectronicsuTCA.fill(eid, 
                     cBcnMsm_ElectronicsuTCA.getBinContent(eid));
             }
         }
         
 
         //  GENERATE THE SUMMARY FOR THIS LS AND STORE IT
         std::vector<flag::Flag> vtmpflags; // tmp summary flags vector
         vtmpflags.resize(nRawFlag);
         vtmpflags[fEvnMsm]=flag::Flag("EvnMsm");
         vtmpflags[fBcnMsm]=flag::Flag("BcnMsm");
         vtmpflags[fBadQ]=flag::Flag("BadQ");
         for (std::vector<uint32_t>::const_iterator it=_vhashFEDs.begin();
             it!=_vhashFEDs.end(); ++it)
         {
             HcalElectronicsId eid(*it);
             
             //  reset all the tmp flags to fNA
             //  MUST DO IT NOW! AS NCDAQ MIGHT OVERWRITE IT!
             for (std::vector<flag::Flag>::iterator ft=vtmpflags.begin();
                 ft!=vtmpflags.end(); ++ft)
                 ft->reset();
             
             //  check if this FED was @cDAQ
             std::vector<uint32_t>::const_iterator cit=std::find(
                 _vcdaqEids.begin(), _vcdaqEids.end(), *it);
             if (cit==_vcdaqEids.end())
             {
                 //  was not @cDAQ, set all the flags for this FED as fNCDAQ
                 for (std::vector<flag::Flag>::iterator ft=vtmpflags.begin();
                     ft!=vtmpflags.end(); ++ft)
                     ft->_state = flag::fNCDAQ;
 
                 // push all the flags for this FED
                 // IMPORTANT!!!
                 lssum._vflags.push_back(vtmpflags);
                 continue;
             }
 
             //  here only if was registered at cDAQ
             if (utilities::isFEDHBHE(eid) || utilities::isFEDHF(eid) ||
                 utilities::isFEDHO(eid))
             {
                 if (_xEvn.get(eid)>0)
                     vtmpflags[fEvnMsm]._state = flag::fBAD;
                 else
                     vtmpflags[fEvnMsm]._state = flag::fGOOD;
                 if (_xBcn.get(eid)>0)
                     vtmpflags[fBcnMsm]._state = flag::fBAD;
                 else
                     vtmpflags[fBcnMsm]._state = flag::fGOOD;
                 if (_xBadQ.get(eid)>0)
                     vtmpflags[fBadQ]._state = flag::fBAD;
                 else
                     vtmpflags[fBadQ]._state = flag::fGOOD;
             }
 
             // push all the flags for this FED
             lssum._vflags.push_back(vtmpflags);
         }
 
         //  push all flags for all FEDs for this LS
         _vflagsLS.push_back(lssum);
     }