DCMHardwareConfig.cpp

Go to the documentation of this file.

#include <DatabaseUtils/DAQConfig/DCMHardwareConfig.h>
#include <DatabaseUtils/DAQConfig/ConfigDataTree.h>
#include <DatabaseUtils/DAQConfig/DBColumnParams.h>
#include <DatabaseUtils/DAQConfig/GlobalNameSpec.h>
#include <DatabaseUtils/DAQConfig/NamedConfigUtils.h>
#include <DatabaseUtils/DAQConfig/SubsystemNameSpec.h>

namespace dbutils {
namespace daqconfig {

const uint16_t LOW_FEB_ID = DBColumnParams::LOW_FEB_ID;
const uint16_t HIGH_FEB_ID = DBColumnParams::HIGH_FEB_ID;

const uint16_t LOW_PIXEL_ID = DBColumnParams::LOW_PIXEL_ID;
const uint16_t HIGH_PIXEL_ID = DBColumnParams::HIGH_PIXEL_ID;

/**
 * Creates a DCM hardware configuration object from the specified
 * list of subsystem configuration IDs.
 *
 * @param subsystemConfigIdList The list of subsystem
 *        configuration IDs.
 * @param dcmName The name of the DCM of interest.
 */
DCMHardwareConfig::
DCMHardwareConfig(const std::vector<int64_t>& subsystemConfigIdList,
                  const std::string& dcmName, bool loadDataImmediately) :
    _dcmName(dcmName), _subsystemConfigIdList(subsystemConfigIdList),
    _hasValidData(false), _primarySubsystemConfigId(-1)
{
    if (loadDataImmediately) {loadData();}
}

/**
 * Creates a DCM hardware configuration object from the specified
 * subsystem configuration specification.
 *
 * @param nameSpec The named configuration of interest.
 * @param dcmName The name of the DCM of interest.
 */
DCMHardwareConfig::
DCMHardwareConfig(const SubsystemNameSpec& nameSpec,
                  const std::string& dcmName, bool loadDataImmediately) :
    _dcmName(dcmName), _hasValidData(false),
    _primarySubsystemConfigId(-1)
{
    _fetchNamedConfigList(nameSpec, _subsystemConfigIdList);
    if (loadDataImmediately) {loadData();}
}

/**
 * Creates a DCM hardware configuration object from the specified
 * global configuration specification.
 *
 * @param nameSpec The named configuration of interest.
 * @param dcmName The name of the DCM of interest.
 */
DCMHardwareConfig::
DCMHardwareConfig(const GlobalNameSpec& nameSpec,
                  const std::string& dcmName, bool loadDataImmediately) :
    _dcmName(dcmName), _hasValidData(false),
    _primarySubsystemConfigId(-1)
{
    _fetchNamedConfigList(nameSpec, _subsystemConfigIdList);
    if (loadDataImmediately) {loadData();}
}

/**
 * Creates a DCM hardware configuration object from the specified
 * global configuration ID.
 *
 * @param globalConfigId The ID of the global configuration of interest.
 * @param dcmName The name of the DCM of interest.
 */
DCMHardwareConfig::
DCMHardwareConfig(const int64_t& globalConfigId,
                  const std::string& dcmName, bool loadDataImmediately) :

    _dcmName(dcmName), _hasValidData(false),
    _primarySubsystemConfigId(-1)
{
    IDSpec idSpec(globalConfigId, IDSpec::GLOBAL, IDSpec::DAQ);
    NamedConfigUtils::
        getSubsystemConfigIdAncestryFromGlobalId(idSpec,
                                                 SubsystemNameSpec::
                                                 DCM_SUBSYSTEM_NAME,
                                                 SubsystemNameSpec::
                                                 HARDWARE_CONFIG_TYPE,
                                                 _subsystemConfigIdList);
    if (loadDataImmediately) {loadData();}
}

/**
 * Loads DCM hardware configuration data from the database into this
 * object.  Before this method is called, an instance of this class
 * will *not* have valid data.
 */
void DCMHardwareConfig::loadData()
{
    boost::mutex::scoped_lock sl(_dataMutex);

    if (_subsystemConfigIdList.size() > 0) {
        _primarySubsystemConfigId = _subsystemConfigIdList[0];
        _hasValidData = _fetchAllData(_subsystemConfigIdList, _dcmName);
    }
}

/**
 * Returns the number of enabled pixels on this DCM.
 */
int DCMHardwareConfig::getEnabledPixelCount()
{
    boost::mutex::scoped_lock sl(_dataMutex);
    int count = 0;

    for (uint16_t fdx = LOW_FEB_ID; fdx <= HIGH_FEB_ID; ++fdx) {
        int64_t sixtyFourBitOne = 1;

        if ((_febEnableMask & (sixtyFourBitOne << fdx)) == 0) {continue;}

        if (fdx < _pixelEnableList.size()) {
            int32_t pixelMask = _pixelEnableList[fdx];
            for (int ipix = 0; ipix < 32; ++ipix) {
                if ((pixelMask & (1 << ipix)) != 0) {
                    ++count;
                }
            }
        }
    }

    return count;
}

/**
 * Fetches the list of named configuration IDs that correspond to the
 * input named configuration.
 *
 * The list contains the single named configuration ID that is identified
 * by the input parameters as its first element.  The second element is
 * the parent named configuration (if any), followed by the grandparent
 * named configuration, etc.
 *
 * @param nameSpec The named configuration of interest.
 * @param idList The resulting list of named subsystem configuration IDs
 *        [output parameter].
 *
 * @returns true if the list was successfully fetched, false if not
 */
bool DCMHardwareConfig::
_fetchNamedConfigList(const SubsystemNameSpec& nameSpec,
                      std::vector<int64_t>& idList)
{
    return NamedConfigUtils::
        getSubsystemConfigIdAncestry(nameSpec, idList);
}

/**
 * Fetches the list of named configuration IDs that correspond to the
 * input named configuration.
 *
 * The list contains the single named configuration ID that is identified
 * by the input parameters as its first element.  The second element is
 * the parent named configuration (if any), followed by the grandparent
 * named configuration, etc.
 *
 * @param nameSpec The named configuration of interest.
 * @param idList The resulting list of named subsystem configuration IDs
 *        [output parameter].
 *
 * @returns true if the list was successfully fetched, false if not
 */
bool DCMHardwareConfig::
_fetchNamedConfigList(const GlobalNameSpec& nameSpec,
                      std::vector<int64_t>& idList)
{
    int64_t subsystemConfigId;
    bool status = NamedConfigUtils::
        getSubsystemConfigIdFromGlobalName(nameSpec,
                                           SubsystemNameSpec::
                                           DCM_SUBSYSTEM_NAME,
                                           SubsystemNameSpec::
                                           HARDWARE_CONFIG_TYPE,
                                           subsystemConfigId);

    if (status) {
        IDSpec idSpec(subsystemConfigId, IDSpec::SUBSYSTEM, IDSpec::DAQ);
        status = NamedConfigUtils::getConfigIdAncestry(idSpec, idList);
    }

    return status;
}

bool DCMHardwareConfig::
_fetchAllData(const std::vector<int64_t>& subsystemConfigIdList,
              const std::string& dcmName)
{
    bool status = true;

    // system-wide data
    if (status) {
        status = _fetchDCMSystemParams(subsystemConfigIdList);
    }

    // dcm-specific data
    if (status) {
        status = _fetchDCMFirmwareLocations(subsystemConfigIdList, dcmName);
    }
    if (status) {
        status = _fetchFEBFirmwareLocations(subsystemConfigIdList, dcmName);
    }
    if (status) {
        status = _fetchFEBEnableMasks(subsystemConfigIdList, dcmName);
    }
    if (status) {
        status = _fetchDCMDataDevValues(subsystemConfigIdList, dcmName);
    }
    if (status) {
        status = _fetchTimingSystemValues(subsystemConfigIdList, dcmName);
    }
    if (status) {
        status = _fetchDCMFPGAParams(subsystemConfigIdList, dcmName);
    }
    if (status) {
        status = _fetchDCMApplicationParams(subsystemConfigIdList, dcmName);
    }

    // feb-specific data
    if (status) {
        status = _fetchPixelEnableMasks(subsystemConfigIdList, dcmName);
    }
    if (status) {
        status = _fetchASICRegisterValues(subsystemConfigIdList, dcmName);
    }
    if (status) {
        status = _fetchDSODataRegulatorValues(subsystemConfigIdList, dcmName);
    }
    if (status) {
        status = _fetchFEBPulserValues(subsystemConfigIdList, dcmName);
    }

    // pixel-specific data
    if (status) {
        status = _fetchPixelOffsets(subsystemConfigIdList, dcmName);
    }
    if (status) {
        status = _fetchPixelThresholds(subsystemConfigIdList, dcmName);
    }

    return status;
}

bool DCMHardwareConfig::
_fetchDCMSystemParams(const std::vector<int64_t>& subsystemConfigIdList)
{
    ConfigDataSelector cfgSelector;

    std::vector<std::string> dataColumnsOfInterest;
    dataColumnsOfInterest.push_back("fpgaMode");
    dataColumnsOfInterest.push_back("microSliceDT");

    ConfigDataTree
        dcmSystemParamDataSet("NovaDatabase/tables/DAQConfig/DCMSystemParameters.xml",
                              subsystemConfigIdList, cfgSelector,
                              dataColumnsOfInterest);

    if (! dcmSystemParamDataSet.getTrueValue("fpgaMode", _dcmFPGAMode)) {
        return false;
    }
    if (! dcmSystemParamDataSet.getTrueValue("microSliceDT",
                                             _microsliceTimeLength)) {
        return false;
    }
    return true;
}

bool DCMHardwareConfig::
_fetchDCMFirmwareLocations(const std::vector<int64_t>& subsystemConfigIdList,
                           const std::string& dcmName)
{
    ConfigDataSelector cfgSelector;
    cfgSelector.addSelectionColumn(DBColumnParams::DCMID_COLUMN_NAME,
                                   dcmName, dcmName);

    std::vector<std::string> dataColumnsOfInterest;
    dataColumnsOfInterest.push_back("location");
    dataColumnsOfInterest.push_back("forceProgramming");

    ConfigDataTree
        dcmFirmwareDataSet("NovaDatabase/tables/DAQConfig/DCMFPGAFirmwareLocations.xml",
                           subsystemConfigIdList, cfgSelector,
                           dataColumnsOfInterest);
    if (! dcmFirmwareDataSet.getEffectiveValueFor1Key(dcmName, "location",
                                                      _dcmFirmwareLocation)) {
        return false;
    }
    if (! dcmFirmwareDataSet.getEffectiveValueFor1Key(dcmName,
                                                      "forceProgramming",
                                                      _forceDCMFirmwareProgramming)) {
        return false;
    }
    return true;
}

bool DCMHardwareConfig::
_fetchFEBFirmwareLocations(const std::vector<int64_t>& subsystemConfigIdList,
                           const std::string& dcmName)
{
    ConfigDataSelector cfgSelector;
    cfgSelector.addSelectionColumn(DBColumnParams::DCMID_COLUMN_NAME,
                                   dcmName, dcmName);

    std::vector<std::string> dataColumnsOfInterest;
    dataColumnsOfInterest.push_back("location");
    dataColumnsOfInterest.push_back("forceProgramming");

    ConfigDataTree
        febFirmwareDataSet("NovaDatabase/tables/DAQConfig/FEBFPGAFirmwareLocations.xml",
                           subsystemConfigIdList, cfgSelector,
                           dataColumnsOfInterest);
    if (! febFirmwareDataSet.getEffectiveValueFor1Key(dcmName, "location",
                                                      _febFirmwareLocation)) {
        return false;
    }
    if (! febFirmwareDataSet.getEffectiveValueFor1Key(dcmName,
                                                      "forceProgramming",
                                                      _forceFEBFirmwareProgramming)) {
        return false;
    }
    return true;
}

bool DCMHardwareConfig::
_fetchFEBEnableMasks(const std::vector<int64_t>& subsystemConfigIdList,
                     const std::string& dcmName)
{
    ConfigDataSelector cfgSelector;
    cfgSelector.addSelectionColumn(DBColumnParams::DCMID_COLUMN_NAME,
                                   dcmName, dcmName);

    std::vector<std::string> dataColumnsOfInterest;
    dataColumnsOfInterest.push_back("mask");

    ConfigDataTree
        febEnableMaskDataSet("NovaDatabase/tables/DAQConfig/FEBEnableMasks.xml",
                             subsystemConfigIdList, cfgSelector,
                             dataColumnsOfInterest);
    return febEnableMaskDataSet.getEffectiveValueFor1Key(dcmName, "mask",
                                                         _febEnableMask);
}

bool DCMHardwareConfig::
_fetchDCMDataDevValues(const std::vector<int64_t>& subsystemConfigIdList,
                       const std::string& dcmName)
{
    ConfigDataSelector cfgSelector;
    cfgSelector.addSelectionColumn(DBColumnParams::DCMID_COLUMN_NAME,
                                   dcmName, dcmName);

    std::vector<std::string> dataColumnsOfInterest;
    dataColumnsOfInterest.push_back("readTimeout");
    dataColumnsOfInterest.push_back("useMemoryMappedBuffer");

    ConfigDataTree
        dcmDataDevDataSet("NovaDatabase/tables/DAQConfig/DCMDataDevParameters.xml",
                          subsystemConfigIdList, cfgSelector,
                          dataColumnsOfInterest);

    if (! dcmDataDevDataSet.getEffectiveValueFor1Key(dcmName, "readTimeout",
                                                     _dcmReadTimeout)) {
        return false;
    }
    if (! dcmDataDevDataSet.getEffectiveValueFor1Key(dcmName,
                                                     "useMemoryMappedBuffer",
                                                     _useMemoryMappedBuffer)) {
        return false;
    }
    return true;
}

bool DCMHardwareConfig::
_fetchTimingSystemValues(const std::vector<int64_t>& subsystemConfigIdList,
                         const std::string& dcmName)
{
    ConfigDataSelector cfgSelector;
    cfgSelector.addSelectionColumn(DBColumnParams::DCMID_COLUMN_NAME,
                                   dcmName, dcmName);

    std::vector<std::string> dataColumnsOfInterest;
    dataColumnsOfInterest.push_back("enable");
    dataColumnsOfInterest.push_back("port");
    dataColumnsOfInterest.push_back("tduFirmwareVersion");
    dataColumnsOfInterest.push_back("historyEnable");

    ConfigDataTree
        timingSystemDataSet("NovaDatabase/tables/DAQConfig/TimingSystemSettings.xml",
                            subsystemConfigIdList, cfgSelector,
                            dataColumnsOfInterest);

    if (! timingSystemDataSet.getEffectiveValueFor1Key(dcmName, "enable",
                                                       _timingSystemEnable)) {
        return false;
    }
    if (! timingSystemDataSet.getEffectiveValueFor1Key(dcmName, "port",
                                                       _timingSystemPort)) {
        return false;
    }
    if (! timingSystemDataSet.getEffectiveValueFor1Key(dcmName,
                                                       "tduFirmwareVersion",
                                                       _tduFirmwareVersion)) {
        return false;
    }
    if (! timingSystemDataSet.getEffectiveValueFor1Key(dcmName,
                                                       "historyEnable",
                                                       _timingHistoryEnable)) {
        return false;
    }
    return true;
}

bool DCMHardwareConfig::
_fetchDCMFPGAParams(const std::vector<int64_t>& subsystemConfigIdList,
                    const std::string& dcmName)
{
    ConfigDataSelector cfgSelector;
    cfgSelector.addSelectionColumn(DBColumnParams::DCMID_COLUMN_NAME,
                                   dcmName, dcmName);

    std::vector<std::string> dataColumnsOfInterest;
    dataColumnsOfInterest.push_back("linkTimeout");
    dataColumnsOfInterest.push_back("doReset");
    dataColumnsOfInterest.push_back("nanoSliceVersion");

    ConfigDataTree
        dcmParamDataSet("NovaDatabase/tables/DAQConfig/DCMFPGAParameters.xml",
                        subsystemConfigIdList, cfgSelector,
                        dataColumnsOfInterest);
    if (! dcmParamDataSet.getEffectiveValueFor1Key(dcmName, "linkTimeout",
                                                   _fpgaLinkTimeout)) {
        return false;
    }
    if (! dcmParamDataSet.getEffectiveValueFor1Key(dcmName, "doReset",
                                                   _doDCMFPGAReset)) {
        return false;
    }
    if (! dcmParamDataSet.getEffectiveValueFor1Key(dcmName, "nanoSliceVersion",
                                                   _nanoSliceVersion)) {
        return false;
    }
    return true;
}

bool DCMHardwareConfig::
_fetchDCMApplicationParams(const std::vector<int64_t>& subsystemConfigIdList,
                           const std::string& dcmName)
{
    ConfigDataSelector cfgSelector;
    cfgSelector.addSelectionColumn(DBColumnParams::DCMID_COLUMN_NAME,
                                   dcmName, dcmName);

    std::vector<std::string> dataColumnsOfInterest;
    dataColumnsOfInterest.push_back("numberOfHwConfigAttempts");

    ConfigDataTree
        dcmParamDataSet("NovaDatabase/tables/DAQConfig/DCMApplicationParameters.xml",
                        subsystemConfigIdList, cfgSelector,
                        dataColumnsOfInterest);
    return dcmParamDataSet.getEffectiveValueFor1Key(dcmName,
                                                    "numberOfHwConfigAttempts",
                                                    _numberOfHwConfigAttempts);
}

bool DCMHardwareConfig::
_fetchPixelEnableMasks(const std::vector<int64_t>& subsystemConfigIdList,
                       const std::string& dcmName)
{
    ConfigDataSelector cfgSelector;
    cfgSelector.addSelectionColumn(DBColumnParams::DCMID_COLUMN_NAME,
                                   dcmName, dcmName);
    cfgSelector.addSelectionColumn(DBColumnParams::FEBID_COLUMN_NAME);

    std::vector<std::string> dataColumnsOfInterest;
    dataColumnsOfInterest.push_back("mask");

    ConfigDataTree
        pixelEnableDataSet("NovaDatabase/tables/DAQConfig/PixelEnableMasks.xml",
                           subsystemConfigIdList, cfgSelector,
                           dataColumnsOfInterest);

    for (uint16_t fdx = LOW_FEB_ID; fdx <= HIGH_FEB_ID; ++fdx) {
        int32_t value;
        if (! pixelEnableDataSet.getEffectiveValueFor2Keys(dcmName, fdx,
                                                           "mask", value)) {
            return false;
        }
        _pixelEnableList.push_back(value);
    }

    return true;
}

bool DCMHardwareConfig::
_fetchASICRegisterValues(const std::vector<int64_t>& subsystemConfigIdList,
                         const std::string& dcmName)
{
    ConfigDataSelector cfgSelector;
    cfgSelector.addSelectionColumn(DBColumnParams::DCMID_COLUMN_NAME,
                                   dcmName, dcmName);
    cfgSelector.addSelectionColumn(DBColumnParams::FEBID_COLUMN_NAME);

    std::vector<std::string> dataColumnsOfInterest;
    dataColumnsOfInterest.push_back("spare");
    dataColumnsOfInterest.push_back("vtsel");
    dataColumnsOfInterest.push_back("refsel");
    dataColumnsOfInterest.push_back("isel");
    dataColumnsOfInterest.push_back("bwsel");
    dataColumnsOfInterest.push_back("gsel");
    dataColumnsOfInterest.push_back("tfsel");
    dataColumnsOfInterest.push_back("mux2to1");
    dataColumnsOfInterest.push_back("mux8to1");
    dataColumnsOfInterest.push_back("qInjPixelMask");

    ConfigDataTree
        pixelEnableDataSet("NovaDatabase/tables/DAQConfig/ASICRegisterSettings.xml",
                           subsystemConfigIdList, cfgSelector,
                           dataColumnsOfInterest);

    for (uint16_t fdx = LOW_FEB_ID; fdx <= HIGH_FEB_ID; ++fdx) {
        int16_t asicSpareValue;
        if (! pixelEnableDataSet.getEffectiveValueFor2Keys(dcmName, fdx,
                                                           "spare",
                                                           asicSpareValue)) {
            return false;
        }
        int16_t asicVtSelValue;
        if (! pixelEnableDataSet.getEffectiveValueFor2Keys(dcmName, fdx,
                                                           "vtsel",
                                                           asicVtSelValue)) {
            return false;
        }
        int16_t asicRefSelValue;
        if (! pixelEnableDataSet.getEffectiveValueFor2Keys(dcmName, fdx,
                                                           "refsel",
                                                           asicRefSelValue)) {
            return false;
        }
        int16_t asicISelValue;
        if (! pixelEnableDataSet.getEffectiveValueFor2Keys(dcmName, fdx,
                                                           "isel", 
                                                           asicISelValue)) {
            return false;
        }
        int16_t asicBWSelValue;
        if (! pixelEnableDataSet.getEffectiveValueFor2Keys(dcmName, fdx,
                                                           "bwsel",
                                                           asicBWSelValue)) {
            return false;
        }
        int16_t asicGSelValue;
        if (! pixelEnableDataSet.getEffectiveValueFor2Keys(dcmName, fdx,
                                                           "gsel", 
                                                           asicGSelValue)) {
            return false;
        }
        int16_t asicTfSelValue;
        if (! pixelEnableDataSet.getEffectiveValueFor2Keys(dcmName, fdx,
                                                           "tfsel",
                                                           asicTfSelValue)) {
            return false;
        }
        int16_t asicMux2to1Value;
        if (! pixelEnableDataSet.getEffectiveValueFor2Keys(dcmName, fdx,
                                                           "mux2to1",
                                                           asicMux2to1Value)) {
            return false;
        }
        int16_t asicMux8to1Value;
        if (! pixelEnableDataSet.getEffectiveValueFor2Keys(dcmName, fdx,
                                                           "mux8to1",
                                                           asicMux8to1Value)) {
            return false;
        }
        int32_t asicQInjPixelMask;
        if (! pixelEnableDataSet.getEffectiveValueFor2Keys(dcmName, fdx,
                                                           "qInjPixelMask",
                                                           asicQInjPixelMask)) {
            return false;
        }

        ASICRegisterValueSet theSet(asicSpareValue,
                                    asicVtSelValue,
                                    asicRefSelValue,
                                    asicISelValue,
                                    asicBWSelValue,
                                    asicGSelValue,
                                    asicTfSelValue,
                                    asicMux2to1Value,
                                    asicMux8to1Value,
                                    asicQInjPixelMask);
        _asicRegisterValueList.push_back(theSet);
    }

    return true;
}

bool DCMHardwareConfig::
_fetchDSODataRegulatorValues(const std::vector<int64_t>& subsystemConfigIdList,
                             const std::string& dcmName)
{
    ConfigDataSelector cfgSelector;
    cfgSelector.addSelectionColumn(DBColumnParams::DCMID_COLUMN_NAME,
                                   dcmName, dcmName);
    cfgSelector.addSelectionColumn(DBColumnParams::FEBID_COLUMN_NAME);

    std::vector<std::string> dataColumnsOfInterest;
    dataColumnsOfInterest.push_back("pointsPerPixel");

    ConfigDataTree
        dsoDataRegulatorDataSet("NovaDatabase/tables/DAQConfig/DSODataRegulatorSettings.xml",
                                subsystemConfigIdList, cfgSelector,
                                dataColumnsOfInterest);

    for (uint16_t fdx = LOW_FEB_ID; fdx <= HIGH_FEB_ID; ++fdx) {
        int16_t value;
        if (! dsoDataRegulatorDataSet.
            getEffectiveValueFor2Keys(dcmName, fdx,
                                      "pointsPerPixel", value)) {
            return false;
        }
        _dsoPointsPerPixelList.push_back(value);
    }

    return true;
}

bool DCMHardwareConfig::
_fetchFEBPulserValues(const std::vector<int64_t>& subsystemConfigIdList,
                      const std::string& dcmName)
{
    ConfigDataSelector cfgSelector;
    cfgSelector.addSelectionColumn(DBColumnParams::DCMID_COLUMN_NAME,
                                   dcmName, dcmName);
    cfgSelector.addSelectionColumn(DBColumnParams::FEBID_COLUMN_NAME);

    std::vector<std::string> dataColumnsOfInterest;
    dataColumnsOfInterest.push_back("pulserEnable");
    dataColumnsOfInterest.push_back("pulserPeriod");
    dataColumnsOfInterest.push_back("pulserWidth");

    ConfigDataTree
        febPulserDataSet("NovaDatabase/tables/DAQConfig/FEBPulserParameters.xml",
                         subsystemConfigIdList, cfgSelector,
                         dataColumnsOfInterest);

    for (uint16_t fdx = LOW_FEB_ID; fdx <= HIGH_FEB_ID; ++fdx) {
        int16_t pulserEnable;
        if (! febPulserDataSet.getEffectiveValueFor2Keys(dcmName, fdx,
                                                         "pulserEnable",
                                                         pulserEnable)) {
            return false;
        }
        int32_t pulserPeriod;
        if (! febPulserDataSet.getEffectiveValueFor2Keys(dcmName, fdx,
                                                         "pulserPeriod",
                                                         pulserPeriod)) {
            return false;
        }
        int32_t pulserWidth;
        if (! febPulserDataSet.getEffectiveValueFor2Keys(dcmName, fdx,
                                                         "pulserWidth",
                                                         pulserWidth)) {
            return false;
        }

        FEBPulserParameterSet theSet(pulserEnable,
                                     pulserPeriod,
                                     pulserWidth);
        _pulserParameterList.push_back(theSet);
    }

    return true;
}

bool DCMHardwareConfig::
_fetchPixelOffsets(const std::vector<int64_t>& subsystemConfigIdList,
                   const std::string& dcmName)
{
    ConfigDataSelector cfgSelector;
    cfgSelector.addSelectionColumn(DBColumnParams::DCMID_COLUMN_NAME,
                                   dcmName, dcmName);
    cfgSelector.addSelectionColumn(DBColumnParams::FEBID_COLUMN_NAME);
    cfgSelector.addSelectionColumn(DBColumnParams::PIXELID_COLUMN_NAME);

    std::vector<std::string> dataColumnsOfInterest;
    dataColumnsOfInterest.push_back("offsetValue");

    ConfigDataTree
        pixelOffsetDataSet("NovaDatabase/tables/DAQConfig/PixelOffsets.xml",
                           subsystemConfigIdList, cfgSelector,
                           dataColumnsOfInterest);

    for (uint16_t fdx = LOW_FEB_ID; fdx <= HIGH_FEB_ID; ++fdx) {
        boost::shared_ptr<std::vector<int16_t> >
            offsetList(new std::vector<int16_t>());
        for (uint16_t pdx = LOW_PIXEL_ID; pdx <= HIGH_PIXEL_ID; ++pdx) {
            int16_t value;
            if (! pixelOffsetDataSet.
                getEffectiveValueFor3Keys(dcmName, fdx, pdx,
                                          "offsetValue", value)) {
                return false;
            }
            offsetList->push_back(value);
        }
        _pixelOffsetArray.push_back(offsetList);
    }

    return true;
}

bool DCMHardwareConfig::
_fetchPixelThresholds(const std::vector<int64_t>& subsystemConfigIdList,
                      const std::string& dcmName)
{
    ConfigDataSelector cfgSelector;
    cfgSelector.addSelectionColumn(DBColumnParams::DCMID_COLUMN_NAME,
                                   dcmName, dcmName);
    cfgSelector.addSelectionColumn(DBColumnParams::FEBID_COLUMN_NAME);
    cfgSelector.addSelectionColumn(DBColumnParams::PIXELID_COLUMN_NAME);

    std::vector<std::string> dataColumnsOfInterest;
    dataColumnsOfInterest.push_back("threshold");

    ConfigDataTree
        pixelThresholdDataSet("NovaDatabase/tables/DAQConfig/PixelThresholds.xml",
                              subsystemConfigIdList, cfgSelector,
                              dataColumnsOfInterest);

    for (uint16_t fdx = LOW_FEB_ID; fdx <= HIGH_FEB_ID; ++fdx) {
        boost::shared_ptr<std::vector<int16_t> >
            thresholdList(new std::vector<int16_t>());
        for (uint16_t pdx = LOW_PIXEL_ID; pdx <= HIGH_PIXEL_ID; ++pdx) {
            int16_t value;
            if (! pixelThresholdDataSet.
                getEffectiveValueFor3Keys(dcmName, fdx, pdx,
                                          "threshold", value)) {
                return false;
            }
            thresholdList->push_back(value);
        }
        _pixelThresholdArray.push_back(thresholdList);
    }

    return true;
}

} // end of namespace daqconfig
} // end of namespace dbutils