RunHistory.cxx

Go to the documentation of this file.

#include <RunHistory/RunHistory.h>
#include <DatabaseUtils/DAQConfig/PixelEnableMasks.h>
#include <DatabaseUtils/DAQConfig/PixelThresholds.h>
#include <DatabaseUtils/DCS/APDSettings.h>
#include <DAQChannelMap/DAQChannelMap.h>
#ifdef NOVACMAKE
#include <Database/cxx/include/Table.h>
#include <Database/cxx/include/Util.h>
#else
#include <Database/Table.h>
#include <Database/Util.h>
#endif

#include <messagefacility/MessageLogger/MessageLogger.h> 
#include <cetlib_except/exception.h>

#include <cstdlib>
#include <bitset>
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <TTimeStamp.h>
#include <TStopwatch.h>

namespace db = nova::dbi;
namespace dcscfg = dbutils::dcs;
namespace daqcfg = dbutils::daqconfig;

namespace nova {
  namespace dbi {

    std::map<HardwareLocation, std::pair<FEBInfo, APDInfo>> gLocToFA; // map of location in DAQ space
                                                                      // to the connected FEB and APD
    
    //**********************************************************************
    PGresult* PerformPGQuery(std::string          const& query, 
                             std::unique_ptr<Table> const& hwTable)
    {
      bool gotConnection = hwTable->GetConnection();
      
      if (!gotConnection) {
        LOG_WARNING("RunHistory") << "Failed to connect to hardware database! "
                                << "Failed to load hardware info.";
        return nullptr;
      }
      LOG_DEBUG("RunHistory") << "about to execute query\n"
                              << query; 

      PGresult *res = nullptr;

      if (hwTable->ExecuteSQL(query,res)) {
        if (PQresultStatus(res) != PGRES_TUPLES_OK) {
          LOG_WARNING("RunHistory") << "Query failed: " << query;
          PQclear(res);
          hwTable->CloseConnection();
          return nullptr;
        }
      } // end if the query worked
      else {
        LOG_WARNING("RunHistory") << "SQL error, failed query: " << query;
        PQclear(res);
        hwTable->CloseConnection();
        return nullptr;
      }

      LOG_DEBUG("RunHistory") << "query returned " << PQntuples(res) << " rows";
      
      return res;
    }

    //**********************************************************************
    bool SortDiBlocks(RunHistory::DiBlock db1, RunHistory::DiBlock db2)
    {
      return (db1.num < db2.num);
    }

    //**********************************************************************

    RunHistory::FEB::FEB()
    {
      isEnabled = false;
      hasAPD = false;
      apdV = 0;
      isCooled = false;
      tempEnabled = false;
      temperature = -100;
      gain = 0.;
      pixelMask = 0xFFFFFFFF;
      pixelGain.resize(32, 100.);
      pixelThresh.resize(32, 0.);
    }

    //**********************************************************************

    RunHistory::RunHistory() 
      : _abort(0)
      , _abortIfMissingRunInDB(0)
      , _runNumber(-1)
      , _nsubrun(0)
      , _nTotTrig(0)
      , _nActiveChannels(0)
      , _nTotalChannels(0)
      , _nTotalFEBs(0)
      , _detId(novadaq::cnv::kUNKNOWN_DET)
      , _partition(-1)
      , _nDCMs(0)
      , _dbname("")
      , _dbhost("")
      , _dbuser("")
      , _dbport("")
      , _tStart("2010-01-01 00:00:00")
      , _tEnd("")
      , _dbList(0)
      , _bnevbList(0)
    {
      _badChanVersion="";
      _dbMaskTag="";
      _runType="";
      _npot = 0.;
      _avgpot = 0.;
      _nInstalledAPDs=0;
      _dataType = nova::dbi::kNDataType;
      SetDetector(novadaq::cnv::kUNKNOWN_DET);
      InvalidateCaches();
      _timeQueries=false;
      _timeParsing=false;
      _analysisDiBlockMasking=false;
      _nRetryLoads = 0;
      _getDiBlockMaskFromCondb = false;
      _detGainTag="";
      _verbosity=0;
      _currentSR=0;
      _ndRHCRunStart.clear();
      _ndRHCRunStop.clear();
      _fdRHCRunStart.clear();
      _fdRHCRunStop.clear();
    }
    //**********************************************************************

    RunHistory::RunHistory(int run, std::string det) 
      : _abort(0)
      , _abortIfMissingRunInDB(0)
      , _runNumber(run)
      , _nsubrun(0)
      , _nTotTrig(0)
      , _nActiveChannels(0)
      , _nTotalChannels(0)
      , _nTotalFEBs(0)
      , _partition(-1)
      , _nDCMs(0)
      , _dbname("")
      , _dbhost("")
      , _dbuser("")
      , _dbport("")
      , _tStart("2010-01-01 00:00:00")
      , _tEnd("")
      , _dbList(0)
      , _bnevbList(0)
    {
      _badChanVersion="";
      _dbMaskTag="";
      _runType="";
      _npot = 0.;
      _avgpot = 0.;
      _nInstalledAPDs=0;
      _dataType = nova::dbi::kNDataType;
      _verbosity=0;
      
      SetDetector(det);
      InvalidateCaches();
      _timeQueries=false;
      _timeParsing=false;
      _analysisDiBlockMasking=false;
      _nRetryLoads = 0;
      _getDiBlockMaskFromCondb = false;
      _detGainTag="";
      _currentSR=0;
      _ndRHCRunStart.clear();
      _ndRHCRunStop.clear();
      _fdRHCRunStart.clear();
      _fdRHCRunStop.clear();
    }
    //**********************************************************************

    RunHistory::RunHistory(int run, novadaq::cnv::DetId det) 
      : _runNumber(run)
      , _nsubrun(0)
      , _nTotTrig(0)
      , _nActiveChannels(0)
      , _nTotalChannels(0)
      , _nTotalFEBs(0)
      , _partition(-1)
      , _nDCMs(0)
      , _dbname("")
      , _dbhost("")
      , _dbuser("")
      , _dbport("")
      , _tStart("2010-01-01 00:00:00")
      , _tEnd("")
      , _dbList(0)
      , _bnevbList(0)
    {
      _badChanVersion="";
      _dbMaskTag="";
      _runType="";
      _npot = 0.;
      _avgpot = 0.;
      _nInstalledAPDs=0;
      _dataType = nova::dbi::kNDataType;

      SetDetector(det);
      InvalidateCaches();
      _timeQueries=false;
      _timeParsing=false;
      _analysisDiBlockMasking=false;
      _nRetryLoads = 0;
      _getDiBlockMaskFromCondb = false;
      _detGainTag="";
      _verbosity = 0;
      _currentSR=0;
      _ndRHCRunStart.clear();
      _ndRHCRunStop.clear();
      _fdRHCRunStart.clear();
      _fdRHCRunStop.clear();
    }

    //**********************************************************************

    RunHistory::~RunHistory()
    {
    }

    //**********************************************************************

    int RunHistory::NDCMs()
    {
      if (! _gotHardwareInfo) LoadHardwareInfo();
      return _nDCMs;
    }

    //**********************************************************************

    int RunHistory::NLiveDCMs()
    {
      if (! _gotHardwareInfo) LoadHardwareInfo();
      int ndcm=0;
      for (unsigned int i=0; i<_dbList.size(); ++i)
        for (unsigned int j=0; j<_dbList[i].dcm.size(); ++j)
          if (_dbList[i].dcm[j].isActive)
            ++ndcm;

      return ndcm;
    }

    //**********************************************************************
    int RunHistory::NAnalysisDiBlocks(int sr)
    {
      if (_subrunList[sr].gotNAnalysisDiBlocks) return _subrunList[sr].nAnalysisDiBlocks;

      _subrunList[sr].nAnalysisDiBlocks=0;
      LoadDAQRunHistory();
      LoadHardwareInfo();
      for (size_t i=0; i<_dbList.size(); ++i) {
        int db = _dbList[i].num;
        if (this->IsGoodDiBlock(db,sr)) 
          _subrunList[sr].nAnalysisDiBlocks++;
      }
      
      _subrunList[sr].gotNAnalysisDiBlocks=true;
      return _subrunList[sr].nAnalysisDiBlocks;
      
    }

    //**********************************************************************
    // This is an approximation of the number of analysis channels.  It 
    // takes into account analysis masks of diblocks, but it does not 
    // account for DAQ masks of individual pixels.  We could do that, but
    // loading all the pixel masks is currently pretty slow.  This number
    // should over estimate by no more than a few percent.  Since the primary
    // customer of this method is analysis of BadChannels, this is actually
    // the right thing to do, since BadChannels does not account for DAQ-masked
    // pixels either.
    //**********************************************************************

    int RunHistory::NAnalysisChannels(int sr)
    {
      if (_subrunList[sr].gotNAnalysisChannels) return _subrunList[sr].nAnalysisChannels;

      _subrunList[sr].nAnalysisChannels=0;
      LoadDAQRunHistory();
      LoadHardwareInfo();
      for (size_t i=0; i<_dbList.size(); ++i) {
        int db = _dbList[i].num;
        if (this->IsGoodDiBlock(db,sr)) 
          _subrunList[sr].nAnalysisChannels += 32*_dbList[i].nInstrumentedFEBs;
      }
      
      _subrunList[sr].gotNAnalysisChannels=true;
      return _subrunList[sr].nAnalysisChannels;
      
    }

    //**********************************************************************

    void RunHistory::SetDBInfo(std::string dbname, std::string dbhost,
                               std::string user,   std::string dbport)
    {
      _dbname = dbname;
      _dbhost = dbhost;
      _dbuser = user;
      _dbport = dbport;

    }

    //**********************************************************************

    void RunHistory::SetRunNumber(int run)
    {
      if(_runNumber != run) InvalidateCaches();
      _runNumber = run;
    }

    //**********************************************************************

    void RunHistory::SetDetector(novadaq::cnv::DetId det)
    {
      if(_detId != det) InvalidateCaches();

      if(!novadaq::cnv::DetInfo::DetIdOk(det) &&
         det != novadaq::cnv::kUNKNOWN_DET) {
        std::cerr << __PRETTY_FUNCTION__ << " Bad detector id: " << det << std::endl;
        std::abort();
      }
      else{
        _detId = det;
        _detector = novadaq::cnv::DetInfo::GetName(det);
      }
    }

    //**********************************************************************

    void RunHistory::SetDetector(const std::string& det)
    {
      if (! novadaq::cnv::DetInfo::DetNameOk(det)) {
        std::cerr << __PRETTY_FUNCTION__ << " Bad detector id: " << det << std::endl;
        std::abort();
      }
      else {
        SetDetector(novadaq::cnv::DetId(novadaq::cnv::DetInfo::GetId(det)));
      }
    }

    //**********************************************************************
    bool RunHistory::IsRHC() 
    {
      if (_detId == novadaq::cnv::kFARDET) {      
        if (_fdRHCRunStart.empty() || _fdRHCRunStop.empty()) {
        std::cerr << __PRETTY_FUNCTION__ << " Empty FD RHC run list!" << std::endl;
        std::abort();
        }
        if (_fdRHCRunStart.size() != _fdRHCRunStop.size() ) {
        std::cerr << __PRETTY_FUNCTION__ << " FD RHC run start list is not the same length as the run stop list.  Something is wrong..." << std::endl;
        std::abort();
        }

        for ( size_t i=0; i<_fdRHCRunStart.size(); ++i) {
          if (_runNumber >= _fdRHCRunStart[i] && 
              _runNumber <= _fdRHCRunStop[i])
            return true;
        }
        return false;
      }
      else if (_detId == novadaq::cnv::kNEARDET) {
        if (_ndRHCRunStart.empty() || _ndRHCRunStop.empty()) {
          std::cerr << __PRETTY_FUNCTION__ << " Empty ND RHC run list!" << std::endl;
        std::abort();
        }
        if (_ndRHCRunStart.size() != _ndRHCRunStop.size() ) {
        std::cerr << __PRETTY_FUNCTION__ << " ND RHC run start list is not the same length as the run stop list.  Something is wrong..." << std::endl;
        std::abort();
        }
        
        for ( size_t i=0; i<_ndRHCRunStart.size(); ++i) {
          if (_runNumber >= _ndRHCRunStart[i] && 
              _runNumber <= _ndRHCRunStop[i])
            return true;
        }
        return false;
      }
      else {
        std::cerr << __PRETTY_FUNCTION__ << " Unknown detector.  Why are asking for beam mode?" << std::endl;
        
      }
      return false;
    }

    //**********************************************************************

    bool RunHistory::LoadDCSAlarms(int subrun)
    {
      /*
      if (!_gotDAQRunHistory) {
        if (!LoadDAQRunHistory()) return false;
      }
      */

      return false;
    }

    //**********************************************************************

    bool RunHistory::LoadHardwareInfo()
    {
      if (_gotHardwareInfo) return true;

      if (!LoadDAQRunHistory()) return false;

      LOG_INFO("RunHistory") << "RunHistory: Loading FEB and APD installation information" << std::endl;

      int detId = novadaq::cnv::DetInfo::GetId(_detector);

      std::unique_ptr<db::Table> hwTable;

      hwTable.reset(new db::Table());

      if (novadaq::cnv::DetInfo::DetNameOk(_detector))
        hwTable->SetDetector(_detector);
      else
        return false;

      hwTable->SetTableType(nova::dbi::kHardwareTable);
      hwTable->SetTimeQueries(_timeQueries);
      hwTable->SetVerbosity(_verbosity);
      
      bool gotConnection = hwTable->GetConnection(_nRetryLoads);
      
      if (!gotConnection) { 
         LOG_ERROR("RunHistory") <<"RunHistory::LoadHardwareInfo(): Failed to connect to hardware database!  Failed to load hardware info." << std::endl;
         std::abort();
      }

      std::string query;
      PGresult* res;

      if (detId == novadaq::cnv::kNEARDET) {
        query="SELECT dcm_name,dcm_port,block,plane,module_position from hardware_position where detector='NearDet' and install_date at time zone 'UTC' < '" + _tStart + "' and (remove_date is NULL or remove_date at time zone 'UTC' > '" + _tStart + "') and hw_type='APD' order by dcm_name,dcm_port";

        if (hwTable->ExecuteSQL(query,res)) {
          if (PQresultStatus(res) != PGRES_TUPLES_OK) {
            std::cerr << __PRETTY_FUNCTION__ << " Query failed: " << query << std::endl;
            PQclear(res);
            hwTable->CloseConnection();
            return false;
          }

          std::string dcmName;

          int nRow = PQntuples(res);
          for (int i=0; i < nRow; i++) {
            dcmName = PQgetvalue(res,i,0);
            int ifeb = atoi(PQgetvalue(res,i,1));
            short diblock = atoi(dcmName.substr(6,2).c_str());
            //            if(_useMasking && IsGoodDiBlock(int(diblock))==false) break; // ignore masked diblocks
            unsigned int idcm = atoi(dcmName.substr(9,2).c_str());
            int idb = _diblockIndex[diblock];
            if (_dbList[idb].dcm[idcm-1].isActive) {
              if (_dbList[idb].hasNoAPDs)
                _dbList[idb].hasNoAPDs = false;
              if (_dbList[idb].dcm[idcm-1].feb[ifeb].hasAPD) continue;
              _dbList[idb].dcm[idcm-1].feb[ifeb].hasAPD = true;
              _dbList[idb].dcm[idcm-1].feb[ifeb].block = atoi(PQgetvalue(res,i,2));
              _dbList[idb].dcm[idcm-1].feb[ifeb].layer = atoi(PQgetvalue(res,i,3));
              _dbList[idb].dcm[idcm-1].feb[ifeb].pos_in_layer = atoi(PQgetvalue(res,i,4));
              _dbList[idb].dcm[idcm-1].nInstrumentedFEBs++;
              _dbList[idb].nInstrumentedFEBs++;
              ++_nInstalledAPDs;
            }
          }
          PQclear(res);
        }

      }
      else if (detId == novadaq::cnv::kFARDET) {

        // get locations of installed APDs

        query="SELECT btrim(fcom.location1,'DIBLK:') diblk, btrim(fcom.position1,'DCM:') pos, CAST(btrim(fcom.port1,'PRT:') AS INT) feb, mod.block AS block, mod.layer AS plane, mod.position_in_layer AS position FROM public.feb_comm_cables fcom, ashriverprod_factory.module mod LEFT OUTER JOIN ashriverprod_factory.barcoded_item bm ON (mod.barcoded_item_id = bm.barcoded_item_id) LEFT OUTER JOIN ashriverprod_factory.module_apd_connection ON (mod.barcoded_item_id = module_apd_connection.module) LEFT OUTER JOIN ashriverprod_factory.apd ON (module_apd_connection.apd = apd.barcoded_item_id) LEFT OUTER JOIN ashriverprod_factory.barcoded_item ba ON (apd.barcoded_item_id = ba.barcoded_item_id) LEFT OUTER JOIN ashriverprod_factory.nova_connection mac ON (mac.connection_id = module_apd_connection.connection_id) WHERE mac.date_created AT TIME ZONE 'CDT' < '" + _tStart + "' and (mac.date_removed is NULL or mac.date_removed AT TIME ZONE 'CDT' > '" + _tStart + "') and (mod.block=CAST(btrim(fcom.location2,'BLK:') AS INT) and mod.layer=CAST(btrim(fcom.position2,'PLN:') AS INT) and mod.position_in_layer=CAST(btrim(fcom.port2,'POS:') AS INT)) ORDER BY diblk,pos,feb";

        if (hwTable->ExecuteSQL(query,res)) {
          if (PQresultStatus(res) != PGRES_TUPLES_OK) {
            std::cerr << __PRETTY_FUNCTION__ << " Query failed: " << query << std::endl;
            PQclear(res);
            hwTable->CloseConnection();
            return false;
          }

          std::string dcmName;

          int nRow = PQntuples(res);
          for (int i=0; i < nRow; i++) {
            int diblock = atoi(PQgetvalue(res,i,0));
            if(_useMasking && IsGoodDiBlock(diblock)==false) continue; // ignore masked diblocks
            unsigned int idcm = atoi(PQgetvalue(res,i,1));
            //            if(std::string(PQgetvalue(res,i,6)).compare(0,3,"S11") != 0)  // one possible way of checking for permanently bad APDs, depending on DB
            int idb = _diblockIndex[diblock];
            int ifeb = atoi(PQgetvalue(res,i,2));
            if( (diblock==4 &&idcm==7 &&ifeb==15) ||   // hard code list of permanently bad APDs to ignore
                (diblock==5 &&idcm==7 &&ifeb==59) ||
                (diblock==14&&idcm==6 &&ifeb==42) ) continue;
            if (_dbList[idb].dcm[idcm-1].isActive) {
              if (_dbList[idb].hasNoAPDs)
                _dbList[idb].hasNoAPDs = false;
              if (_dbList[idb].dcm[idcm-1].feb[ifeb].hasAPD) continue;
              _dbList[idb].dcm[idcm-1].feb[ifeb].hasAPD = true;
              _dbList[idb].dcm[idcm-1].feb[ifeb].block = atoi(PQgetvalue(res,i,3));
              _dbList[idb].dcm[idcm-1].feb[ifeb].layer = atoi(PQgetvalue(res,i,4));
              _dbList[idb].dcm[idcm-1].feb[ifeb].pos_in_layer = atoi(PQgetvalue(res,i,5));
              _dbList[idb].dcm[idcm-1].nInstrumentedFEBs++;
              _dbList[idb].nInstrumentedFEBs++;
              ++_nInstalledAPDs;
            }
          }
          PQclear(res);
        }
        else {
          std::cerr << __PRETTY_FUNCTION__ << " SQL error, failed query: " << query << std::endl;
          PQclear(res);
          hwTable->CloseConnection();
          return false;
        }
      }

      hwTable->CloseConnection();
      _gotHardwareInfo = true;
      
      return true;
    }

    //**********************************************************************

    bool RunHistory::LoadPedestals()
    {
      if (_runNumber >= 1000000 || _runNumber < 10000) {
        LOG_ERROR("RunHistory") << "Ideal run number not acceptable for this method.  Aborting.";
        std::abort();
      }
      
      if (_gotPedestals) return true;

      if (! LoadDAQRunHistory()) return false;      
      if (! LoadHardwareInfo()) return false;
      if (! LoadFEBMasks()) return false;
      if (! LoadPixelMasks()) return false;
      
      std::unique_ptr<db::Table> t;
      t.reset(new db::Table("RunHistory/tables/PedestalsByRun.xml"));
      
      if (novadaq::cnv::DetInfo::DetNameOk(_detector))
        t->SetDetector(_detector);
      else
        return false;
      
      int pedIdx = t->GetColIndex("ped");

      t->SetDataTypeMask(nova::dbi::kDataOnly);
      t->SetMinTSVld(_runNumber);
      t->SetMaxTSVld(_runNumber);
      t->SetTimeQueries(_timeQueries);
      t->SetTimeParsing(_timeParsing);
      t->SetVerbosity(_verbosity);

      LOG_INFO("RunHistory") << "RunHistory: loading channel pedestals" << std::endl;      

      if (!t->Load()) {
        std::cerr << __PRETTY_FUNCTION__ << "No pedestals found in DB!";
        if(_abort) std::abort();
        return false;
      }
      else {
        if (t->NRow() == 0) {
          LOG_ERROR("RunHistory") << __PRETTY_FUNCTION__ << ": failed to get any rows from database, which should not happen." << std::endl;
          if (_abort) std::abort();
        }
      } 

      t->FillChanRowMap();
      nova::dbi::Row* row;
      //      int nrow = t->NRow();
      int detId = novadaq::cnv::DetInfo::GetId(_detector);
      int16_t ped = 0;
      daqchannelmap::DAQChannelMap* daqcmap = daqchannelmap::DAQChannelMap::getInstance(detId);
      
      for (unsigned int idb=0; idb<_dbList.size(); ++idb) {
        int dbNum = _dbList[idb].num;   
        for (unsigned int idcm=0; idcm<_dbList[idb].dcm.size(); ++idcm) {
          if (! _dbList[idb].dcm[idcm].isActive) continue;
          int dcmNum = _dbList[idb].dcm[idcm].position;
          int nfebs = _dbList[idb].dcm[idcm].feb.size();
          int64_t febmask = _dbList[idb].dcm[idcm].febMask;
          for (int ifeb=0; ifeb<nfebs; ++ifeb) {
            if (!(febmask >> ifeb)&0x1) continue;
            for (int ip=0; ip<32; ++ip) {
              daqchannelmap::dchan daqChan = daqcmap->encodeDChan(detId,dbNum,
                                                                  dcmNum,ifeb,ip);
              daqchannelmap::lchan logChan = daqcmap->encodeLChan(daqChan);
              
              int plane = daqcmap->getPlane(logChan);
              int cell = daqcmap->getCell(logChan);
              geo::OfflineChan chan(plane, cell);
              int tchan = chan.ToDBValidityChan();
              
              row = t->GetVldRow(tchan,_runNumber);
              if (!row) {
                LOG_WARNING("RunHistory") << "No row found for channel " << tchan << std::endl;
                continue;
              }
              row->Col(pedIdx).Get(ped);
              _dbList[idb].dcm[idcm].feb[ifeb].pixelThresh[ip] = ped;
            }
          }
        }       
      }
      LOG_INFO("RunHistory") << "done!" << std::endl;
      
      _gotPedestals = true;
      
      return true;
    }
    
    //**********************************************************************

    int RunHistory::GetPedestal(const geo::OfflineChan& oChan, bool& ok)
    {
      if (!LoadDAQRunHistory()) {
        if (_abort) std::abort();
        return -1;
      }
      if (!LoadHardwareInfo()) {
        if (_abort) std::abort();
        return -1;
      }
      if (!LoadFEBMasks()) {
        if (_abort) std::abort();
        return -1;
      }
      if (!LoadPedestals()) {
        if (_abort) std::abort();
        return -1;
      }

      daqchannelmap::DAQChannelMap* dmap = daqchannelmap::DAQChannelMap::getInstance(_detId);
      daqchannelmap::lchan logChan = dmap->encodeLChan(_detId, oChan.Plane(), oChan.Cell());
      daqchannelmap::dchan daqChan = dmap->encodeDChan(logChan);

      int diblk = int(dmap->getDiBlock(daqChan));
      int dcmId = int(dmap->getDCM(daqChan));
      int ifeb  = int(dmap->getFEB(daqChan));
      int ipix  = int(dmap->getPixel(daqChan));

      int idb = _diblockIndex[diblk];
      if (idb < (int)_dbList.size())
        return _dbList[idb].dcm[dcmId-1].feb[ifeb].pixelThresh[ipix];

      return 0;
    }
    
    //**********************************************************************

    int RunHistory::GetPedestal(const daqchannelmap::dchan& daqChan, bool& ok)
    {
      if (!LoadDAQRunHistory()) {
        if (_abort) std::abort();
        return -1;
      }
      if (!LoadHardwareInfo()) {
        if (_abort) std::abort();
        return -1;
      }
      if (!LoadFEBMasks()) {
        if (_abort) std::abort();
        return -1;
      }
      if (!LoadPixelMasks()) {
        if (_abort) std::abort();
        return -1;
      }
      if (!LoadPedestals()) {
        if (_abort) std::abort();
        return -1;
      }
      
      daqchannelmap::DAQChannelMap* dmap = daqchannelmap::DAQChannelMap::getInstance(_detId);
      
      int diblk = int(dmap->getDiBlock(daqChan));
      int dcmId = int(dmap->getDCM(daqChan));
      int ifeb  = int(dmap->getFEB(daqChan));
      int ipix  = int(dmap->getPixel(daqChan));

      int idb = _diblockIndex[diblk];
      if (idb < (int)_dbList.size())
        return _dbList[idb].dcm[dcmId-1].feb[ifeb].pixelThresh[ipix];

      return 0;

    }
    
    //**********************************************************************

    bool RunHistory::LoadPixelMasks()
    {
      if (_runNumber >= 1000000 || _runNumber < 10000) {
        LOG_ERROR("RunHistory") << "Ideal run number not acceptable for this method.  Aborting.";
        std::abort();
      }
      

      if (_gotPixelMasks) return true;

      if (! LoadDAQRunHistory()) return false;      
      if (! LoadHardwareInfo()) return false;
      if (! LoadFEBMasks()) return false;
      
      std::unique_ptr<db::Table> t;
      t.reset(new db::Table("RunHistory/tables/PixelMasksByRun.xml"));
      
      if (novadaq::cnv::DetInfo::DetNameOk(_detector))
        t->SetDetector(_detector);
      else
        return false;
      
      int maskIdx = t->GetColIndex("mask");

      t->SetDataTypeMask(nova::dbi::kDataOnly);
      t->SetMinTSVld(_runNumber);
      t->SetMaxTSVld(_runNumber);
      t->SetTimeQueries(_timeQueries);
      t->SetTimeParsing(_timeParsing);
      t->SetVerbosity(_verbosity);

      LOG_INFO("RunHistory") << "RunHistory: loading pixel enable masks" << std::endl;      

      if (!t->Load()) {
        std::cerr << __PRETTY_FUNCTION__ << "No pixel masks found in DB!";
        if(_abort) std::abort();
        return false;
      }
      else {
        if (t->NRow() == 0) {
          LOG_ERROR("RunHistory") << __PRETTY_FUNCTION__ << ": failed to get any rows from database, which should not happen." << std::endl;
          if (_abort) std::abort();
        }
      } 

      t->FillChanRowMap();
      nova::dbi::Row* row;
      //      int nrow = t->NRow();
      int detId = novadaq::cnv::DetInfo::GetId(_detector);
      int32_t pMask;
      
      for (unsigned int idb=0; idb<_dbList.size(); ++idb) {
        int dbNum = _dbList[idb].num;   
        for (unsigned int idcm=0; idcm<_dbList[idb].dcm.size(); ++idcm) {
          if (! _dbList[idb].dcm[idcm].isActive) continue;
          int dcmNum = _dbList[idb].dcm[idcm].position;
          int nfebs = _dbList[idb].dcm[idcm].feb.size();
          for (int ifeb=0; ifeb<nfebs; ++ifeb) {
            int tchan = detId*1000000 + 10000*dbNum + 100*dcmNum + ifeb;
            row = t->GetVldRow(tchan,_runNumber);
            if (!row) {
              LOG_WARNING("RunHistory") << "No row found for channel " << tchan << std::endl;
              continue;
            }
            row->Col(maskIdx).Get(pMask);
            _dbList[idb].dcm[idcm].feb[ifeb].pixelMask = pMask;
          }
        }       
      }
      _gotPixelMasks = true;
      
      return true;
    }
  
  //**********************************************************************

    bool RunHistory::LoadFEBMasks()
    {
      if (_gotFEBMasks) return true;

      if (! LoadDAQRunHistory()) return false;      
      if (! LoadHardwareInfo()) return false;
      
      std::unique_ptr<db::Table> t;
      t.reset(new db::Table("RunHistory/tables/FEBMasksByRun.xml"));
      
      if (novadaq::cnv::DetInfo::DetNameOk(_detector))
        t->SetDetector(_detector);
      else
        return false;
      
      int maskIdx = t->GetColIndex("mask");

      t->SetDataTypeMask(nova::dbi::kDataOnly);
      t->SetMinTSVld(_runNumber);
      t->SetMaxTSVld(_runNumber);
      t->SetTimeQueries(_timeQueries);
      t->SetTimeParsing(_timeParsing);
      t->SetVerbosity(_verbosity);

      LOG_INFO("RunHistory") << "RunHistory: loading FEB enable masks" << std::endl;      

      if (!t->Load()) {
        std::cerr << __PRETTY_FUNCTION__ << "No pixel masks found in DB!";
        if(_abort) std::abort();
        return false;
      }
      else {
        if (t->NRow() == 0) {
          LOG_ERROR("RunHistory") << __PRETTY_FUNCTION__ << ": failed to get any rows from database, which should not happen." << std::endl;
          if (_abort) std::abort();
        }
      } 

      t->FillChanRowMap();
      nova::dbi::Row* row;

      //      int nrow = t->NRow();
      int detId = novadaq::cnv::DetInfo::GetId(_detector);
      int64_t pMask;
      
      for (unsigned int idb=0; idb<_dbList.size(); ++idb) {
        int dbNum = _dbList[idb].num;   
        for (unsigned int idcm=0; idcm<_dbList[idb].dcm.size(); ++idcm) {
          if (! _dbList[idb].dcm[idcm].isActive) continue;
          int dcmNum = _dbList[idb].dcm[idcm].position;
          int tchan = detId*1000000 + 10000*dbNum + 100*dcmNum;
          row = t->GetVldRow(tchan,_runNumber);
          if (!row) {
            LOG_WARNING("RunHistory") << "No row found for channel " << tchan << std::endl;
            continue;
          }
          row->Col(maskIdx).Get(pMask);
          _dbList[idb].dcm[idcm].febMask = pMask;
        }       
      }
      _gotFEBMasks = true;
      
      return true;
      
    }
    
  //**********************************************************************

    bool RunHistory::LoadFEBMasksFromDAQDB()
    {
      if (_gotPixelInfo) return true;
      if (_gotFEBMasks) return true;
      
      if (! LoadDAQRunHistory()) return false;      
      if (! LoadHardwareInfo()) return false;

      _nTotalChannels=0;
      _nTotalFEBs=0;

      char daqEnv[128];
      sprintf(daqEnv,"NOVADAQ_ENVIRONMENT=%s",_detector.c_str());
      putenv(daqEnv);

      std::vector<std::string> tmpDCMList;
      for (unsigned int i=0; i<_dbList.size(); ++i)
        for (unsigned int j=0; j < _dbList[i].dcm.size(); ++j) {
          if (_dbList[i].dcm[j].isActive)
            tmpDCMList.push_back(_dbList[i].dcm[j].appname);
        }
      
      //TStopwatch ts;
      //ts.Start();
      LOG_INFO("RunHistory") << "RunHistory: loading pixel enable masks" << std::endl;
      daqcfg::PixelEnableMasks pixelEnableMasks(_gCfgId, tmpDCMList);

      bool hasValidData = pixelEnableMasks.hasValidData();      
      if (hasValidData) {
        for (unsigned int idb=0; idb<_dbList.size(); ++idb) {
          for (unsigned int idcm=0; idcm<_dbList[idb].dcm.size(); ++idcm) {
            if (! _dbList[idb].dcm[idcm].isActive) continue;
            
            std::string dcmName = _dbList[idb].dcm[idcm].appname;
            int64_t febMask = 0;
            pixelEnableMasks.getFEBEnableMask(dcmName, febMask);
            _dbList[idb].dcm[idcm].febMask = febMask;
          }
        }
      }
      else {
        return false;
      }
      
      _gotFEBMasks = true;
      return true;
    }
      
  //**********************************************************************

    bool RunHistory::LoadPixelInfo(int nAttempt)
    {
      if (nAttempt > _nRetryLoads) {
        std::cerr << __PRETTY_FUNCTION__ << " giving up!"
                  << std::endl;
        return false;
      }

      if (_gotPixelInfo) return true;

      if (! LoadDAQRunHistory()) return false;      
      if (! LoadHardwareInfo()) return false;

      _nTotalChannels=0;
      _nTotalFEBs=0;

      char daqEnv[128];
      sprintf(daqEnv,"NOVADAQ_ENVIRONMENT=%s",_detector.c_str());
      putenv(daqEnv);

      std::vector<std::string> tmpDCMList;
      for (unsigned int i=0; i<_dbList.size(); ++i)
        for (unsigned int j=0; j < _dbList[i].dcm.size(); ++j) {
          if (_dbList[i].dcm[j].isActive)
            tmpDCMList.push_back(_dbList[i].dcm[j].appname);
        }
      
      //TStopwatch ts;
      //ts.Start();
      LOG_INFO("RunHistory") << "RunHistory: loading pixel enable masks" << std::endl;
      daqcfg::PixelEnableMasks pixelEnableMasks(_gCfgId, tmpDCMList);
      LOG_INFO("RunHistory") << "RunHistory: loading pixel thresholds" << std::endl;
      daqcfg::PixelThresholds pixelThresholds(_gCfgId, tmpDCMList);
      LOG_INFO("RunHistory") << "done!" << std::endl;
      //ts.Stop();
      //ts.Print();

      bool hasValidData = (pixelEnableMasks.hasValidData() &&
                           pixelThresholds.hasValidData());
      
      if (hasValidData) {
        for (unsigned int idb=0; idb<_dbList.size(); ++idb) {
          for (unsigned int idcm=0; idcm<_dbList[idb].dcm.size(); ++idcm) {
            if (! _dbList[idb].dcm[idcm].isActive) continue;

            std::string dcmName = _dbList[idb].dcm[idcm].appname;
            int64_t febMask = 0;
            pixelEnableMasks.getFEBEnableMask(dcmName, febMask);
            _dbList[idb].dcm[idcm].febMask = febMask;
            int nfeb = _dbList[idb].dcm[idcm].feb.size();
            for (int ifeb = 0; ifeb < nfeb; ++ifeb) {
              if (pixelEnableMasks.febIsEnabled(dcmName, ifeb)) {
                _nTotalChannels += 32;
                ++_nTotalFEBs;
                
                FEB& f = _dbList[idb].dcm[idcm].feb[ifeb];
                f.isEnabled = true;
                int32_t pixelMask;
                pixelEnableMasks.getPixelEnableMask(dcmName, ifeb, pixelMask);
                f.pixelMask = pixelMask;
                f.nActivePix = pixelEnableMasks.
                  getEnabledPixelCountForFEB(dcmName, ifeb);
                if (pixelThresholds.hasValidData())
                  pixelThresholds.getThresholdsForFEB(dcmName, ifeb,
                                                      f.pixelThresh);
              } // end if (febIsEnabled)
            } // end loop over FEBs
          } // end loop over DCMs
        } // end loop over DiBlocks
      } // end if hasValidData
      else {
        std::cerr << __PRETTY_FUNCTION__ << " failed to get valid data"
                  << std::endl;
        if (_nRetryLoads > 0) {
          int sleepTime = 1 + ((double)random()/(double)RAND_MAX)*(1 << nAttempt++);
          sleep(sleepTime);
          return this->LoadPixelInfo(nAttempt+1);
        }
        else {
          return false;
        }
      }
      
      _gotPixelInfo = true;
      
      return true;
    }

    //**********************************************************************
    bool RunHistory::LoadCoolingInfo()
    {
      if (_gotCoolingInfo) return true;

      /*
      if (!_gotDAQRunHistory) {
        if (!LoadDAQRunHistory()) return false;
      }
      */

      return false;
    }

    //**********************************************************************

    int RunHistory::DetGainSetting()
    {
      if (!_detGainSetting) {
        std::unique_ptr<db::Table> t;
        t.reset(new db::Table("RunHistory/tables/GainSetting.xml"));
        
        if (novadaq::cnv::DetInfo::DetNameOk(_detector))
          t->SetDetector(_detector);
        else
          return 0;
        
        int gainIdx = t->GetColIndex("gain");

        t->SetDataTypeMask(nova::dbi::kMCOnly|nova::dbi::kDataOnly);
        t->SetTag(_detGainTag);
        t->SetMinTSVld(_runNumber);
        t->SetMaxTSVld(_runNumber);
        t->SetTimeQueries(_timeQueries);
        t->SetTimeParsing(_timeParsing);
        t->SetVerbosity(_verbosity);
        if (!t->Load()) {
          std::cerr << __PRETTY_FUNCTION__ << "No gain setting found in DB!";
          if(_abort) std::abort();      
          LOG_WARNING("RunHistory") << "WARNING: RunHistory::DetGainSetting(): No detector gain setting\n"
              " info found for run " << _runNumber << ", so setting gain to 1";
          _detGainSetting = 1;
          // get from the dB
        }
        else {
          if (t->NRow() != 1) {
            LOG_ERROR("RunHistory") << __PRETTY_FUNCTION__ << ": failed to get 1 row from database.  Aborting." << std::endl;
            abort();
          }
          t->GetRow(0)->Col(gainIdx).Get(_detGainSetting);              
          LOG_INFO("RunHistory") << "Gain setting for run " << _runNumber
                    << " is " << _detGainSetting << std::endl;
        }
      }

      return _detGainSetting;
    }

    //**********************************************************************

    bool RunHistory::DetFineTimingSetting() const
    {
      // TODO. This really should be implemented by a database table like
      // DetGainSetting, but this is the best that can be done on short notice.

      // ND has always been fine-timing in any runs used for physics
      if(_detId != novadaq::cnv::kFARDET) return true;

      // FD switched at some point and never switched back. Ideal conditions
      // runs up at high run numbers are all fine timing. We use magic number
      // up there for gains, but so far not for timing. If that ever changes
      // will have to add more logic here.

      // https://cdcvs.fnal.gov/redmine/projects/novawatchdog/wiki/Far_Detector
      return _runNumber >= 17212;
    }

    //**********************************************************************

    bool RunHistory::LoadAPDSettings()
    {
      if (_gotAPDSettings) return true;
      
      if (!LoadDAQRunHistory()) return false;

      if (!LoadHardwareInfo()) return false;

      std::vector<std::string> tmpDCMList;
      for (unsigned int idb=0; idb<_dbList.size(); ++idb)
        for (unsigned int idcm=0; idcm<_dbList[idb].dcm.size(); ++idcm)
          if (_dbList[idb].dcm[idcm].isActive)
            tmpDCMList.push_back(_dbList[idb].dcm[idcm].appname);
      
      char daqEnv[128];
      sprintf(daqEnv,"NOVADAQ_ENVIRONMENT=%s",_detector.c_str());
      putenv(daqEnv);
      
      dcscfg::APDSettings apdSettings(_gCfgId, tmpDCMList);
      
      for (unsigned int idb=0; idb < _dbList.size(); ++idb) {
        for (unsigned int idcm = 0; idcm < _dbList[idb].dcm.size(); ++idcm) {
          if (! _dbList[idb].dcm[idcm].isActive) continue;
          std::string dcmName = _dbList[idb].dcm[idcm].appname;
          for (int ifeb = 0; ifeb < 64; ++ifeb) {
            FEB& f = _dbList[idb].dcm[idcm].feb[ifeb];
            apdSettings.getTemperatureEnable(dcmName,ifeb,f.tempEnabled);
            double temp;
            apdSettings.getTemperature      (dcmName,ifeb,temp);
            f.temperature = temp;
            apdSettings.getVoltage          (dcmName,ifeb,f.apdV);
            //      apdSettings.getCoolingEnableFlag(dcmName,ifeb,f.isCooled);
          }
        }
      }
      
      // now get the gains

      int detId = novadaq::cnv::DetInfo::GetId(_detector);

      if (detId == novadaq::cnv::kFARDET) {
        
        // get a map of the hardware locations to the installed APDs and FEBs
        this->MapHardwareToLocation();
        
        _nInstalledAPDs = gLocToFA.size();
        
        // loop over the gLocToFA map to fill the necessary information
        for(auto const& locitr : gLocToFA){
          
          auto const& hl  = locitr.first;
          auto const& apd = locitr.second.second;

          if(hl._diblock > _dbList.size() ) continue;
          for (unsigned int idb=0; idb<_dbList.size(); ++idb) {
            if (_dbList[idb].num == (int)hl._diblock) {
              
              if(_dbList[idb].dcm[hl._dcm-1].isActive) {
                if(!_dbList[idb].dcm[hl._dcm-1].feb[hl._feb].hasAPD)
                  continue;
                
                auto pixGain = apd._pixelGain;
                float avGain = 0.;
                float pGain  = 0.;
                for(size_t p = 0; p < pixGain.size(); ++p){
                  pGain = pixGain.at(p);
                  _dbList[idb].dcm[hl._dcm-1].feb[hl._feb].pixelGain.at(p) = pGain;
                  avGain += pGain;
                }
                avGain /= 32.;
                _dbList[idb].dcm[hl._dcm-1].feb[hl._feb].gain = avGain;
              
                if(std::abs(100. - avGain) > 10.){
                  LOG_WARNING("RunHistory") << "average gain for APD "
                                            << apd._sn
                                            << " connected to "
                                            << "dcm-2-" << hl._diblock
                                            << "-"      << hl._dcm
                                            << "-"      << hl._feb
                                            << " is "   << avGain
                                            << " : 100 expected so default to that";
                  _dbList[idb].dcm[hl._dcm-1].feb[hl._feb].gain = 100.;
                  for(size_t p = 0; p < pixGain.size(); ++p)
                    _dbList[idb].dcm[hl._dcm-1].feb[hl._feb].pixelGain.at(p) = 100.;
                }
              }
            }
          } // end if the dcm is active
        } // end loop over location map
      } // end if far detector
      
      _gotAPDSettings = true;
      
      return true;
    }

    //**********************************************************************
    int RunHistory::GoodDiBlockMask(int subrun, bool reload)
    {
      if(reload)
        _gotGoodDiBlockMask=false;
      LoadGoodDiBlockMask();
      
      if (!_getDiBlockMaskFromCondb)
        subrun = 0;
      else {
        if (subrun < 0 || subrun > 63) {
          if (subrun > 63)
            LOG_WARNING("RunHistory") << __PRETTY_FUNCTION__ << " invalid subrun " << subrun << ".  Converted to subrun " << subrun << std::endl;
          subrun = _currentSR;
        }
        
      }
      
      return _subrunList[subrun].goodDiBlockMask;
    }
    
    //**********************************************************************
    bool RunHistory::IsGoodDiBlock(int idb, int subrun)
    {
      
      ///< Is diblock kept when applying mask?  Generally don't use this, just ask for HasAPD (for a channel) or for nInstrumentedFEBs (in a DCM or Diblock) and any mask asked for will already be applied.  Always returns good if masking turned off.  Diblock number argument 1-14
      if(!_useMasking) return true;
      
      LoadGoodDiBlockMask();
      if (idb < 1) return false;

      if (!_getDiBlockMaskFromCondb)
        subrun = 0;
      else {
        if (subrun < 0 || subrun > 63) {
          if (subrun>63)
            LOG_WARNING("RunHistory") << __PRETTY_FUNCTION__ << " invalid subrun " << subrun << ".  Converted to subrun " << subrun << std::endl;
          subrun = _currentSR;
        }
        
      }
      
      return ((_subrunList[subrun].goodDiBlockMask >> (idb-1))&0x1);
    }


    //**********************************************************************

    bool RunHistory::LoadDataEpoch()
    {
      if (_gotDataEpoch) return true;

      std::unique_ptr<db::Table> t;
      t.reset(new db::Table("RunHistory/tables/DataEpochs.xml"));

      if (novadaq::cnv::DetInfo::DetNameOk(_detector))
        t->SetDetector(_detector);
      else
        return false;
      
      int nameIdx = t->GetColIndex("name");
      int rstartIdx = t->GetColIndex("run_start");
      int rendIdx = t->GetColIndex("run_end");

      t->SetVerbosity(_verbosity);
      t->SetTimeQueries(_timeQueries);
      t->SetTimeParsing(_timeParsing);

      bool loadFailed = false;

      // exclude these columns in case of formatting issues (,\', etc.)
      if (! t->Load()) loadFailed = true;

      if (loadFailed) {
        LOG_ERROR("RunHistory") << "Loading of data epoch info from database failed." << std::endl;
        return false;
      }
      
      int nRow = t->NRow();
      int runStart = 0;
      int runEnd = 0;

      for (int i=0; i<nRow; ++i) {
        t->GetRow(i)->Col(rstartIdx).Get(runStart);
        if (! t->GetRow(i)->Col(rendIdx).Get(runEnd)) 
          runEnd = 0;
        if (_runNumber >= runStart && (_runNumber <= runEnd || runEnd==0 )) {
          _dataEpoch.run_start = runStart;
          _dataEpoch.run_end = runEnd;
          t->GetRow(i)->Col(nameIdx).Get(_dataEpoch.name);
          _gotDataEpoch = true;
          break;
        }
      }

      if (!_gotDataEpoch) {
        LOG_ERROR("RunHistory") << "Failed to find data epoch in the database!" << std::endl;
        _gotDataEpoch = true;
        return false;
      }
      
      _gotDataEpoch = true;
      return true;
    }
    
    //**********************************************************************

    bool RunHistory::LoadGoodDiBlockMask()
    {
      if (_gotGoodDiBlockMask) return true;

      //      if (!LoadDAQRunHistory()) return false;

      if(_useMasking==false) {  // if masking is turned off, set the mask so the CAFs see this
        _subrunList[0].goodDiBlockMask = (1<<17)-1;
        _gotGoodDiBlockMask = true;
        return true;
      }

      int detId = novadaq::cnv::DetInfo::GetId(_detector);

      if(detId==novadaq::cnv::kNEARDET) {  // switch masking off for ND for now
        _useMasking = false;
        _gotGoodDiBlockMask = true;
        return true;
      }

      if(_customMasking && detId==novadaq::cnv::kFARDET) {
        for (int isr=0; isr<64; ++isr)
          _subrunList[isr].goodDiBlockMask = _customMask;
        _gotGoodDiBlockMask = true;
        LOG_INFO("RunHistory") <<  __PRETTY_FUNCTION__ << "Applying custom mask: " << DiBlockMaskToString(_subrunList[0].goodDiBlockMask) << std::endl;
        return true;
      }

      if(_runNumber >= 1000000 || _runNumber < 10000) {  // for MC-like run numbers, leave these with no mask.  no need to access DB and cause crashes in MC sim or old ideal MC
        _useMasking = false;    
        _subrunList[0].goodDiBlockMask = (1<<17)-1;
        for (int isr=1; isr<64; ++isr)
          _subrunList[isr].goodDiBlockMask = _subrunList[0].goodDiBlockMask;
        _gotGoodDiBlockMask = true;
        return true;
      }

      bool fallback = false;

      std::unique_ptr<db::Table> t;

      if (_getDiBlockMaskFromCondb) 
        t.reset(new db::Table("RunHistory/tables/DQValidity.xml"));
      else
        t.reset(new db::Table("RunHistory/tables/GoodDiBlocksVsRun.xml"));

      if (novadaq::cnv::DetInfo::DetNameOk(_detector))
        t->SetDetector(_detector);
      else
        return false;

      int maskIdx = t->GetColIndex("dbmask");
      t->SetVerbosity(_verbosity);
      t->SetTimeQueries(_timeQueries);
      t->SetTimeParsing(_timeParsing);

      if (!_getDiBlockMaskFromCondb) {
        t->SetValidityRange("run",_runNumber);
        t->AddOrderColumn("inserttime");
        t->SetOrderDesc();
      }
      else {
        t->SetTag(_dbMaskTag);
        t->SetMinTSVld(_runNumber*100);
        t->SetMaxTSVld((_runNumber+1)*100-1);
        t->SetDataTypeMask(nova::dbi::kDataOnly);
        t->AddExcludeCol(std::string("comment"));
        t->AddExcludeCol(std::string("flag"));
        t->AddExcludeCol(std::string("miprate"));
        t->AddExcludeCol(std::string("ngooddb"));
        t->AddExcludeCol(std::string("numslc"));
        t->AddExcludeCol(std::string("trkfrac"));
      }
      bool loadFailed = false;

      // exclude these columns in case of formatting issues (,\', etc.)
      if (! t->Load()) loadFailed = true;

      if (loadFailed || t->NRow() == 0) {
        std::cerr << __PRETTY_FUNCTION__ << "No mask found in DB!";
        if(_abort) std::abort();        
        LOG_WARNING("RunHistory") << __PRETTY_FUNCTION__ << ": RunHistory::LoadGoodDiBlockMask(): No good diblock mask";
        LOG_WARNING("RunHistory") << " info found for run " << _runNumber << ", so assuming all";
        LOG_WARNING("RunHistory") << " good diblocks" << std::endl;
        fallback = true;
        // use a wide open mask; added benefit: the mask will appear in CAF files downstream as unphysical
      }
      else {
        if (!_getDiBlockMaskFromCondb) {
          t->GetRow(0)->Col(maskIdx).Get(_subrunList[0].goodDiBlockMask);
          for (size_t isr=1; isr<64; ++isr)
            _subrunList[isr].goodDiBlockMask = _subrunList[0].goodDiBlockMask;
        }
        else {
          t->FillChanRowMap();
          int tmask;
          for (int isr=0; isr<64; ++isr) {
            int tvld = _runNumber*100+isr;
            nova::dbi::Row* row = t->GetVldRow(0,tvld);
            row->Col(maskIdx).Get(tmask);
            _subrunList[isr].goodDiBlockMask = tmask;
          }
        }       
      }

      // if asked for in the .fcl, modify the mask to meet analysis requirements
      // (far det only, and only if we found a real mask to begin with)
      if ( _analysisDiBlockMasking && detId==novadaq::cnv::kFARDET && !fallback) {
        LOG_DEBUG("RunHistory") <<  __PRETTY_FUNCTION__ << ": Applying analysis diblock masking: ";
        for (int isr=0; isr<64; ++isr) {
          int newMask = ApplyAnalysisDiBlockMask(_subrunList[isr].goodDiBlockMask);
          if (newMask==_subrunList[isr].goodDiBlockMask) {
            LOG_DEBUG("RunHistory") << "mask [" << isr << "] unchanged from " << 
              DiBlockMaskToString(_subrunList[isr].goodDiBlockMask) << std::endl;
          }
          else {
            LOG_INFO("RunHistory") << "mask [" << isr << "] modified from "
                      << DiBlockMaskToString(_subrunList[isr].goodDiBlockMask) 
                      << " to "
                      << DiBlockMaskToString(newMask) << std::endl;
          }
          _subrunList[isr].goodDiBlockMask = newMask;
          
          if (!_subrunList[isr].goodDiBlockMask) {
            LOG_ERROR("RunHistory") <<  __PRETTY_FUNCTION__ << "WARNING: entire detector masked off by analysis requirements!" << std::endl;
            LOG_ERROR("RunHistory") << __PRETTY_FUNCTION__ << "No analyzable detector region found for run " << _runNumber << ", subrun " << isr << std::endl;
            //// Not returning here, as this return value doesn't seem to be trapped by the invokers, so best
            //// to let the code fail gracefully downstream when it sees no hits.
            // return false;
          }
        }
      }
      
      _gotGoodDiBlockMask = true;
      
      return true;
    }
    
    //**********************************************************************

    int RunHistory::GetConfiguration()
    {
      LoadHardwareInfo();
      int detId = novadaq::cnv::DetInfo::GetId(_detector);
      if(detId==novadaq::cnv::kNEARDET) {
        bool diblocks[4] = {0};
        int config = 0;
        for(unsigned int i = 0; i < _dbList.size(); i++) {
          if(_dbList[i].nInstrumentedFEBs>=175 && i < 3) diblocks[_dbList[i].num-1] = true;
          if(_dbList[i].nInstrumentedFEBs>=45 && i == 3) diblocks[_dbList[i].num-1] = true;
        }
        for(int i = 0; i < 4; i++) {
          if(diblocks[i]) config+=1<<i;
        }
        return config;
      }
      if(detId==novadaq::cnv::kFARDET) {
        bool diblocks[14] = {0};
        int config = 0;
        for(unsigned int i = 0; i < _dbList.size(); i++) {
          if(_dbList[i].nInstrumentedFEBs>=700) diblocks[_dbList[i].num-1] = true;
        }
        for(int i = 0; i < 14; i++) {
          if(diblocks[i]) config+=1<<i;
        }
        return config;
      }
      return 0;
    }
    //**********************************************************************

    // For diagnostics and status messages, convert the diblock mask into
    // a human-readable string.
    std::string RunHistory::DiBlockMaskToString(const int mask) const
    {
      std::string answer = "";
      for (int iD=0;iD<14;iD++) {
        if (mask&(1<<(iD))) {
          answer += "#";
        }
        else {
          answer += "-";
        }
      }
      return answer;
    }

    //**********************************************************************

    // Apply the analysis masking to an input raw mask.
    // 4/04/17 switched function from strict FA rules to looser SA rules
    // FA style: Keeps the largest contiguous region of 4 or more diblocks, and keeps
    // the most downstream region if there is a tie for largest.
    // Current style:  Keep ALL contiguous regions of 4 or more diblocks
    int RunHistory::ApplyAnalysisDiBlockMask(const int mask) const
    {

      // for convenience and clarity below, define dib[]...
      const int NUMDIB = 14;
      bool dib[NUMDIB];
      for (int iD=0;iD<NUMDIB;iD++) {
        dib[iD] = (mask&(1<<iD));
      }

      int answer = 0;
      int partial_answer = 0;
      int iStart = -1;
      for (int iD=0;iD<NUMDIB;iD++) {

        if (iStart<0&&dib[iD]) {
          // starting a string of diblocks
          iStart = iD;
        }

        if (iStart>=0&&dib[iD]) {
          // contributes to partial_answer
          partial_answer += (1<<iD);
        }

        if (iStart>=0&&(!dib[iD]||iD==NUMDIB-1)) {
          // just left a string of diblocks, or at last diblock
          int curr_size = iD-iStart;
          if (dib[iD]&&iD==NUMDIB-1) curr_size++;
          if (curr_size>=4) {
            // okay to keep
            answer += partial_answer;
          }
          iStart = -1;
          partial_answer = 0;
        }

      } // iD

      return answer;
    }

    //**********************************************************************

    bool RunHistory::LoadPOT()
    {
      if (_gotPOT) return true;

      _npot = 0.;

      std::unique_ptr<db::Table> potTable;

      potTable.reset(new db::Table("RunHistory/tables/POTByRun.xml"));

      if (novadaq::cnv::DetInfo::DetNameOk(_detector))
        potTable->SetDetector(_detector);
      else
        return false;

      int potIdx = potTable->GetColIndex("npot");
      int avgIdx = potTable->GetColIndex("avg_i");
      potTable->SetTimeQueries(_timeQueries);
      potTable->SetTimeParsing(_timeParsing);
      potTable->SetVerbosity(_verbosity);
      
      potTable->SetValidityRange("run",_runNumber);
      potTable->Load();
      if (potTable->NRow() == 0) {
        std::cerr << __PRETTY_FUNCTION__ << " No POT info found for run " 
                  << _runNumber << std::endl;
        return false;
      }
      else {
        potTable->GetRow(0)->Col(potIdx).Get(_npot);
        potTable->GetRow(0)->Col(avgIdx).Get(_avgpot);
      }

      _gotPOT = true;
      return true;

    }

    //**********************************************************************

    bool RunHistory::LoadDAQRunHistory()
    {
      if (_gotDAQRunHistory) return true;
      
      if (_failedToFindRun) {
       if (_abortIfMissingRunInDB){ 
          LOG_ERROR("RunHistory")<<"LoadDAQRunHistory: failed to find the run in the runs table." << std::endl;
          std::abort();
           }
       else std::cerr <<  __PRETTY_FUNCTION__ << " failed to find the run in the runs table." << std::endl;
             return false;

           }

      if(_runNumber >= 1000000 || _runNumber < 10000) {  // it's MC - assume perfect + mask
        LOG_INFO("RunHistory") << "Looks like a MC run number - assume perfect + any mask" << std::endl;
        _isMC = true;
        BuildMC();
        return true;
      }

      _nDCMs = 0;

      std::unique_ptr<db::Table> runsTable;
      std::unique_ptr<db::Table> resTable;
      std::unique_ptr<db::Table> srTable;

      runsTable.reset(new db::Table("RunHistory/tables/Runs.xml"));
      srTable.reset(new db::Table("RunHistory/tables/Subruns.xml"));
      resTable.reset(new db::Table("RunHistory/tables/DAQResourcesByRun.xml"));
      runsTable->SetTimeQueries(_timeQueries);
      runsTable->SetTimeParsing(_timeParsing);
      srTable->SetTimeQueries(_timeQueries);
      srTable->SetTimeParsing(_timeParsing);
      resTable->SetTimeQueries(_timeQueries);
      resTable->SetTimeParsing(_timeParsing);
      resTable->SetVerbosity(100);

      if (novadaq::cnv::DetInfo::DetNameOk(_detector)) {
        runsTable->SetDetector(_detector);
        srTable->SetDetector(_detector);
        resTable->SetDetector(_detector);
      }
      else {
        LOG_ERROR("RunHistory")<<"RunHistory::LoadDAQRun: invalid detector name!"<<std::endl;
        std::abort();                                              

      }
      
      runsTable->SetSubSchema("daq");
      runsTable->SetValidityRange("run",_runNumber);
      runsTable->AddExcludeCol(std::string("nevents"));
      runsTable->AddExcludeCol(std::string("begin_comment"));
      runsTable->AddExcludeCol(std::string("end_comment"));
      runsTable->AddExcludeCol(std::string("shifter"));
      runsTable->SetVerbosity(_verbosity);
      if (!runsTable->Load()){
        LOG_ERROR("RunHistory")<<"LoadDAQRunHistory: failed to load the runs table." << std::endl;
        if(_detector=="TestBeam" && _abort) std::abort();
        else if (_detector!="TestBeam") std::abort();
      }
        
      if (runsTable->NRow() == 0) {
        std::cerr << __PRETTY_FUNCTION__ << " no entry found the runs table!" << std::endl;
        _failedToFindRun = true;
        return false;
      }
      db::Row* row = runsTable->GetRow(0);
      if (row) {
        std::string timeStr;
        if (row->Col(runsTable->GetColIndex("tstart")).Get(timeStr)) _tStart = timeStr;
        if (row->Col(runsTable->GetColIndex("tstop")).Get(timeStr)) _tEnd = timeStr;
        //        row->Col(runsTable->GetColIndex("nevents")).Get(_nTotTrig);
        row->Col(runsTable->GetColIndex("configid")).Get(_gCfgId);
        row->Col(runsTable->GetColIndex("nsubruns")).Get(_nsubrun);
        row->Col(runsTable->GetColIndex("nactivechan")).Get(_nActiveChannels);
        row->Col(runsTable->GetColIndex("partition")).Get(_partition);
        row->Col(runsTable->GetColIndex("runtype")).Get(_runType);
      }

      // Load subrun information
      /*
      srTable->SetSubSchema("daq");
      srTable->SetValidityRange("run",_runNumber);
      srTable->Load();
      std::cout << srTable->NRow() << std::endl;
      std::cout << "_nsubrun = " << _nsubrun << std::endl;
      */
      /*
      if (srTable->NRow() == _nsubrun-1) {
        int srnum;      
        std::string tstr1, tstr2;

        int numIdx = srTable->GetColIndex("subrun");
        int tstartIdx = srTable->GetColIndex("tstart");
        int tstopIdx = srTable->GetColIndex("tstop");

        for (int irow=0; irow<_nsubrun-1; ++irow) {
          row = srTable->GetRow(irow);
          if (row->Col(numIdx).Get(srnum) &&
              row->Col(tstartIdx).Get(tstr1) &&
              row->Col(tstopIdx).Get(tstr2)) {
            std::cout << srnum << ", " << tstr1 << ", " << tstr2 << std::endl;
            nova::dbi::Util::TimeAsStringToTime_t(tstr1,_subrunList[srnum].tstart);
            nova::dbi::Util::TimeAsStringToTime_t(tstr2,_subrunList[srnum].tstop);
          }
        }
      }
      */

      resTable->SetSubSchema("daq");
      resTable->SetValidityRange("run",_runNumber);
      resTable->AddOrderColumn("appname");
      resTable->SetVerbosity(_verbosity);
      if (!resTable->Load()) 
       {
         LOG_ERROR("RunHistory")<<"LoadDAQRunHistory: failed to load the resources table." << std::endl;
        std::abort();
       }

      
      int nResources = resTable->NRow();
      if (nResources == 0){
       LOG_ERROR("RunHistory")<<"LoadDAQRunHistory: no resources found for run " << _runNumber << std::endl;
        std::abort(); 
        }

      int rtIdx = resTable->GetColIndex("resource_type");
      int anIdx = resTable->GetColIndex("appname");
      int detIdx = resTable->GetColIndex("detector");

      int detId = novadaq::cnv::DetInfo::GetId(_detector);

      for (int i=0; i<nResources; ++i) {
        row = resTable->GetRow(i);
        std::string rtype;
        std::string appname;
        std::string detector;
        if (row->Col(rtIdx).Get(rtype)) {
          row->Col(detIdx).Get(detector);
          if(detId == novadaq::cnv::kFARDET&&detector!="FarDet") continue;
          if(detId == novadaq::cnv::kNEARDET&&detector!="NearDet") continue;
          if (rtype == "bnevb") {
            BNEVB b;
            row->Col(anIdx).Get(appname);
            b.appname = appname;
            _bnevbList.push_back(b);
          }
          else if (rtype == "dcm") {
            row->Col(anIdx).Get(appname);
            bool foundDiBlock = false;
            short dbnum = atoi(appname.substr(6,2).c_str());
            short pos = atoi(appname.substr(9,2).c_str());
            _nDCMs++;
            /*
              JMP, 2015-11-03: this is strange logic, and created an infinite loop,
              since IsGoodDiBlock requires loading the DAQRunHistory.  Removing.
            if(_useMasking && IsGoodDiBlock(int(dbnum))==false) {
              continue; // ignore masked diblocks
            }
            */
            
            for (unsigned int idb=0; idb < _dbList.size(); ++idb) {
              if (_dbList[idb].num == dbnum) {
                _dbList[idb].dcm[pos-1].appname = appname;
                _dbList[idb].dcm[pos-1].position = pos;
                _dbList[idb].dcm[pos-1].diblock = dbnum;
                _dbList[idb].dcm[pos-1].isActive = true;
                _dbList[idb].dcm[pos-1].feb.resize(64);
                _dbList[idb].dcm[pos-1].nInstrumentedFEBs = 0;
                foundDiBlock = true;
                break;
              }
            }
            if (!foundDiBlock) {
              // diblock does not yet exist, build it
              unsigned int ndcms=12;
              if (detId == novadaq::cnv::kNEARDET)
                ndcms=4;
              DiBlock db(ndcms);
              db.num = dbnum;
              _diblockIndex[dbnum] = _dbList.size();
              db.hasNoAPDs = true;
              db.nInstrumentedFEBs = 0;
              DCM d;
              d.appname = appname;
              d.diblock = dbnum;
              d.position = pos;
              d.isActive = true;
              d.feb.resize(64);
              d.nInstrumentedFEBs = 0;
              db.dcm[d.position-1] = d;

              _dbList.push_back(db);
            }
          }
        }
      }
      std::sort(_dbList.begin(), _dbList.end(), SortDiBlocks);
      for (size_t i=0; i<_dbList.size(); ++i)
        _diblockIndex[_dbList[i].num] = i;
      
      
      _gotDAQRunHistory = true;
      return true;
    }

    //**********************************************************************

    RunHistory::DiBlock RunHistory::GetDiBlock(int i, bool loadAll)
    { 
      LoadHardwareInfo();
      if (i >= int(_dbList.size())) {
        LOG_ERROR("RunHistory")<<"RunHistory::GetDiBlock: invalid diblock!"<<std::endl;
        std::abort();
      }
      if (loadAll) LoadAllDetInfo(); 
      return _dbList[i]; 
    }

    //**********************************************************************
    bool RunHistory::HasAPD(const daqchannelmap::dchan& daqChan)
    {
      if (! _gotHardwareInfo)
        LoadHardwareInfo();

      daqchannelmap::DAQChannelMap* daqcmap = daqchannelmap::DAQChannelMap::getInstance(_detId);
      daqchannelmap::diblock_t diblk = daqcmap->getDiBlock(daqChan);
      daqchannelmap::dcm_id_t  dcmId = daqcmap->getDCM(daqChan);
      daqchannelmap::feb_t      ifeb = daqcmap->getFEB(daqChan);

      if(_runNumber >= 1000000 || _runNumber < 10000) {  // it's MC - assume perfect + mask
        if(_useMasking) {if(IsGoodDiBlock(diblk)) return true;}
        else return true;
      }

      else {
        for (unsigned int i=0; i<_dbList.size(); ++i)
          if (_dbList[i].num == (short)diblk) {
            if (_dbList[i].hasNoAPDs) return false;
            if (_useMasking && IsGoodDiBlock(diblk)==false) return false;
            if (! _dbList[i].dcm[dcmId-1].isActive)
              return false;
            else
              return _dbList[i].dcm[dcmId-1].feb[ifeb].hasAPD;
          }
      }
      return false;
    }

    //**********************************************************************
    bool RunHistory::HasAPD(const geo::OfflineChan& oChan)
    {
      daqchannelmap::DAQChannelMap* dmap = daqchannelmap::DAQChannelMap::getInstance(_detId);
      daqchannelmap::lchan logChan = dmap->encodeLChan(_detId, oChan.Plane(), oChan.Cell());
      daqchannelmap::dchan daqChan = dmap->encodeDChan(logChan);

      return HasAPD(daqChan);

    }

    //**********************************************************************

    bool RunHistory::IsDiBlockFullyInstrumented(int idb)
    {
      LoadHardwareInfo();

      int detId = novadaq::cnv::DetInfo::GetId(_detector);

      for (unsigned int i=0; i<_dbList.size(); ++i) {
        if (_dbList[i].num == idb) {
          if (detId==novadaq::cnv::kFARDET && _dbList[i].nInstrumentedFEBs >= 700) return true;
          if (detId==novadaq::cnv::kNEARDET && idb < 4 && _dbList[i].nInstrumentedFEBs >= 175) return true;
          if (detId==novadaq::cnv::kNEARDET && idb == 4 && _dbList[i].nInstrumentedFEBs >= 45) return true;
          return false;
        }
      }

      return false;

    }

    //**********************************************************************
    bool RunHistory::IsCooled(const daqchannelmap::dchan& daqChan)
    {
      std::cerr << __PRETTY_FUNCTION__ << " is not yet implemented!" 
                << std::endl;

      bool iscooled = false;

      if (!LoadPixelInfo()) return false;
      
      daqchannelmap::DAQChannelMap* dmap  = daqchannelmap::DAQChannelMap::getInstance(_detId);
      daqchannelmap::diblock_t      diblk = dmap->getDiBlock(daqChan);
      daqchannelmap::dcm_id_t       dcmId = dmap->getDCM(daqChan);
      daqchannelmap::feb_t          ifeb  = dmap->getFEB(daqChan);

      for (unsigned int iDB=0; iDB<_dbList.size(); ++iDB) {
        if (_dbList[iDB].num == (short)diblk) {
          if (_dbList[iDB].hasNoAPDs) return iscooled;
          int iDCM = dcmId-1;
          if (iDCM >= (int)_dbList[iDB].dcm.size()) return iscooled;
          
          if (!_dbList[iDB].dcm[iDCM].isActive) return iscooled;
          if (_dbList[iDB].dcm[iDCM].position == -1) return iscooled;
          
          if (ifeb >= _dbList[iDB].dcm[iDCM].feb.size()) return iscooled;
          
          FEB& currFEB = _dbList[iDB].dcm[iDCM].feb[ifeb];
          if (!currFEB.isEnabled) return iscooled;
          
          if ( !currFEB.hasAPD ) return iscooled;
          
          //everything is fine
          iscooled = currFEB.isCooled;
          break;
        }
      }
      
      return iscooled;
    }

    //**********************************************************************
    bool RunHistory::IsCooled(const geo::OfflineChan& oChan)
    {
      daqchannelmap::DAQChannelMap* dmap = daqchannelmap::DAQChannelMap::getInstance(_detId);
      daqchannelmap::lchan logChan = dmap->encodeLChan(_detId, oChan.Plane(), oChan.Cell());
      daqchannelmap::dchan daqChan = dmap->encodeDChan(logChan);

      return IsCooled(daqChan);
    }

    //**********************************************************************
    RunHistory::FEB RunHistory::GetFEB(daqchannelmap::dchan const& daqChan,
                                       bool & ok)
    {
      FEB feb;
      ok = false;

      if (!LoadAPDSettings()) return feb;

      daqchannelmap::DAQChannelMap* dmap  = daqchannelmap::DAQChannelMap::getInstance(_detId);
      daqchannelmap::diblock_t      diblk = dmap->getDiBlock(daqChan);
      daqchannelmap::dcm_id_t       dcmId = dmap->getDCM(daqChan);
      daqchannelmap::feb_t          ifeb  = dmap->getFEB(daqChan);

      for (size_t iDB = 0; iDB < _dbList.size(); ++iDB) {
        if (_dbList[iDB].num == (short)diblk) {
          DiBlock currDiBlock = GetDiBlock(iDB);
          if (currDiBlock.hasNoAPDs) return feb;
          int iDCM = dcmId-1;
          if (iDCM >= (int)currDiBlock.dcm.size()) return feb;
          
          DCM currDCM = currDiBlock.dcm[iDCM];
          if (currDCM.position == -1) return feb;
          
          std::bitset<64> febSet(currDCM.febMask);
          if (ifeb >= currDCM.feb.size()) return feb;
          
          FEB currFEB = currDCM.feb[ifeb];
          if (!febSet[ifeb] || !currFEB.isEnabled) return feb;
          
          if ( !currFEB.hasAPD ) return feb;
          
          //everything is fine
          ok = true;
          feb = currFEB;
          
          break;
        }
      }

      return feb;
    }

    //**********************************************************************
    RunHistory::FEB RunHistory::GetFEB(geo::OfflineChan const& oChan,
                                       bool & ok)
    {
      daqchannelmap::DAQChannelMap* dmap = daqchannelmap::DAQChannelMap::getInstance(_detId);
      daqchannelmap::lchan logChan = dmap->encodeLChan(_detId, oChan.Plane(), oChan.Cell());
      daqchannelmap::dchan daqChan = dmap->encodeDChan(logChan);

      return this->GetFEB(daqChan, ok);
    }

    //**********************************************************************
    // GetFEB checks to make sure that the APD settings have been loaded properly
    float RunHistory::GetGain(const daqchannelmap::dchan& daqChan, bool& ok)
    {
      float gain=0.;

      FEB feb = this->GetFEB(daqChan, ok);

      if(ok) return feb.gain;

      return gain;
    }

    //**********************************************************************
    float RunHistory::GetGain(const geo::OfflineChan& oChan, bool& ok)
    {
      daqchannelmap::DAQChannelMap* dmap = daqchannelmap::DAQChannelMap::getInstance(_detId);
      daqchannelmap::lchan logChan = dmap->encodeLChan(_detId, oChan.Plane(), oChan.Cell());
      daqchannelmap::dchan daqChan = dmap->encodeDChan(logChan);

      return GetGain(daqChan, ok);
    }

    //**********************************************************************
    float RunHistory::GetPixelGain(daqchannelmap::dchan const& daqChan,
                                   bool                      & ok)
    {

      FEB feb = this->GetFEB(daqChan, ok);
      daqchannelmap::DAQChannelMap* dmap = daqchannelmap::DAQChannelMap::getInstance(_detId);
      daqchannelmap::pixel_t pixel  = dmap->getPixel(daqChan);
      if(ok && pixel < feb.pixelGain.size()) return feb.pixelGain[pixel];

      return 0.;
    }

    //**********************************************************************
    float RunHistory::GetPixelGain(geo::OfflineChan const& oChan,
                                   bool                  & ok)
    {
      daqchannelmap::DAQChannelMap* dmap = daqchannelmap::DAQChannelMap::getInstance(_detId);
      daqchannelmap::lchan logChan = dmap->encodeLChan(_detId, oChan.Plane(), oChan.Cell());
      daqchannelmap::dchan daqChan = dmap->encodeDChan(logChan);

      return this->GetPixelGain(daqChan, ok);
    }

    //**********************************************************************
    std::vector<float> RunHistory::GetPixelGains(daqchannelmap::dchan const& daqChan,
                                                 bool                      & ok)
    {

      FEB feb = this->GetFEB(daqChan, ok);
      
      if(ok) return feb.pixelGain;
 
      return std::vector<float>(32, 0.);
    }

    //**********************************************************************
    std::vector<float> RunHistory::GetPixelGains(geo::OfflineChan const& oChan,
                                                 bool                  & ok)
    {
      daqchannelmap::DAQChannelMap* dmap = daqchannelmap::DAQChannelMap::getInstance(_detId);
      daqchannelmap::lchan logChan = dmap->encodeLChan(_detId, oChan.Plane(), oChan.Cell());
      daqchannelmap::dchan daqChan = dmap->encodeDChan(logChan);

      return this->GetPixelGains(daqChan, ok);
    }

    //**********************************************************************
    int RunHistory::GetThreshold(const daqchannelmap::dchan& daqChan, bool& ok)
    {
      if (! _gotPixelInfo)
        LoadPixelInfo();
      
      ok = false;
      int threshold(4095);
      daqchannelmap::DAQChannelMap* dmap  = daqchannelmap::DAQChannelMap::getInstance(_detId);
      daqchannelmap::diblock_t      diblk = dmap->getDiBlock(daqChan);
      daqchannelmap::dcm_id_t       dcmId = dmap->getDCM(daqChan);
      daqchannelmap::feb_t          ifeb  = dmap->getFEB(daqChan);
      daqchannelmap::pixel_t        ipix  = dmap->getPixel(daqChan);

      //if (diblk > 2) return threshold;

      //daqchannelmap::diblock_t ranges from 1 to 17 -> subtract 1 to get c++ index
      for (unsigned int iDB=0; iDB<_dbList.size(); ++iDB) {
        if (_dbList[iDB].num == (short)diblk) {
          if (_dbList[iDB].hasNoAPDs) return threshold;
            //daqchannelmap::dcm_id_t ranges from 1 to 12 -> subtract 1 to get c++ index
          int iDCM = dcmId-1;
          if (iDCM >= (int)_dbList[iDB].dcm.size()) break;
          
          DCM& currDCM = _dbList[iDB].dcm[iDCM];
          if (currDCM.position == -1) break;
          
          std::bitset<64> febSet(currDCM.febMask);
          if (ifeb >= currDCM.feb.size()) break;
          
          FEB& currFEB = currDCM.feb[ifeb];
          if (!febSet[ifeb] || !currFEB.isEnabled) break;
          
          std::bitset<32> pixSet(currFEB.pixelMask);
          if (!pixSet[ipix]) break;
          
          if ( !currFEB.hasAPD ) break;
      
          //everything is fine
          ok = true;
          threshold = currFEB.pixelThresh[ipix];
          break;
        }
        
      }
      
      return threshold;
    }
    
    //**********************************************************************
    int RunHistory::GetThreshold(const geo::OfflineChan& oChan, bool& ok)
    {
      if (! _gotPixelInfo)
        LoadPixelInfo();

      daqchannelmap::DAQChannelMap* dmap = daqchannelmap::DAQChannelMap::getInstance(_detId);
      daqchannelmap::lchan logChan = dmap->encodeLChan(_detId, oChan.Plane(), oChan.Cell());
      daqchannelmap::dchan daqChan = dmap->encodeDChan(logChan);
      
      int threshold = GetThreshold(daqChan, ok);
      return threshold;
    }


    //**********************************************************************
    std::vector<DQSubrunInfo> RunHistory::GetDQSubrunInfo()
    {
      if (!_gotDQSubrunInfo) {
        _dqSRInfo.clear();
        
        std::unique_ptr<db::Table> dqTable(new nova::dbi::Table("RunHistory/tables/DQSubrunInfo.xml"));
        dqTable->SetDetector(_detector);
        dqTable->SetValidityRange("run",_runNumber);
        dqTable->AddOrderColumn("version");
        dqTable->SetOrderDesc();
        dqTable->AddExcludeCol(std::string("comment"));
        dqTable->AddExcludeCol(std::string("inserttime"));
        dqTable->AddExcludeCol(std::string("insertuser"));
        dqTable->SetVerbosity(_verbosity);
        dqTable->Load();
        
        std::map<std::string,int> colName = dqTable->GetColNameToIndexMap();
        
        int version=0;
        int nextVersion=0;
        for (int i=0; i<dqTable->NRow(); ++i) {
          // make sure we only use rows with the latest version number
          if (i==0) {
            dqTable->GetRow(i)->Col(colName["version"]).Get(version);
            nextVersion=version;
          }
          else
            dqTable->GetRow(i)->Col(colName["version"]).Get(nextVersion);
          
          if (nextVersion != version) break;
          
          DQSubrunInfo sri;
          sri._run = _runNumber;
          sri._version = version;
          dqTable->GetRow(i)->Col(colName["subrun"]).Get(sri._subrun);
          dqTable->GetRow(i)->Col(colName["flag"]).Get(sri._flag);
          dqTable->GetRow(i)->Col(colName["miprate"]).Get(sri._miprate);
          dqTable->GetRow(i)->Col(colName["ngooddb"]).Get(sri._ngooddb);
          dqTable->GetRow(i)->Col(colName["numslc"]).Get(sri._numslc);
          dqTable->GetRow(i)->Col(colName["trkfrac"]).Get(sri._trkfrac);
          _dqSRInfo.push_back(sri);
        }
        _gotDQSubrunInfo = true;
      }
      
      return _dqSRInfo;
    }

    //**********************************************************************
    void RunHistory::PrintChanInfo()
    {
      std::map<geo::OfflineChan,std::vector<ChanInfo_t> >::iterator it = _chanInfo.begin();
      for (; it != _chanInfo.end(); ++it) {
        std::vector<ChanInfo_t>& ci = it->second;
        geo::OfflineChan chan = it->first;
        for (unsigned int j=0; j<ci.size(); ++j)
          std::cout << chan.Plane() << "," << chan.Cell() << "," << ci[j].occ
                    << std::endl;
      }
    }

    //**********************************************************************

    void RunHistory::SetChanInfo(geo::OfflineChan chan, float occ, float coinc,
                                 time_t t)
    {
      ChanInfo_t ci;
      ci.occ    = occ;
      ci.coinc  = coinc;
      ci.tstart = t;
      _chanInfo[chan].push_back(ci);
    }

    //**********************************************************************

    float RunHistory::Occupancy(geo::OfflineChan chan, time_t t)
    {
      const std::vector<ChanInfo_t>& cis = _chanInfo[chan];

      unsigned int i=0;
      for (; i<cis.size() && cis[i].tstart<t; ++i);
      if (i>0)
        return cis[i-1].occ;
      else
        return -6.;
    }

    //**********************************************************************

    float RunHistory::Coincidence(geo::OfflineChan chan, time_t t)
    {
      const std::vector<ChanInfo_t>& cis = _chanInfo[chan];

      unsigned int i=0;
      for (; i<cis.size() && cis[i].tstart<t; ++i);
      if (i>0)
        return cis[i-1].coinc;
      else
        return 0.;
    }

    //**********************************************************************

    void RunHistory::SetIsBad(geo::OfflineChan chan, bool isBad, time_t t)
    {
      BadChan_t b;
      b.isBad = isBad;
      b.tstart = t;
      _badChan[chan].push_back(b);
    }

    //**********************************************************************

    bool RunHistory::IsBad(geo::OfflineChan chan, time_t t)
    {
      unsigned int i=0;
      for (; i<_badChan[chan].size() && _badChan[chan][i].tstart<t; ++i);
      return _badChan[chan][i-1].isBad;
    }

    //**********************************************************************
    time_t RunHistory::SubrunTStart(int isr) {
      LoadDAQRunHistory();
      if (isr < 0 || isr > _nsubrun) return 0;
      if (isr == 0) return this->TStart();
      return _subrunList[isr].tstart; 
    }

    //**********************************************************************
    time_t RunHistory::SubrunTStop(int isr) {
      LoadDAQRunHistory();
      if (isr < 0 || isr > _nsubrun) return 0;
      if (isr == _nsubrun-1) return this->TStop();
      return _subrunList[isr+1].tstart; 
    }

    //**********************************************************************
    time_t RunHistory::TStart() {
      LoadDAQRunHistory();
      time_t t;
      if (nova::dbi::Util::TimeAsStringToTime_t(_tStart,t))
        return t;
      else
        return 0;
    }

    //**********************************************************************

    time_t RunHistory::TStop() {
      LoadDAQRunHistory();
      time_t t;
      std::string tEnd = _tEnd;
      if (_tEnd == "")
        tEnd = "2000-01-01 00:00:00";
      if (nova::dbi::Util::TimeAsStringToTime_t(tEnd,t))
        return t;
      else
        return 0;
    }

    //**********************************************************************

    void RunHistory::Dump() {
      std::cout << "****************************************" << std::endl;
      std::cout << "Dump of run " << _runNumber << std::endl;
      std::cout << "****************************************\n" << std::endl;
      std::cout << "Num Subruns        : " << _nsubrun << std::endl;
      std::cout << "Start time         : " << TStartAsString() << std::endl;
      std::cout << "End time           : " << TStopAsString() << std::endl;
      std::cout << "Trig Tot           : " << _nTotTrig << std::endl;
      std::cout << "Num Active Channels: " << _nActiveChannels << std::endl;
      std::cout << "Num Total Channels:  " << _nTotalChannels << std::endl;
      std::cout << "Num DCMs           : " << NLiveDCMs() << std::endl;
      for (unsigned int i=0; i<_dbList.size(); ++i)
        for (unsigned int j=0; j<_dbList[i].dcm.size(); ++j)
          if (_dbList[i].dcm[j].isActive)
            std::cout << "\t" << _dbList[i].dcm[j].appname << std::endl;
      std::cout << "Num BNEVBs         : " << _bnevbList.size() << std::endl;
      for (unsigned int i=0; i<_bnevbList.size(); ++i)
        std::cout << "\t" << _bnevbList[i].appname << std::endl;
      
    }

    //**********************************************************************

    void RunHistory::InvalidateCaches()
    {
      _failedToFindRun = false;
      _gotDAQRunHistory = false;
      _gotFEBMasks = false;
      _gotPixelInfo = false;
      _gotHardwareInfo = false;
      _gotAPDSettings = false;
      _gotCoolingInfo = false;
      _gotPOT = false;
      _gotGoodDiBlockMask = false;
      _gotDQSubrunInfo = false;
      _gotDataEpoch = false;
      _gotPixelMasks = false;
      _gotPedestals = false;
      _diblockIndex.clear();
      
      _isMC = false;

      _subrunList.clear();
      _subrunList.resize(64);
      for (int isr=0; isr<_nsubrun; ++isr) {
        _subrunList[isr].tstart = 0;
        _subrunList[isr].tstop = 0;
        _subrunList[isr].goodDiBlockMask = 0;
        _subrunList[isr].gotNAnalysisDiBlocks = false;
        _subrunList[isr].gotNAnalysisChannels = false;
        _subrunList[isr].nAnalysisDiBlocks = 0;
        _subrunList[isr].nAnalysisChannels = 0;
      }


      _npot = 0.;
      _avgpot = 0.;
      _nTotTrig = 0;
      _nActiveChannels=0;
      _nTotalChannels=0;
      _nTotalFEBs=0;
      _nInstalledAPDs=0;
      _customMask=0;
      _detGainSetting=0;
      _dbList.clear();
      _bnevbList.clear();
    }

    //**********************************************************************
    // the key for the returned map is the module # in the module_apd_connection table
    std::map<uint32_t, APDInfo> RunHistory::PullAPDInfoFromDB()
    {
      LOG_INFO("RunHistory") << "Pull APD Info from DB" << std::endl;
      //TStopwatch ts;

      std::map<uint32_t, APDInfo> apdinfomap;
      std::map<std::string, std::vector<float> > apdgains;

      std::list<std::string> notInstalledAPD;

      std::unique_ptr<db::Table> hwTable;
      hwTable.reset(new db::Table());

      if (novadaq::cnv::DetInfo::DetNameOk(_detector))
        hwTable->SetDetector(_detector);
      else {
         LOG_ERROR("RunHistory")<<"Could not establish detector table connection"<<std::endl;
         std::abort();
           }
      hwTable->SetTableType(nova::dbi::kHardwareTable);
      //hwTable->SetIgnoreEnvVar(false);
      hwTable->SetTimeQueries(_timeQueries);
      hwTable->SetVerbosity(_verbosity);
      
      std::string SQL;

      PGresult* res  = nullptr;
      //      PGresult* res2 = nullptr;

      if (_detId == novadaq::cnv::kFARDET) {

        // get test information for APDs
        SQL ="select right(gain.apd_id, 7), gain.batch_no, gain.target_degc, gain.pixel_col, gain.pixel_row, gain.pixel_m from public.apd_pixel_m gain where gain.target_degc<0 ORDER BY right(gain.apd_id, 7) ASC, gain.batch_no DESC, gain.target_degc ASC, gain.pixel_col ASC, gain.pixel_row ASC";
        
        res = PerformPGQuery(SQL, hwTable);
        uint32_t    row;
        uint32_t    col;
        uint32_t    pixel;
        std::string colStr;
        std::string apdSN;
        int         numRows = PQntuples(res);
        int         batch;
        
        for(int r = 0; r < numRows; ++r){
          
          apdSN  = PQgetvalue(res, r, 0);
          batch  = std::atoi(PQgetvalue(res, r, 1));
          
          // the query is ordered by the batch number with the most recent first
          // so only grab those values
          if(apdgains.count(apdSN) < 1){
            apdgains[apdSN] = std::vector<float>(32,100.);
            
            while(apdSN.compare(PQgetvalue(res, r, 0)) == 0 &&
                  batch == std::atoi(PQgetvalue(res, r, 1)) ){
              colStr = PQgetvalue(res, r, 3);
              row    = std::atoi(PQgetvalue(res, r, 4)) - 1;
              col    = 0;
              if     (colStr.compare("B") == 0) col = 8;
              else if(colStr.compare("C") == 0) col = 16;
              else if(colStr.compare("D") == 0) col = 24;
              
              // encode "dummy" dchan with constant diblock, dcm and feb numbers as we only need the
              // correct pixel and detector to be encoded.
              daqchannelmap::dchan dchan = daqchannelmap::DAQChannelMap::getInstance(_detId)->encodeDChan(_detId, 1, 1, 1, row+col);
              pixel = daqchannelmap::DAQChannelMap::getInstance(_detId)->computeFiberInModule(dchan);
              
              apdgains[apdSN][pixel] = std::atof(PQgetvalue(res, r, 5));
              
              ++r;
            } // end loop to get the gains for the most recent batch of this apd
              // need to decrement r by 1 so that the end of the for loop doesn't push us one to far
            --r;
          } // end if the apd is not already in the map
          
        }// end loop over query to get the apd gain information
        
        SQL  = "select right(astat.apd_id, 7), astat.batch_no, astat.target_degc, astat.vr, bi.barcoded_item_id, bi.date_added, mac.module, mac.connection_id, nc.date_removed from public.apd_stats astat, ashriverprod_factory.barcoded_item bi, ashriverprod_factory.module_apd_connection mac, ashriverprod_factory.nova_connection nc ";
        SQL += "where right(bi.barcode,7)=right(astat.apd_id,7) and bi.glassfish_discriminator='apd' and mac.apd=bi.barcoded_item_id and nc.connection_id=mac.connection_id and bi.date_added < '";
        SQL += _tStart;
        SQL += "'  and (nc.date_removed is NULL or nc.date_removed > '";
        SQL += _tStart;
        SQL += "') and (bi.date_removed is NULL or bi.date_removed > '";
        SQL += _tStart;
        SQL += "')";
        // order the results by APD serial number and then temperature.
        // We only take the first result, ie the low temperature data, except
        // when there is only high temp data.
        SQL += "ORDER BY right(astat.apd_id, 7) ASC, astat.target_degc ASC";
        
        //ts.Start();
        res = PerformPGQuery(SQL, hwTable);
        //ts.Stop();
        //ts.Print();
          // LOG_DEBUG("APDInfo") << "query " << SQL << " returned " << PQntuples(res)
          //                         << " rows\n First Row: " << PQgetvalue(res, 0, 0)
          //                         << " " << PQgetvalue(res, 0, 1)
          //                         << " " << PQgetvalue(res, 0, 2)
          //                         << " " << PQgetvalue(res, 0, 3)
          //                         << " " << PQgetvalue(res, 0, 4)
          //                         << " " << PQgetvalue(res, 0, 5)
          //                         << " " << PQgetvalue(res, 0, 6)
          //                         << " " << PQgetvalue(res, 0, 7)
          //                         << " " << PQgetvalue(res, 0, 8)
          //                         << " in ";
        
        //ts.Reset();
        //ts.Start();
        std::string date;
        APDInfo     apdi;
        APDInfo     prevAPD;
        numRows = PQntuples(res);
        
        LOG_DEBUG("RunHistory") << "Found " << numRows << " apds in the db";
        
        for(int r = 0; r < numRows; ++r){
          
          // convert the date added to the number of seconds since 1970
          date = PQgetvalue(res, r, 5);
          TTimeStamp ts(std::atoi(date.substr(0,4).c_str()),
                        std::atoi(date.substr(5,2).c_str()),
                        std::atoi(date.substr(8,2).c_str()),
                        std::atoi(date.substr(12,2).c_str()),
                        std::atoi(date.substr(15,2).c_str()),
                        std::atoi(date.substr(18,2).c_str()));
          
          apdi._sn        = PQgetvalue(res, r, 0);
          apdi._batch     = std::atoi(PQgetvalue(res, r, 1));
          apdi._temp      = std::atoi(PQgetvalue(res, r, 2));
          apdi._voltage   = std::atof(PQgetvalue(res, r, 3));
          apdi._barcode   = std::atoi(PQgetvalue(res, r, 4));
          apdi._installed = ts.AsDouble();
          apdi._module    = std::atoi(PQgetvalue(res, r, 6));
          apdi._modcon    = std::atoi(PQgetvalue(res, r, 7));
          
          if(apdgains.count(apdi._sn) > 0)
            apdi._pixelGain = apdgains[apdi._sn];
          //      else
          //        std::cout << "no gains found for " << apdi._sn << std::endl;
          
          // make sure the current apd is not already in the map and
          // that the avGain is > 0
          // if it is already in the map, use the most recent
          if(apdinfomap.count(apdi._module) > 0){
            
            prevAPD = apdinfomap.at(apdi._module);
            
            // first check the installed date
            if(apdi._installed > prevAPD._installed)
              apdinfomap[apdi._module] = apdi;
          }
          else
            apdinfomap[apdi._module] = apdi;
          
          //LOG_DEBUG("APDInfo") << apdi;
          
        } // end loop over rows
        //ts.Stop();
        //ts.Print();
        
        PQclear(res);
        
      } // end if the far detector
      
      //ts.Stop();
      //ts.Print();
      
      LOG_DEBUG("APDInfo")
        << apdinfomap.size()
        << " apds were installed"
        << "print out info for all APDs";
      
      hwTable->CloseConnection();
      
      return apdinfomap;
    }

    //**********************************************************************
    std::map<HardwareLocation, std::pair<FEBInfo, APDInfo>> RunHistory::PullFEBInfoFromDB(std::map<uint32_t, APDInfo> apdinfomap)
    {
      //std::cout << "Pull FEB Info from DB" << std::endl;
      //TStopwatch ts;
      //ts.Start();
    
      // the key for this map is the module # in the module_feb_connection table
      std::list<std::pair<FEBInfo, APDInfo>> febtoapd;
      std::map<uint32_t, FEBInfo> febinfomap;
      
      std::unique_ptr<db::Table> hwTable;
      hwTable.reset(new db::Table());
      
      if (novadaq::cnv::DetInfo::DetNameOk(_detector))
        hwTable->SetDetector(_detector);
      else {
        LOG_ERROR("RunHistory")<<"could not extablish table connection for detector"<<std::endl;
        std::abort();
           }
      hwTable->SetTableType(nova::dbi::kHardwareTable);
      //hwTable->SetIgnoreEnvVar(false);
      hwTable->SetTimeQueries(_timeQueries);
      hwTable->SetVerbosity(_verbosity);
      
      std::string SQL;
      
      PGresult* res = nullptr;
      
      std::map<HardwareLocation, std::pair<FEBInfo, APDInfo>> htol;
      
      if (_detId == novadaq::cnv::kFARDET) {
        
        // get locations of installed FEBs
        SQL = "select bi.barcode, febtest.hvfitintercept, febtest.hvfitslope, bi.barcoded_item_id, bi.date_added, mfc.module, mfc.connection_id, nc.date_removed from ashriverprod_factory.barcoded_item bi, ashriverprod_factory.module_feb_connection mfc, ashriverprod_factory.nova_connection nc, public.feb_test_summary febtest where bi.barcode=overlay(overlay(febtest.febsn placing '.' from 5 for 1) placing '.' from 7 for 1) and bi.glassfish_discriminator='feb' and mfc.feb=bi.barcoded_item_id and nc.connection_id=mfc.connection_id and bi.date_added < '";
        SQL += _tStart;
        SQL += "'  and (nc.date_removed is NULL or nc.date_removed > '";
        SQL += _tStart;
        SQL += "') and (bi.date_removed is NULL or bi.date_removed > '";
        SQL += _tStart;
        SQL += "') ORDER BY bi.date_added DESC";
        
        res = PerformPGQuery(SQL, hwTable);
        // std::cout << SQL << "\n returned "
        //           << PQntuples(res)
        //           << " rows" << std::endl;
        
        int nRow  = PQntuples(res);
        for(int r = 0; r < nRow; ++r){
          // convert the date added to the number of seconds since 1970
          std::string date = PQgetvalue(res, 0, 4);
          TTimeStamp ts(std::atoi(date.substr(0,4).c_str()),
                        std::atoi(date.substr(5,2).c_str()),
                        std::atoi(date.substr(8,2).c_str()),
                        std::atoi(date.substr(12,2).c_str()),
                        std::atoi(date.substr(15,2).c_str()),
                        std::atoi(date.substr(18,2).c_str()));
          
          FEBInfo febi;
          febi._sn        = PQgetvalue(res, r, 0);
          febi._intercept = std::atof(PQgetvalue(res, r, 1));
          febi._slope     = std::atof(PQgetvalue(res, r, 2));
          febi._barcode   = std::atoi(PQgetvalue(res, r, 3));
          febi._module    = std::atoi(PQgetvalue(res, r, 5));
          febi._modcon    = std::atoi(PQgetvalue(res, r, 6));
          febi._installed = ts.AsDouble();
          
          // use the default slope from Leon M. if the returned slope is 0
          if(febi._slope == 0.) febi._slope = 0.02586;
          
          // make sure the current feb is not already in the map
          // if it is, use the most recent
          if(febinfomap.count(febi._module) > 0){
            
          if(febi._installed > febinfomap[febi._module]._installed)
            febinfomap[febi._module] = febi;
          }
          else
            febinfomap[febi._module] = febi;
          
        } // end loop over febs
        PQclear(res);
        
        LOG_DEBUG("RunHistory")
        << "there are " << febinfomap.size()
        << " febs installed and put in the map and "
        << apdinfomap.size() << " apds";
        
        // now get the module to hardware location map
        SQL = "select btrim(fcom.location1, 'DIBLK:') diblk, btrim(fcom.position1, 'DCM:') dcm, btrim(fcom.port1,'PRT:') feb, mod.block, mod.layer, mod.position_in_layer, mod.barcoded_item_id from public.feb_comm_cables fcom, ashriverprod_factory.module mod where (mod.block=CAST(btrim(fcom.location2,'BLK:') AS INT) and mod.layer=CAST(btrim(fcom.position2,'PLN:') AS INT) and mod.position_in_layer=CAST(btrim(fcom.port2,'POS:') AS INT)) ORDER BY diblk ASC, dcm ASC, feb ASC";
        
        res = PerformPGQuery(SQL, hwTable);
        
        HardwareLocation hl;
        uint32_t         mod   = 0;
        uint32_t         noapd = 0;
        for(int r = 0; r < PQntuples(res); ++r){
          
          hl._detid    = _detId;
          hl._diblock  = std::atoi(PQgetvalue(res, r, 0));
          hl._dcm      = std::atoi(PQgetvalue(res, r, 1));
          hl._feb      = std::atoi(PQgetvalue(res, r, 2));
          hl._block    = std::atoi(PQgetvalue(res, r, 3));
          hl._layer    = std::atoi(PQgetvalue(res, r, 4));
          hl._layerPos = std::atoi(PQgetvalue(res, r, 5));
          mod          = std::atoi(PQgetvalue(res, r, 6));
          
            // find the FEB for this module
          if(febinfomap.count(mod) > 0){
            std::pair<FEBInfo, APDInfo> hwpair;
            hwpair.first = febinfomap[mod];
            
            // find the corresponding apd
            if(apdinfomap.count(mod) > 0) 
              hwpair.second = apdinfomap[mod];
            else{
              LOG_DEBUG("RunHistory")
              << noapd
              << " no APD found for "
              << hwpair.first << " installed at " << hl;
              
              ++noapd;
            }
            htol[hl] = hwpair;
          }
        }
        
        PQclear(res);
        
        LOG_DEBUG("RunHistory")
        << "There are " << febinfomap.size()
        << " febs in the db, and " << htol.size()
        << " are connected to a harward location" << std::endl
        << "There are " << apdinfomap.size() << " apds installed";
        
        
      } // end if the right detector
      
      //ts.Stop();
      //ts.Print();
      
      hwTable->CloseConnection();
      
      return htol;
    }

    //**********************************************************************
    void RunHistory::MapHardwareToLocation()
    {
      //       TStopwatch ts;
      //       ts.Start();

      // get the location to installed hardware map
      auto htol  = this->PullFEBInfoFromDB(this->PullAPDInfoFromDB());

      gLocToFA.swap(htol);

      if (_detId == novadaq::cnv::kFARDET) {
        
        // look for missing hardware locations
        int missingHardware = 0;
        for (int idb=0; idb<14; ++idb) {
          for (unsigned int idcm=0; idcm<12; ++idcm) {
            for (int j=0; j<64; ++j) {
              // no gain recorded for the FEB, see if it is in the hardware
              // location map
              HardwareLocation hl;
              hl._detid   = _detId;
              hl._diblock = idb  + 1;
              hl._dcm     = idcm + 1;
              hl._feb     = j;
              
              if(gLocToFA.count(hl) < 1){
                LOG_DEBUG("RunHistory") << hl << " is not in the location map";
                ++missingHardware;
              }
            }// end loop over febs
          }// end loop over dcms
        }// end loop over diblocks
        LOG_DEBUG("RunHistory") << "there are " << missingHardware << " locations without hardware";
      } 
      
      //       ts.Stop();
      //       ts.Print();
      
      return;
    }

    void RunHistory::BuildMC() // build fake everything for MC
    {

      unsigned int fNDiblocks = 14;
      unsigned int fNDCMs = 12;

      if (_detId == novadaq::cnv::kNEARDET) {
        fNDiblocks = 4;
        fNDCMs = 4;
      }

      for (unsigned int ndib = 1; ndib<=fNDiblocks; ndib++) { // make full set of diblocks

        if(!IsGoodDiBlock(ndib)) continue;

        if(_detId == novadaq::cnv::kNEARDET && ndib==4) fNDCMs = 2;
        DiBlock db(fNDCMs);
        db.num = ndib;
        _diblockIndex[ndib] = ndib-1;
        db.hasNoAPDs = false;
        if(_detId == novadaq::cnv::kNEARDET) {
          if(ndib == 4) db.nInstrumentedFEBs = 53;
          else db.nInstrumentedFEBs = 192;
        }
        else db.nInstrumentedFEBs = fNDCMs*64;
        for(unsigned int ndcm = 1; ndcm <= fNDCMs; ndcm++) {
          DCM d;
          d.diblock = ndib;
          d.position = ndcm;
          d.isActive = true;
          if(_detId == novadaq::cnv::kNEARDET && ndib<4 && (ndcm==1 || ndcm==4)) {
            d.feb.resize(32);
            d.nInstrumentedFEBs = 32;
          }
          else if(_detId == novadaq::cnv::kNEARDET && ndib==4 && ndcm==1) {
            d.feb.resize(31);
            d.nInstrumentedFEBs = 31;
          }
          else if(_detId == novadaq::cnv::kNEARDET && ndib==4 && ndcm==2) {
            d.feb.resize(22);
            d.nInstrumentedFEBs = 22;
          }
          else {
            d.feb.resize(64);
            d.nInstrumentedFEBs = 64;
          }
          db.dcm[d.position-1] = d;
        }
        _dbList.push_back(db);
      }

      _gotDAQRunHistory = true; // don't want to be asking about these things for MC runs, leave the parameters these functions fill at 0
      _gotPixelInfo = true;
      _gotHardwareInfo = true;
      _gotAPDSettings = true;
      _gotCoolingInfo = true;
      _gotPOT = true;
      _nsubrun = 64;
    }

  }  // end of namespace dbi
} // end of namespace nova