DybChannelQualitySvc.cc

Go to the documentation of this file.

#include "DybChannelQualitySvc.h"
#include "HardCodedNoisyChannels.h"
#include "ChannelPacked.h"

#include "DatabaseInterface/DbiResultPtr.h"
#include "Conventions/Detectors.h"
#include "Conventions/Electronics.h"

#include "genDbi/GAdWpHvMap.h"
#include "genDbi/GAdWpHvSetting.h"
#include "genDbi/GAdWpHvToFee.h"
#include "genDbi/GDcsAdWpHv.h"


/* From Gassing Li, re channel quality status table:

  The final strategy we adopted for the GDqChannelPacked table, for
  which the new channel quality service would query, is to pack the
  192 status bits ordered by their corresponding FeeChannelId into 7
  integers and saved in one payload record. Only the lower 31 bits for
  each integer are used for packing status. The packing details are in
  the pack method at
 
  http://dayawane.ihep.ac.cn/tracs/dybsvn/browser/dybgaudi/trunk/Database/Scraper/python/Scraper/dq/CQPacker.py

  see also

  http://dayabay.ihep.ac.cn/DocDB/0090/009090/001/CQ_Service_Status_20130710.pdf

  Update: this is augmented with the ability to set bad channels via a
  configurable list.  Items in this list will override the
  GdqChannelPacked table.

*/
#include "genDbi/GDqChannelPacked.h"
// needed to determine ordering of DqChannelPacked bits
#include "genDbi/GCableMap.h"

#include <string>
#include <cmath>

#include <iostream>
#include <sstream>
using namespace std;

DybChanQualCache::DybChanQualCache(const ServiceMode& sm, bool usehv, bool usenoisy)
    : m_timelessSM(Context(sm.context().GetSite(), 
                           sm.context().GetSimFlag(),
                               TimeStamp(0,0),
                               sm.context().GetDetId()),
                       sm.task())
    , m_hvlocKey(0)
    , m_hvfeeKey(0)
    , m_hvgetKey(0)
    , m_hvsetKey(0)
    , m_dqcpKey(0)
    , m_cmapKey(0)
    , m_useHV(usehv)
    , m_useNoisy(usenoisy)
{
    this->update(sm.context().GetTimeStamp());
}

template<class GTable> 
bool update_table(const std::string& name,
                  const Context& ctx, int task,
                  DbiResultKey *&kept_key,
                  DbiResultPtr<GTable> *&resptr)
{
    resptr =  new DbiResultPtr<GTable>(name.c_str(), ctx, ctx.GetDetId(), task);
    const DbiResultKey* key= resptr->GetKey(); 

    if (key && kept_key) {
        if (key->IsEqualTo(kept_key)) {
            return false;
        }
        delete kept_key;
        kept_key = new DbiResultKey(key);
        return true;
    }

    if (!key && !kept_key) {
        return false;
    }


    if (key) {
        kept_key = new DbiResultKey(key);
        return true;
    }

    delete kept_key;
    kept_key = 0;
    return true;
}
                                    

bool DybChanQualCache::empty()
{
    bool full = m_dqcp.size()>0 && m_chlist.size()>0;
    if (m_useHV) {
        full = full && m_hvset.size()>0 && m_hvget.size()>0;
    }
    return !full;
}

void DybChanQualCache::check_hvchid(DayaBay::HvChannelId hvch, const std::string& who)
{
    if (!hvch.bogus()) { return; }

    stringstream ss;
    ss << " bogus HvChannelId: " << hvch.asString();
    throw GaudiException(ss.str().c_str(), who, StatusCode::FAILURE);
}

bool DybChanQualCache::update_hvloc(Context& ctx)
{
    DbiResultPtr<GAdWpHvMap>* res = 0;
    bool updated = update_table<GAdWpHvMap>("AdWpHvMap",
                                            ctx, m_timelessSM.task(), m_hvlocKey, res);
    if (updated) { 
        m_loc2hv.clear();
        unsigned int ind, nrows = res->GetNumRows();
        //cerr << "Updating from AdWpHvMap with " << nrows << " rows @ " << ctx.AsString("E") << endl;
        if (!nrows) {
            throw GaudiException("DybChannelQualitySvc no AdWpHvMap entries",
                                 "DybChanQualCache",StatusCode::FAILURE);
        }

        for (ind=0; ind < nrows; ++ind) {
            const GAdWpHvMap* row = res->GetRowByIndex(ind);
            DayaBay::HvChannelId hvch = row->GetHvChannelId();
            check_hvchid(hvch,"AdWpHvMap");
            std::string loc = row->GetLocationId();
            m_loc2hv[loc] = hvch;
        }
    }

    delete res;
    return updated;
}

bool DybChanQualCache::update_hvfee(Context& ctx)
{
    DbiResultPtr<GAdWpHvToFee>* res = 0;
    bool updated = update_table<GAdWpHvToFee>("AdWpHvToFee",
                                              ctx, m_timelessSM.task(), m_hvfeeKey, res);
    if (updated) {
        m_hv2fee.clear();
        unsigned int ind, nrows = res->GetNumRows();
        //cerr << "Updating from AdWpHvToFee with " << nrows << " rows @ " << ctx.AsString("E") << endl;
        if (!nrows) {
            throw GaudiException("DybChannelQualitySvc no AdWpHvToFee entries",
                                 "DybChanQualCache",StatusCode::FAILURE);
        }

        for (ind=0; ind < nrows; ++ind) {
            const GAdWpHvToFee* row = res->GetRowByIndex(ind);
            DayaBay::HvChannelId hvch = row->GetHvChannelId();
            check_hvchid(hvch,"AdWpHvToFee");
            DayaBay::FeeChannelId chid = row->GetFeeChannelId();
            m_hv2fee[hvch] = chid;
        }
    }
    delete res;
    return updated;
}

DayaBay::FeeChannelId DybChanQualCache::hv2fee(DayaBay::HvChannelId hvch)
{
    DayaBay::FeeChannelId feech = m_hv2fee[hvch];
    if (feech.bogus()) {
        stringstream ss;
        // ss << "Got bogus FeeChannelId out of " << m_hv2fee.size() 
        //    << " from HvChannelId=" << hvch
        //    << ", crate=" << hvch.crate()
        //    << ", board=" << hvch.slot()
        //    << ", channel=" << hvch.channel();
        throw GaudiException(ss.str().c_str(),
                             "DybChanQualCache",StatusCode::FAILURE);
    }
    return feech;
}


bool DybChanQualCache::update_hvset(Context& ctx, bool force)
{
    DbiResultPtr<GAdWpHvSetting>* res = 0;
    bool updated = update_table<GAdWpHvSetting>("AdWpHvSetting", 
                                                ctx, m_timelessSM.task(), m_hvsetKey, res);
    if (!updated) { updated = force; }
    if (updated) {
        m_hvset.clear();
        unsigned int ind, nrows = res->GetNumRows();
        //cerr << "Updating from AdWpHvToSetting with " << nrows << " rows @ " << ctx.AsString("E") << endl;
        if (!nrows) {
            throw GaudiException("DybChannelQualitySvc no AdWpHvSetting entries",
                                 "DybChanQualCache",StatusCode::FAILURE);
        }

        for (ind=0; ind < nrows; ++ind) {
            const GAdWpHvSetting* row = res->GetRowByIndex(ind);
            DayaBay::HvChannelId hvch = row->GetHvChannelId();
            check_hvchid(hvch,"AdWpHvSetting");
            DayaBay::FeeChannelId feech = hv2fee(hvch);
            m_hvset[feech] = row->GetHvSetting();
        }
    }
    delete res;
    return updated;
}

bool DybChanQualCache::update_hvget(Context& ctx, bool force)
{
    DbiResultPtr<GDcsAdWpHv>* res = 0;
    bool updated = update_table<GDcsAdWpHv>("DcsAdWpHv", 
                                            ctx, m_timelessSM.task(), m_hvgetKey, res);
    if (!updated) { updated = force; }
    if (updated) {
        m_hvget.clear();
        unsigned int ind, nrows = res->GetNumRows();
        //cerr << "Updating from DcsAdWpHv with " << nrows << " rows @ " << ctx.AsString("E") << endl;
        if (!nrows) {
            throw GaudiException("DybChannelQualitySvc no DcsAdWpHv entries",
                                 "DybChanQualCache",StatusCode::FAILURE);
        }

        for (ind=0; ind < nrows; ++ind) {
            const GDcsAdWpHv* row = res->GetRowByIndex(ind);
            std::string loc = row->GetLocationId();
            DayaBay::HvChannelId hvch = m_loc2hv[loc];
            check_hvchid(hvch,loc);
            DayaBay::FeeChannelId feech = hv2fee(hvch);
            m_hvget[feech] = row->GetVoltage();
        }
    }
    delete res;
    return updated;
}

bool DybChanQualCache::update_cmap(Context& ctx)
{
    DbiResultPtr<GCableMap>* res = 0;
    bool updated = update_table<GCableMap>("CableMap",
                                           ctx, m_timelessSM.task(), m_cmapKey, res);
    if (updated) {
        m_chlist.clear();
        unsigned int ind=0, nrows = res->GetNumRows();
        if (!nrows) {
            throw GaudiException("DybChannelQualitySvc no CableMap entries",
                                 "DybChanQualCache",StatusCode::FAILURE);
        }
        
        for (ind=0; ind<nrows; ++ind) {
            const GCableMap* row = res->GetRowByIndex(ind);
            DayaBay::AdPmtSensor pmt(row->GetSensorId().fullPackedData());
            if (! pmt.is8inch()) {
                continue;
            }
            m_chlist.push_back(row->GetChannelId().fullPackedData());
        }
        m_chlist.sort();
    }
    delete res;
    return updated;
}
bool DybChanQualCache::update_dqcp(Context& ctx)
{
    DbiResultPtr<GDqChannelPacked>* res = 0;
    bool updated = update_table<GDqChannelPacked>("DqChannelPacked",
                                                  ctx, m_timelessSM.task(), m_dqcpKey, res);
    if (updated) {
        unsigned int nrows = res->GetNumRows();
        if (!nrows) {
            throw GaudiException("DybChannelQualitySvc no DqChannelPacked entries",
                                 "DybChanQualCache",StatusCode::FAILURE);
        }
        
        if (nrows > 1) {
            cerr << "Got ignoring additional ("<<nrows-1<<") DqChannelPacked results for " << ctx.AsString() << endl;
        }
        const GDqChannelPacked* row = res->GetRowByIndex(0);
        ChannelPacked::CQpacked packed;
        packed.push_back(row->GetMask0());
        packed.push_back(row->GetMask1());
        packed.push_back(row->GetMask2());
        packed.push_back(row->GetMask3());
        packed.push_back(row->GetMask4());
        packed.push_back(row->GetMask5());
        packed.push_back(row->GetMask6());
        
        ChannelPacked::CQbits channel_quality = ChannelPacked::unpack(packed);

        ChList_t::iterator it, done = m_chlist.end();
        int cqind = 0;
        m_dqcp.clear();
        for (it=m_chlist.begin(); it != done; ++it, ++cqind) {
            DayaBay::FeeChannelId chid(*it);
            m_dqcp[chid] = channel_quality[cqind]; // whew
        }
    }
    delete res;
    return updated;
    
}


// FIXME: see where called below, for now, always update
bool DybChanQualCache::update_noise(Context& ctx, bool /*force*/)
{
    //cerr << "update_noise("<<ctx.AsString("E")<<") clearing " << m_noise.size() << " channels" << endl;
    m_noise.clear();

    for (int ind=0; Dyb::noisy_channels[ind].channel.fullPackedData(); ++ind) {
        Dyb::NoisyChannel& nc = Dyb::noisy_channels[ind];
        //cerr << "update_noise() checking: " << nc.channel << " from " << nc.start.AsString("E") << " to " << nc.stop.AsString("E") << endl;

        if (! nc.covered(ctx)) { continue; }
        //cerr << "Caching based on " << ctx.AsString("E") << endl;
        m_noise[nc.channel] = nc.noise;
    }

    //cerr << "update_noise(): cached " << m_noise.size() << " noisy channels" << endl;
    return true;
}

// Maybe update cache based on a low level DBI update.  Return
// true if an update happened
bool DybChanQualCache::update(const TimeStamp& ts)
{
    // Progressively check more expensively if this timestamp is "new"

    if (ts.GetSec() == m_lastTS.GetSec() && ts.GetNanoSec() == m_lastTS.GetNanoSec()) {
        //cerr << "Cache clean on timestamp value: " << ts.AsString() << endl;
        return false;
    }
    m_lastTS = ts;
    
    Context ctx = m_timelessSM.context();
    ctx.SetTimeStamp(ts);

    //cerr << "Checking cache for " << ctx.AsString("E") << endl;

    bool updated_hv = false;
    if (m_useHV) {
        bool updated_hvloc = update_hvloc(ctx);
        bool updated_hvfee = update_hvfee(ctx);
        bool updated_hvset = update_hvset(ctx, updated_hvfee);
        bool updated_hvget = update_hvget(ctx, updated_hvfee|updated_hvloc);
        updated_hv = updated_hvset || updated_hvget;
    }

    /*bool updated_cmap =*/ update_cmap(ctx);
    bool updated_dqcp = update_dqcp(ctx);

    if (m_useNoisy) {
        update_noise(ctx, true);
    }

    return updated_hv || updated_dqcp;
}


bool DybChanQualCache::covers(const TimeStamp& start, const TimeStamp& stop)
{
    return start <= m_lastTS && m_lastTS < stop;
}


//
// DybChannelQuality view (with ownership) into the cache
//

DybChannelQuality::DybChannelQuality(DybChanQualCache* cdc, std::vector<Dyb::ChannelOverride>& chor,
                                     float delta_hv,
                                     bool usehv, bool usenoisy)
    : m_cdc(cdc)
    , m_deltaHV(delta_hv)
    , m_useHV(usehv)
    , m_useNoisy(usenoisy)
    , m_chor(chor)
{
    
}

DybChannelQuality::~DybChannelQuality()
{
    delete m_cdc;
    m_cdc = 0;
}

bool DybChannelQuality::good(DayaBay::FeeChannelId chid) const
{
    size_t nchors = m_chor.size();
    if (nchors) {
        //cerr << "Looking for " << chid.asString() << " out of  " << nchors << endl;
        for (size_t ind=0; ind < nchors; ++ind) {
            const Dyb::ChannelOverride& chor = m_chor[ind];
            if (chor.channel != chid) {
                //cerr << "\twrong channel != " << chor.channel.asString() << endl;
                continue;
            }
            if (!m_cdc->covers(chor.start, chor.stop)) {
                //cerr << "\tdoes not cover " << chor.start.AsString() << " -- " << chor.stop.AsString() << endl;
                continue;
            }
            //cerr << "\tgot it, qual = " << chor.good << endl;
            return chor.good;
        }
    }
    else {
        //cerr << "No overrides " << chid.asString() << endl;
    }

    if (m_useHV) {
        float requested = hvRequested(chid);
        if (requested < m_deltaHV) {
            return false;
        }

        float measured = hvMeasured(chid);
        if (measured < m_deltaHV) {
            return false;
        }

        if (fabs(requested-measured) > m_deltaHV) {
            return false;
        }
    }

    if (m_useNoisy) {
        if (noise(chid) > Dyb::noisy_channel_cut) {
            return false;
        }
    }

    // Return bad if channel is bad or not found (-1).  If not found
    // something is really wrong!  We should really assert that it's
    // not negative but the desired strategy from the calib group is
    // to fail towards acceptance.  So the impossible is merely
    // considered bad here.
    if (goodDqCp(chid) <= 0) {
        return false;
    }

    // Hurrah!
    return true;
}

int DybChannelQuality::goodDqCp(DayaBay::FeeChannelId chid) const
{
    DybChanQualCache::DqCpMap_t& dqcp = m_cdc->channel_quality();
    DybChanQualCache::DqCpMap_t::iterator it = dqcp.find(chid);
    if (it == dqcp.end()) { return -1; }
    return it->second;
}

float DybChannelQuality::hvRequested(DayaBay::FeeChannelId chid) const
{
    return m_cdc->setted_hv()[chid];
}

float DybChannelQuality::hvMeasured(DayaBay::FeeChannelId chid) const
{
    return m_cdc->getted_hv()[chid];
}

float DybChannelQuality::noise(DayaBay::FeeChannelId chid) const
{
    DybChanQualCache::HvValMap_t& n = m_cdc->noise();
        
    DybChanQualCache::HvValMap_t::iterator it = n.find(chid);
    if (it == n.end()) { return 0.0; } // no noise is good noise
    return it->second;
}



IChannelQuality::ChannelSet_t DybChannelQuality::channels() const
{
    IChannelQuality::ChannelSet_t ret;

    DybChanQualCache::DqCpMap_t& cqmap = m_cdc->channel_quality();
    DybChanQualCache::DqCpMap_t::iterator it, done = cqmap.end();

    for (it=cqmap.begin(); it != done; ++it) {
        ret.push_back(it->first);
    }
    return ret;
}

//
// DybChannelQualitySvc
//

DybChannelQualitySvc::DybChannelQualitySvc(const std::string& name, ISvcLocator *svc)
    : Service(name,svc)
    , m_lastSM()
{
    declareProperty("UseHV", m_useHV=false,"Consider HV tables");
    declareProperty("UseNoisy", m_useNoisy=false,"Consider hard coded noisy channels");

    declareProperty("ChannelOverride", m_chor_strings,
                    "List of channel override strings.");

}


DybChannelQualitySvc::~DybChannelQualitySvc()
{
}

StatusCode DybChannelQualitySvc::initialize()
{
    StatusCode sc = this->Service::initialize();
    if( sc.isFailure() ) return sc;

    size_t nchor = m_chor_strings.size();
    //cerr << "DybChannelQualitySvc::initialize() with #chor = " << nchor << endl;
    for (size_t ind=0; ind<nchor; ++ind) {
        string chor = m_chor_strings[ind];
        m_chor.push_back(Dyb::ChannelOverride(chor));
        //cerr << "\tchor: " << chor << endl;
    }
    return StatusCode::SUCCESS;
}

const IChannelQuality* DybChannelQualitySvc::get(const ServiceMode& sm)
{
    ServiceMode timeless(Context(sm.context().GetSite(), 
                                 sm.context().GetSimFlag(),
                                 TimeStamp(0,0),
                                 sm.context().GetDetId()),
                         sm.task());
    CacheMap_t::iterator it = m_cache.find(timeless);
    if (it == m_cache.end()) {
        return 0;
    }
    return it->second;
}

void DybChannelQualitySvc::clearChannel(const ServiceMode& timeless_sm)
{
    CacheMap_t::iterator it = m_cache.find(timeless_sm);
    if (it == m_cache.end()) {
        return;                 // can't clear what we don't have
    }

    delete it->second;
    m_cache.erase(it);
}

const IChannelQuality* DybChannelQualitySvc::channelQuality(const ServiceMode& sm)
{
    // First to trivial tests in case users is lazy and re-calls us

    if (sm.context() == m_lastSM.context() && sm.task() == m_lastSM.task()) {
        //cerr << "Clean on ServiceMode value" << endl;
        return this->get(sm);
    }
    m_lastSM = sm;


    // Fresh SM, got to dig deeper

    //cerr << "Checking cache based on " << sm.context().AsString("E") << endl;

    Context ctx = sm.context();
    ctx.SetTimeStamp(TimeStamp::GetBOT());
    ServiceMode timeless_sm(ctx,sm.task());

    // Get, and make if needed, the DCQ for the given SM, neglecting
    // the time.
    DybChannelQuality* dcq = 0;
    CacheMap_t::iterator it = m_cache.find(timeless_sm);

    try {

        if (it == m_cache.end()) {  // first time to see this SM
            DybChanQualCache* dcq_cache = new DybChanQualCache(sm, m_useHV, m_useNoisy);
                                // full SM here!
            dcq = new DybChannelQuality(dcq_cache, m_chor, 15.0, m_useHV, m_useNoisy);
            m_cache[timeless_sm] = dcq;
            //cerr << "New cache based on " << sm.context().AsString("E") << endl;
        }
        else {                  // been there, done that
            dcq = it->second;
            bool upped = dcq->cache().update(sm.context().GetTimeStamp());
            if (upped) {
                //cerr << "Updated cache based on " << sm.context().AsString("E") << endl;
            }

        }

    }
    catch (const GaudiException& ge) {
        //cerr << "Exception during update: " << ge << " at " << sm.context().AsString("E") << endl;
        this->clearChannel(timeless_sm);
        dcq = 0;
        return 0;
    }

    if (dcq && dcq->cache().empty()) {
        //cerr << "Got ChannelQuality but it is empty: at " << sm.context().AsString("E") << endl;
        this->clearChannel(timeless_sm);
        dcq = 0;
        return 0;
    }

    return dcq;
}

StatusCode DybChannelQualitySvc::queryInterface(const InterfaceID& riid, 
                                                void** ppvInterface)
{
    StatusCode sc = StatusCode::FAILURE;
    if (ppvInterface) {
        *ppvInterface = 0;
    
        if (IChannelQualitySvc::interfaceID().versionMatch(riid)) {
            *ppvInterface = static_cast<IChannelQualitySvc*>(this);
            sc = StatusCode::SUCCESS;
            addRef();
        }
        else sc = Service::queryInterface( riid, ppvInterface );    
    }
    return sc;
}