RunHistory.cpp

Go to the documentation of this file.

#include <DatabaseUtils/RunHistory/RunHistory.h>
#include <DatabaseUtils/DAQConfig/PixelEnableMasks.h>
#include <DatabaseUtils/DCS/APDSettings.h>
#include <NovaDAQConventions/DAQConventions.h>
#include <cstdlib>

namespace daqcfg = dbutils::daqconfig;
using namespace std;

namespace dbutils {

  //**********************************************************************
  
  RunHistory::RunHistory(int run, std::string det) :
    _runNumber(run), _nsubrun(0), _nTotTrig(0), 
    _nActiveChannels(0), _nTotalChannels(0), 
    _nTotalFEBs(0), _nMaskedOffFEBs(0),
    _tStart("2010-01-01 00:00:00"), _tEnd(""), 
    _dcmList(0), _bnevbList(0)
  {
    runsTable.reset(new db::Table("NovaDatabase/tables/RunHistory/Runs.xml"));
    resTable.reset(new db::Table("NovaDatabase/tables/RunHistory/DAQResourcesByRun.xml"));
    if (novadaq::cnv::DetInfo::DetNameOk(det)) {
      _detector = det;
      runsTable->SetDetector(det);
      resTable->SetDetector(det);
      char daqEnv[128];
      sprintf(daqEnv,"NOVADAQ_ENVIRONMENT=%s",det.c_str());
      putenv(daqEnv);
    }
    else {
      std::string errStr = "RunHistory::RunHistory: invalid detector name!";
      throw std::runtime_error(errStr);
    }
    
    hwposTable.reset(new db::Table("NovaDatabase/tables/Hardware/HardwarePosition.xml"));
    hwposTable->SetDBInfo("nova_hardware","ifdbprod.fnal.gov",
                          "5432","nova_reader");
    hwposTable->SetIgnoreEnvVar(true);
    
    Load();
  }
  //**********************************************************************
  
  RunHistory::RunHistory(int run, int det) :
    _runNumber(run), _nsubrun(0), _nTotTrig(0), 
    _nActiveChannels(0), _nTotalChannels(0), 
    _nTotalFEBs(0), _nMaskedOffFEBs(0),
    _tStart("2010-01-01 00:00:00"), _tEnd(""), 
    _dcmList(0), _bnevbList(0)
  {
    runsTable.reset(new db::Table("NovaDatabase/tables/RunHistory/Runs.xml"));
    resTable.reset(new db::Table("NovaDatabase/tables/RunHistory/DAQResourcesByRun.xml"));
    if (novadaq::cnv::DetInfo::DetIdOk(det)) {
      _detector = novadaq::cnv::DetInfo::GetName(det);
      runsTable->SetDetector(det);
      resTable->SetDetector(det);
      char daqEnv[128];
      sprintf(daqEnv,"NOVADAQ_ENVIRONMENT=%s",_detector.c_str());
      putenv(daqEnv);
    }
    else {
      std::string errStr = "RunHistory::RunHistory: invalid detector id!";
      throw std::runtime_error(errStr);
    }

    hwposTable.reset(new db::Table("NovaDatabase/tables/Hardware/HardwarePosition.xml"));
    hwposTable->SetDBInfo("nova_hardware","ifdbprod.fnal.gov",
                          "5432","nova_reader");
    hwposTable->SetIgnoreEnvVar(true);
    
    Load();
  }

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

  RunHistory::~RunHistory() 
  {
  }

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

  void RunHistory::SetDBInfo(std::string dbname, std::string dbhost, 
                             std::string user,   std::string dbport)
  {
    if (dbname!="") {
      runsTable->SetDBName(dbname);
      runsTable->SetIgnoreEnvVar(true);
      resTable->SetDBName(dbname);
      resTable->SetIgnoreEnvVar(true);
    }
    if (dbhost!="") {
      runsTable->SetDBHost(dbhost);
      runsTable->SetIgnoreEnvVar(true);
      resTable->SetDBHost(dbhost);
      resTable->SetIgnoreEnvVar(true);
    }
    if (user!="") {
      runsTable->SetUser(user);
      runsTable->SetIgnoreEnvVar(true);
      resTable->SetUser(user);
      resTable->SetIgnoreEnvVar(true);
    }
    if (dbport!="") {
      runsTable->SetDBPort(dbport);
      runsTable->SetIgnoreEnvVar(true);
      resTable->SetDBPort(dbport);
      resTable->SetIgnoreEnvVar(true);
    }
    
  }

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

  void RunHistory::Load()
  {
    runsTable->Clear();
    resTable->Clear();
    hwposTable->Clear();

    runsTable->SetValidityRange("run",_runNumber);
    runsTable->LoadFromDB();
    db::Row* row = runsTable->GetRow(0);
    if (row) {
      string timeStr;
      if (row->Col("tstart")->Get(timeStr)) _tStart = timeStr;
      if (row->Col("tstop")->Get(timeStr)) _tEnd = timeStr;
      row->Col("nevents")->Get(_nTotTrig);
      row->Col("configid")->Get(_gCfgId);
      row->Col("nsubruns")->Get(_nsubrun);
    }

    std::vector<std::string> tmpDCMList;
    resTable->SetValidityRange("run",_runNumber);
    resTable->LoadFromDB();
    int nResources = resTable->NRow();
    for (int i=0; i<nResources; ++i) {
      row = resTable->GetRow(i);
      string rtype;
      string appname;
      if (row->Col("resource_type")->Get(rtype)) {
        if (rtype == "bnevb") {
          BNEVB b;
          row->Col("appname")->Get(appname);
          b.appname = appname;
          _bnevbList.push_back(b);
        }
        else if (rtype == "dcm") {
          DCM d;
          row->Col("appname")->Get(appname);
          d.appname = appname;
          _dcmList.push_back(d);
          tmpDCMList.push_back(appname);
        }
      }
    }

    daqcfg::PixelEnableMasks pixelEnableMasks(_gCfgId, tmpDCMList);
    dcs::APDSettings apdSettings(_gCfgId, tmpDCMList);
    for (uint32_t iDCM = 0; iDCM < _dcmList.size(); ++iDCM) {
      int64_t febMask = 0;
      pixelEnableMasks.getFEBEnableMask(_dcmList[iDCM].appname,
                                        febMask);
      _dcmList[iDCM].febMask = febMask;
      for (int iFEB = 0; iFEB < 64; ++iFEB) {
        bool countIt = true;
        if ( (_dcmList[iDCM].appname == "dcm-3-01-03" ||
              _dcmList[iDCM].appname == "dcm-3-02-03") &&
             ((iFEB >= 16 && iFEB <= 31) || (iFEB >= 47)) )
          countIt = false;
        if ( (_dcmList[iDCM].appname == "dcm-3-01-01" ||
              _dcmList[iDCM].appname == "dcm-3-02-01" ||
              _dcmList[iDCM].appname == "dcm-3-01-02" ||
              _dcmList[iDCM].appname == "dcm-3-02-02") &&
             (iFEB == 47 || iFEB == 63))
          countIt = false;
        if (( _dcmList[iDCM].appname == "dcm-3-03-02") &&
            ((iFEB >= 62)||(iFEB >= 46 && iFEB <= 47)))
          countIt = false;
        if (( _dcmList[iDCM].appname == "dcm-3-03-03") &&
            ((iFEB >= 16 && iFEB <= 31)||(iFEB >= 46)))
          countIt = false;
        if ( _dcmList[iDCM].appname == "dcm-3-04-01")
          if ((iFEB >= 6 && iFEB <= 15) || iFEB >= 22)
            countIt = false;    
        if ( _dcmList[iDCM].appname == "dcm-3-04-02")
          if ((iFEB >= 7 && iFEB <= 15) || (iFEB >= 23 && iFEB <= 31) ||
              iFEB >= 39)
            countIt = false;
        
        if (countIt) {
          FEB f;
          f.dcmid = _dcmList[iDCM].appname;
          f.loc = iFEB;
          _nTotalChannels += 32;
          ++_nTotalFEBs;
          f.isEnabled = false;
          if (pixelEnableMasks.febIsEnabled(_dcmList[iDCM].appname, iFEB)) {
            f.isEnabled = true;
            int32_t pixelMask = 0;
            pixelEnableMasks.getPixelEnableMask(_dcmList[iDCM].appname,
                                                iFEB, pixelMask);
            f.pixelMask = pixelMask;
            f.nActivePix = pixelEnableMasks.
              getEnabledPixelCountForFEB(_dcmList[iDCM].appname, iFEB);
            _nActiveChannels += f.nActivePix;
            f.apdV = 0;
            f.isCooled = false;
            f.tempEnabled = false;
            f.temperature = -100;
            if (apdSettings.hasValidData()) {
              apdSettings.getTemperatureEnable(f.dcmid,f.loc,f.tempEnabled);
              double temp;
              apdSettings.getTemperature(f.dcmid,f.loc,temp);
              f.temperature = temp;           
            }       
          }
          if (! f.isEnabled) _nMaskedOffFEBs++;
          _dcmList[iDCM].feb[iFEB] = f;
        }
      }

    }


    std::string cmd = "detector='" + _detector + "' and hw_type='APD' and install_date < '" + _tStart + "' and (remove_date is NULL or remove_date > '" + _tStart + "')";
    hwposTable->SetValiditySQL(cmd);
    hwposTable->LoadFromDB();
    for (int i=0; i<hwposTable->NRow(); ++i) {
      row = hwposTable->GetRow(i);
      if (row) {
        int block; row->Col("block")->Get(block);
        int plane; row->Col("plane")->Get(plane);
        int module_position; row->Col("module_position")->Get(module_position);
      }
    }

  }

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

  time_t RunHistory::TStart() const {
    time_t t;
    if (nova::database::Util::TimeAsStringToTime_t(_tStart,t))
      return t;
    else
      return 0;
  }

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

  time_t RunHistory::TStop() const {
    time_t t;
    string tEnd = _tEnd;
    if (_tEnd == "")
      tEnd = "2000-01-01 00:00:00";
    if (nova::database::Util::TimeAsStringToTime_t(tEnd,t))
      return t;
    else
      return 0;
  }
  
  //**********************************************************************

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

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

  bool RunHistory::FEBEnableMask(const std::string& dcmName,int64_t& febMask) {
    if (_pixMaskPtr.get() == 0) {
      std::vector<std::string> dcmNameList;
      for (unsigned int i=0; i<_dcmList.size(); ++i) {
        dcmNameList.push_back(_dcmList[i].appname);
      }
      daqcfg::PixelEnableMasks blah(_gCfgId, dcmNameList);
      _pixMaskPtr.reset(new daqcfg::PixelEnableMasks(_gCfgId, dcmNameList));
    }

    if (! _pixMaskPtr->hasValidData()) {return false;}
    return _pixMaskPtr->getFEBEnableMask(dcmName, febMask);
  }

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

  bool RunHistory::PixelEnableMask(const std::string& dcmName,
                                   const int& febId, int32_t& pixelMask) {
    if (_pixMaskPtr.get() == 0) {
      std::vector<std::string> dcmNameList;
      for (unsigned int i=0; i<_dcmList.size(); ++i) {
        dcmNameList.push_back(_dcmList[i].appname);
      }
      _pixMaskPtr.reset(new daqcfg::PixelEnableMasks(_gCfgId, dcmNameList));
    }

    if (! _pixMaskPtr->hasValidData()) {return false;}
    return _pixMaskPtr->getPixelEnableMask(dcmName, febId, pixelMask);
  }

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

  bool RunHistory::PixelThresholdsForFEB(const std::string& dcmName,
                                         const int& febId,
                                         std::vector<int16_t>& thresholdList) {
    if (_pixThreshPtr.get() == 0) {
      std::vector<std::string> dcmNameList;
      for (unsigned int i=0; i<_dcmList.size(); ++i) {
        dcmNameList.push_back(_dcmList[i].appname);
      }
      _pixThreshPtr.reset(new daqcfg::PixelThresholds(_gCfgId, dcmNameList));
    }

    if (! _pixThreshPtr->hasValidData()) {return false;}
    return _pixThreshPtr->getThresholdsForFEB(dcmName, febId, thresholdList);
  }

} // end of namespace dbutils