DigiRunSummary.cc

Go to the documentation of this file.

#include "DQM/HcalTasks/interface/DigiRunSummary.h"

namespace hcaldqm
{
    using namespace constants;
    
    DigiRunSummary::DigiRunSummary(std::string const& name, 
        std::string const& taskname, edm::ParameterSet const& ps) :
        DQClient(name, taskname, ps), _booked(false)
    {
        _thresh_unihf = ps.getUntrackedParameter<double>("thresh_unihf",
            0.2);

        std::vector<uint32_t> vrefDigiSize = ps.getUntrackedParameter<std::vector<uint32_t>>("refDigiSize");
        _refDigiSize[HcalBarrel]  = vrefDigiSize[0];
        _refDigiSize[HcalEndcap]  = vrefDigiSize[1];
        _refDigiSize[HcalOuter]   = vrefDigiSize[2];
        _refDigiSize[HcalForward] = vrefDigiSize[3];
    }

    /* virtual */ void DigiRunSummary::beginRun(edm::Run const& r,
        edm::EventSetup const& es)
    {
        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
        _vhashFEDHF.push_back(HcalElectronicsId(22, SLOT_uTCA_MIN,
            FIBER_uTCA_MIN1, FIBERCH_MIN, false).rawId());
        _vhashFEDHF.push_back(HcalElectronicsId(29, SLOT_uTCA_MIN,
            FIBER_uTCA_MIN1, FIBERCH_MIN, false).rawId());
        _vhashFEDHF.push_back(HcalElectronicsId(32, SLOT_uTCA_MIN,
            FIBER_uTCA_MIN1, FIBERCH_MIN, false).rawId());
        _vhashFEDHF.push_back(HcalElectronicsId(22, SLOT_uTCA_MIN+6,
            FIBER_uTCA_MIN1, FIBERCH_MIN, false).rawId());
        _vhashFEDHF.push_back(HcalElectronicsId(29, SLOT_uTCA_MIN+6,
            FIBER_uTCA_MIN1, FIBERCH_MIN, false).rawId());
        _vhashFEDHF.push_back(HcalElectronicsId(32, SLOT_uTCA_MIN+6,
            FIBER_uTCA_MIN1, FIBERCH_MIN, false).rawId());
        _filter_FEDHF.initialize(filter::fPreserver, hashfunctions::fFED,
            _vhashFEDHF);    // preserve only HF FEDs
        
        _xDead.initialize(hashfunctions::fFED);
        _xDigiSize.initialize(hashfunctions::fFED);
        _xUni.initialize(hashfunctions::fFED);
        _xUniHF.initialize(hashfunctions::fFEDSlot);

        _xDead.book(_emap); _xDigiSize.book(_emap); _xUniHF.book(_emap);
        _xUni.book(_emap, _filter_FEDHF);
        _xNChs.initialize(hashfunctions::fFED);
        _xNChsNominal.initialize(hashfunctions::fFED);
        _xNChs.book(_emap); _xNChsNominal.book(_emap);
        
        _cOccupancy_depth.initialize(_name, "Occupancy",
            hashfunctions::fdepth,
            new quantity::DetectorQuantity(quantity::fieta),
            new quantity::DetectorQuantity(quantity::fiphi),
            new quantity::ValueQuantity(quantity::fN),0);

        //  GET THE NOMINAL NUMBER OF CHANNELS PER FED
        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(it->rawId());
            HcalElectronicsId eid = HcalElectronicsId(_ehashmap.lookup(did));
            _xNChsNominal.get(eid)++;
        }
    }

    /*
     *  END LUMI. EVALUATE LUMI BASED FLAGS
     */
    /* virtual */ void DigiRunSummary::endLuminosityBlock(DQMStore::IBooker& ib,
        DQMStore::IGetter& ig, edm::LuminosityBlock const& lb,
        edm::EventSetup const& es)
    {
        DQClient::endLuminosityBlock(ib, ig, lb, es);

        if (_ptype!=fOffline)
            return;

        LSSummary lssum;
        lssum._LS=_currentLS;

        _xDigiSize.reset(); _xNChs.reset();
        
        //  INITIALIZE LUMI BASED HISTOGRAMS
        Container2D cDigiSize_Crate, cOccupancy_depth;
        cDigiSize_Crate.initialize(_taskname, "DigiSize",
            hashfunctions::fCrate,
            new quantity::ValueQuantity(quantity::fDigiSize),
            new quantity::ValueQuantity(quantity::fN),0);
        cOccupancy_depth.initialize(_taskname, "Occupancy",
            hashfunctions::fdepth,
            new quantity::DetectorQuantity(quantity::fieta),
            new quantity::DetectorQuantity(quantity::fiphi),
            new quantity::ValueQuantity(quantity::fN),0);

        //  LOAD LUMI BASED HISTOGRAMS
        cOccupancy_depth.load(ig, _emap, _subsystem);
        cDigiSize_Crate.load(ig, _emap, _subsystem);
        MonitorElement *meNumEvents = ig.get(_subsystem+
            "/RunInfo/NumberOfEvents");
        int numEvents = meNumEvents->getBinContent(1);
        bool unknownIdsPresent = ig.get(_subsystem+"/"
            +_taskname+"/UnknownIds")->getBinContent(1)>0;

        //  book the Numer of Events - set axis extendable
        if (!_booked)
        {
            ib.setCurrentFolder(_subsystem+"/"+_taskname);
            _meNumEvents = ib.book1D("NumberOfEvents", "NumberOfEvents",
                1000, 1, 1001); // 1000 to start with
            _meNumEvents->getTH1()->SetCanExtend(TH1::kXaxis);

            _cOccupancy_depth.book(ib, _emap, _subsystem);
            _booked=true;
        }
        _meNumEvents->setBinContent(_currentLS, numEvents);

        //  ANALYZE THIS LS for LS BASED FLAGS
        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));

            cOccupancy_depth.getBinContent(did)>0?_xNChs.get(eid)++:
                _xNChs.get(eid)+=0;
            _cOccupancy_depth.fill(did, cOccupancy_depth.getBinContent(did));
            //  digi size
            cDigiSize_Crate.getMean(eid)!=
                _refDigiSize[did.subdet()]?
                _xDigiSize.get(eid)++:_xDigiSize.get(eid)+=0;
            cDigiSize_Crate.getRMS(eid)!=0?
                _xDigiSize.get(eid)++:_xDigiSize.get(eid)+=0;
        }

        //  GENERATE SUMMARY AND STORE IT
        std::vector<flag::Flag> vtmpflags; 
        vtmpflags.resize(nLSFlags);
        vtmpflags[fDigiSize]=flag::Flag("DigiSize");
        vtmpflags[fNChsHF]=flag::Flag("NChsHF");
        vtmpflags[fUnknownIds]=flag::Flag("UnknownIds");
        vtmpflags[fLED]=flag::Flag("LEDMisfire");
        for (std::vector<uint32_t>::const_iterator it=_vhashCrates.begin();
            it!=_vhashCrates.end(); ++it)
        {
            HcalElectronicsId eid(*it);
            HcalDetId did = HcalDetId(_emap->lookup(eid));

            //  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();

            if (_xDigiSize.get(eid)>0)
                vtmpflags[fDigiSize]._state = flag::fBAD;
            else
                vtmpflags[fDigiSize]._state = flag::fGOOD;

            if (did.subdet() == HcalForward)
            {
                if (_xNChs.get(eid)!=_xNChsNominal.get(eid))
                    vtmpflags[fNChsHF]._state = flag::fBAD;
                else
                    vtmpflags[fNChsHF]._state = flag::fGOOD;
            } else {
                vtmpflags[fNChsHF]._state = flag::fNA;
            }
            if (unknownIdsPresent)
                vtmpflags[fUnknownIds]._state = flag::fBAD;
            else
                vtmpflags[fUnknownIds]._state = flag::fGOOD;

            if ((did.subdet() == HcalBarrel) || (did.subdet() == HcalBarrel) || (did.subdet() == HcalBarrel) || (did.subdet() == HcalBarrel)) {
                std::string ledHistName = _subsystem + "/" + _taskname + "/LED_CUCountvsLS/Subdet/";
                if (did.subdet() == HcalBarrel) {
                    ledHistName += "HB";
                } else if (did.subdet() == HcalEndcap) {
                    ledHistName += "HE";
                } else if (did.subdet() == HcalOuter) {
                    ledHistName += "HO";
                } else if (did.subdet() == HcalForward) {
                    ledHistName += "HF";
                }
                MonitorElement* ledHist = ig.get(ledHistName);
                if (ledHist) {
                    bool ledSignalPresent = (ledHist->getEntries() > 0);
                    if (ledSignalPresent)
                        vtmpflags[fLED]._state = flag::fBAD;
                    else
                        vtmpflags[fLED]._state = flag::fGOOD;
                } else {
                    vtmpflags[fLED]._state = flag::fNA;
                }
            } else {
                vtmpflags[fLED]._state = flag::fNA;
            }


            // push all the flags for this crate
            lssum._vflags.push_back(vtmpflags);
        }

        //  push all the flags for all FEDs for this LS
        _vflagsLS.push_back(lssum);
    }

    /*
     *  End Job
     */
    /* virtual */ std::vector<flag::Flag> DigiRunSummary::endJob(
        DQMStore::IBooker& ib, DQMStore::IGetter& ig)
    {
        if (_ptype!=fOffline)
            return std::vector<flag::Flag>();

        _xDead.reset(); _xUniHF.reset(); _xUni.reset();

        //  PREPARE LS AND RUN BASED FLAGS TO USE IT FOR BOOKING
        std::vector<flag::Flag> vflagsPerLS;
        std::vector<flag::Flag> vflagsPerRun;
        vflagsPerLS.resize(nLSFlags);
        vflagsPerRun.resize(nDigiFlag-nLSFlags+1);
        vflagsPerLS[fDigiSize]=flag::Flag("DigiSize");
        vflagsPerLS[fNChsHF]=flag::Flag("NChsHF");
        vflagsPerLS[fUnknownIds]=flag::Flag("UnknownIds");
        vflagsPerLS[fLED]=flag::Flag("LEDMisfire");
        vflagsPerRun[fDigiSize]=flag::Flag("DigiSize");
        vflagsPerRun[fNChsHF]=flag::Flag("NChsHF");
        vflagsPerRun[fUniHF-nLSFlags+1]=flag::Flag("UniSlotHF");
        vflagsPerRun[fDead-nLSFlags+1]=flag::Flag("Dead");

        //  INITIALIZE SUMMARY CONTAINERS
        ContainerSingle2D cSummaryvsLS;
        Container2D cSummaryvsLS_Crate;
        cSummaryvsLS.initialize(_name, "SummaryvsLS",
            new quantity::LumiSection(_maxProcessedLS),
            new quantity::CrateQuantity(_emap),
            new quantity::ValueQuantity(quantity::fState),0);
        cSummaryvsLS.book(ib, _subsystem);
        cSummaryvsLS_Crate.initialize(_name, "SummaryvsLS",
            hashfunctions::fCrate,
            new quantity::LumiSection(_maxProcessedLS),
            new quantity::FlagQuantity(vflagsPerLS),
            new quantity::ValueQuantity(quantity::fState),0);
        cSummaryvsLS_Crate.book(ib, _emap, _subsystem);

        // INITIALIZE CONTAINERS WE NEED TO LOAD or BOOK
        Container2D cOccupancyCut_depth;
        Container2D cDead_depth, cDead_Crate;
        cOccupancyCut_depth.initialize(_taskname, "OccupancyCut",
            hashfunctions::fdepth,
            new quantity::DetectorQuantity(quantity::fieta),
            new quantity::DetectorQuantity(quantity::fiphi),
            new quantity::ValueQuantity(quantity::fN),0);
        cDead_depth.initialize(_name, "Dead",
            hashfunctions::fdepth,
            new quantity::DetectorQuantity(quantity::fieta),
            new quantity::DetectorQuantity(quantity::fiphi),
            new quantity::ValueQuantity(quantity::fN),0);
        cDead_Crate.initialize(_name, "Dead",
            hashfunctions::fCrate,
            new quantity::ElectronicsQuantity(quantity::fSpigot),
            new quantity::ElectronicsQuantity(quantity::fFiberVMEFiberCh),
            new quantity::ValueQuantity(quantity::fN),0);

        //  LOAD
        cOccupancyCut_depth.load(ig, _emap, _subsystem);
        cDead_depth.book(ib, _emap, _subsystem);
        cDead_Crate.book(ib, _emap, _subsystem);

        //  ANALYZE RUN BASED QUANTITIES
        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));

            if (_cOccupancy_depth.getBinContent(did)<1)
            {
                _xDead.get(eid)++;
                cDead_depth.fill(did);
                cDead_Crate.fill(eid);
            }
            if (did.subdet()==HcalForward)
                _xUniHF.get(eid)+=cOccupancyCut_depth.getBinContent(did);
        }
        //  ANALYZE FOR HF SLOT UNIFORMITY
        for (uintCompactMap::const_iterator it=_xUniHF.begin();
            it!=_xUniHF.end(); ++it)
        {
            uint32_t hash1 = it->first;
            HcalElectronicsId eid1(hash1);
            double x1 = it->second;

            for (uintCompactMap::const_iterator jt=_xUniHF.begin();
                jt!=_xUniHF.end(); ++jt)
            {
                if (jt==it)
                    continue;

                double x2 = jt->second;
                if (x2==0)
                    continue;
                if (x1/x2<_thresh_unihf)
                    _xUni.get(eid1)++;
            }
        }

        /*
         *  Iterate over each crate
         *      Iterate over each LS Summary
         *          Iterate over all flags
         *              set...
         */
        //  iterate over all crates
        std::vector<flag::Flag> sumflags;
        int icrate=0;
        for (auto& it_crate : _vhashCrates) {
            flag::Flag fSumRun("DIGI"); // summary flag for this FED
            flag::Flag ffDead("Dead");
            flag::Flag ffUniSlotHF("UniSlotHF");
            HcalElectronicsId eid(it_crate);
            HcalDetId did = HcalDetId(_emap->lookup(eid));

            //  ITERATE OVER EACH LS
            for (std::vector<LSSummary>::const_iterator itls=_vflagsLS.begin();
                itls!=_vflagsLS.end(); ++itls)
            {
                int iflag=0;
                flag::Flag fSumLS("DIGI");
                for (std::vector<flag::Flag>::const_iterator ft=
                    itls->_vflags[icrate].begin(); ft!=itls->_vflags[icrate].end();
                    ++ft)
                {
                    cSummaryvsLS_Crate.setBinContent(eid, itls->_LS, int(iflag), ft->_state);
                    fSumLS+=(*ft);
                    iflag++;
                }
                cSummaryvsLS.setBinContent(eid, itls->_LS, fSumLS._state);
                fSumRun+=fSumLS;
            }

            //  EVALUATE RUN BASED FLAGS
            if (_xDead.get(eid)>0)
                ffDead._state = flag::fBAD;
            else
                ffDead._state = flag::fGOOD;
            if (did.subdet() == HcalForward)
            {
                if (_xUni.get(eid)>0)
                    ffUniSlotHF._state = flag::fBAD;
                else
                    ffUniSlotHF._state = flag::fGOOD;
            }
            fSumRun+=ffDead+ffUniSlotHF;

            // push the summary flag for this FED for the Whole Run
            sumflags.push_back(fSumRun);

            //   increment fed
            icrate++;
        }

        return sumflags;
    }
}