DybChannelQualitySvc.h

Go to the documentation of this file.

#ifndef DYBCHANNELQUALITYSVC_H
#define DYBCHANNELQUALITYSVC_H

#include "ChOr.h"

#include "DybKernel/IChannelQualitySvc.h"
#include "Context/ServiceMode.h"
#include "DatabaseInterface/DbiResultKey.h"
#include "Conventions/Electronics.h"
#include "Conventions/HighVoltage.h"

#include "GaudiKernel/Service.h"

#include <map>


class DybChanQualCache {
public:
    // Make a cache based on the non-time components of the
    // ServiceMode and prime using them plus the timestamp.
    DybChanQualCache(const ServiceMode& sm, bool usehv, bool usenoisy);

    // Maybe update cache based on a low level DBI update.  Return
    // true if an update happened
    bool update(const TimeStamp& ts);


    // Return true if the cache is not fully populated
    bool empty();

    // Access cached data by FeeChannelID
    typedef std::map<DayaBay::FeeChannelId, float> HvValMap_t;
    HvValMap_t& setted_hv() { return m_hvset; }
    HvValMap_t& getted_hv() { return m_hvget; }
    HvValMap_t& noise() { return m_noise;}

    // Return if the cache is inside [start, stop)
    bool covers(const TimeStamp& start, const TimeStamp& stop);

    // Access map of channel to its quality (true is "good")
    typedef std::map<DayaBay::FeeChannelId, bool> DqCpMap_t;
    DqCpMap_t& channel_quality() { return m_dqcp; }
    


private:

    void check_hvchid(DayaBay::HvChannelId hvch, const std::string& who);
    int feechid(int hvb, int hvc);
    bool update_hvloc(Context& ctx);
    bool update_hvfee(Context& ctx);
    bool update_hvset(Context& ctx, bool force);
    bool update_hvget(Context& ctx, bool force);

    bool update_cmap(Context& ctx);
    bool update_dqcp(Context& ctx);

    bool update_noise(Context& ctx, bool force);

    // resolve HV channel to FEE channel IDs
    DayaBay::FeeChannelId hv2fee(DayaBay::HvChannelId hvch);

private:

    ServiceMode m_timelessSM;

    TimeStamp m_lastTS;

    // The cached items
    mutable HvValMap_t m_hvset;
    mutable HvValMap_t m_hvget;
    mutable HvValMap_t m_noise;
    mutable DqCpMap_t m_dqcp;

    // cache channel ordering for use by DqCp.
    typedef std::list<int> ChList_t;
    mutable ChList_t m_chlist;

    DbiResultKey* m_hvlocKey;
    DbiResultKey* m_hvfeeKey;
    DbiResultKey* m_hvgetKey;
    DbiResultKey* m_hvsetKey;
    DbiResultKey* m_dqcpKey;    // DqChannelPacked
    DbiResultKey* m_cmapKey;    // ChannelMap

    // cache the location ID to HV channel id
    typedef std::map< std::string, DayaBay::HvChannelId > Loc2hv_t;
    Loc2hv_t m_loc2hv;

    // cache hv channel ID to fee channel id
    typedef std::map< DayaBay::HvChannelId, DayaBay::FeeChannelId > Hv2fee_t;
    Hv2fee_t m_hv2fee;


    bool m_useHV, m_useNoisy;
};

class DybChannelQuality : public IChannelQuality {

public:                         // Used by the service

    // FIXME: use system of units!?
    DybChannelQuality(DybChanQualCache* cdc, 
                      std::vector<Dyb::ChannelOverride>& chor,
                      float delta_hv = 15 /*V*/, 
                      bool usehv=false, bool usenoisy=false);
    virtual ~DybChannelQuality();

    DybChanQualCache& cache() { return *m_cdc; }

public:                         // IChannelQuality interface

    virtual bool good(DayaBay::FeeChannelId chid) const;

    virtual float hvRequested(DayaBay::FeeChannelId chid) const;

    virtual float hvMeasured(DayaBay::FeeChannelId chid) const;

    virtual float noise(DayaBay::FeeChannelId chid) const;

    virtual IChannelQuality::ChannelSet_t channels() const;

    virtual int goodDqCp(DayaBay::FeeChannelId chid) const;

private:

    mutable DybChanQualCache* m_cdc;
    float m_deltaHV;
    bool m_useHV, m_useNoisy;
    std::vector<Dyb::ChannelOverride> m_chor;
};



class DybChannelQualitySvc : public Service, 
                             virtual public IChannelQualitySvc
{
public:
    DybChannelQualitySvc(const std::string& name, ISvcLocator *svc);
    virtual ~DybChannelQualitySvc();


    // service interface
    virtual StatusCode initialize();

    // IChannelQualitySvc interface
    const IChannelQuality* channelQuality(const ServiceMode& sm);


    // Service interface
    StatusCode queryInterface(const InterfaceID& riid, void** ppvInterface);

private:

    // Lookup in the cache using a timeless SM based on the given one
    const IChannelQuality* get(const ServiceMode& sm);

    // evil company
    void clearChannel(const ServiceMode& timeless_sm);

private:

    // Keep a timeless but per ServiceMode cache of the various
    // collections in order to minimize the chance that we will screw
    // over the user.  We hold on to the cache through a
    // DybChannelQuality view object
    typedef std::map<ServiceMode,DybChannelQuality*> CacheMap_t;
    mutable CacheMap_t m_cache;

    // Trivial caching
    mutable ServiceMode m_lastSM;

    bool m_useHV;

    bool m_useNoisy;

    std::vector<std::string> m_chor_strings;
    std::vector<Dyb::ChannelOverride> m_chor;
};


#endif  // DYBCHANNELQUALITYSVC_H