nova::dbi::RunHistory Class Reference

#include "/cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N21-01-16/RunHistory/RunHistory.h"

Inheritance diagram for nova::dbi::RunHistory:

Classes
class	BNEVB
class	DCM
class	DiBlock
class	FEB

Public Member Functions
	RunHistory ()
virtual	~RunHistory ()
	RunHistory (int run, std::string det)
	RunHistory (int run, novadaq::cnv::DetId detid)
void	SetDBInfo (std::string dbname="", std::string dbhost="", std::string user="", std::string port="")
void	SetRunNumber (int run)
void	SetDetector (novadaq::cnv::DetId det)
void	SetDetector (const std::string &det)
bool	LoadDAQRunHistory ()
bool	LoadHardwareInfo ()
bool	LoadDCSAlarms (int subrun=-1)
bool	LoadCoolingInfo ()
bool	LoadPixelInfo (int nAttempt=0)
bool	LoadPixelMasks ()
bool	LoadFEBMasks ()
bool	LoadFEBMasksFromDAQDB ()
bool	LoadPedestals ()
bool	LoadAPDSettings ()
bool	LoadPOT ()
bool	LoadGoodDiBlockMask ()
bool	LoadDataEpoch ()
bool	LoadAllDetInfo ()
bool	IsRHC ()
void	Dump ()
void	SetNDRHCRunStart (std::vector< int > r)
void	SetNDRHCRunStop (std::vector< int > r)
void	SetFDRHCRunStart (std::vector< int > r)
void	SetFDRHCRunStop (std::vector< int > r)
void	SetTimeQueries (bool f)
void	SetTimeParsing (bool f)
void	SetIfAnyMasking (bool f)
	set from fcl: do we want to use any masking at all? If no, other masking options irrelevant More...
void	SetAnalysisDiBlockMasking (bool f)
	set from fcl: do we want to use the analysis rules when we mask (not for custom masking)? More...
void	SetIfCustomMasking (bool f)
	set from fcl: do we want to use a custom mask? More...
void	SetCustomMask (std::vector< bool > f)
	set from fcl: what is our custom mask? More...
void	SetGetDiBlockMaskFromCondb (bool f)
bool	GetDiBlockMaskFromCondb () const
void	SetSubrunDiBlockMask (int isr, int m)
int	ApplyAnalysisDiBlockMask (const int mask) const
	converts normal mask to analysis rules mask (any continuous chunk of four or more diblocks kept) More...
std::string	DiBlockMaskToString (const int mask) const
int	RunNumber () const
int	NSubruns ()
std::string	Detector () const
int	Partition ()
std::string	RunType ()
time_t	TStart ()
time_t	TStop ()
std::string	TStartAsString ()
std::string	TStopAsString ()
time_t	SubrunTStart (int isr)
time_t	SubrunTStop (int isr)
int	Duration ()
	in units of seconds More...
int	NTriggers ()
float	NPOT ()
float	AvgPOTPerSpill ()
int	NDiBlocks ()
	gives number of active diblocks only, may be less than 14 More...
int	NDCMs ()
int	NLiveDCMs ()
int	NBNEVBs ()
std::vector< BNEVB >	GetBNEVBList ()
int	NAnalysisChannels (int sr=0)
int	NAnalysisDiBlocks (int sr=0)
int	NActiveChannels ()
int	NTotalChannels ()
int	NFEBs ()
int	GoodDiBlockMask (int subrun=-1, bool reload=false)
int	GetConfiguration ()
void	SetGoodDiBlockMask (int newmask)
bool	IsGoodDiBlock (int idb, int subrun=-1)
DiBlock	GetDiBlock (int i, bool loadAll=true)
	get ith diblock is RH list (which only includes diblocks with activity), starting with i=0. Set loadAll = false to prevent loading in pixel masks if not needed, as it can be very slow More...
int	NAPDInstalled ()
bool	IsDiBlockFullyInstrumented (int idb)
	returns true if nInstrumentedFEBs in diblock (which counts FEBs that are instrumented, active, and unmasked only) is >= 700 More...
bool	HasAPD (const geo::OfflineChan &)
	basic check for if a channel should be live. Used by BadChannels. Checks if channel has instrumented APD, is active in run, and is not masked More...
bool	HasAPD (const daqchannelmap::dchan &)
bool	IsCooled (const geo::OfflineChan &)
bool	IsCooled (const daqchannelmap::dchan &)
int	GetThreshold (const geo::OfflineChan &, bool &)
int	GetThreshold (const daqchannelmap::dchan &, bool &)
int	GetPedestal (const geo::OfflineChan &, bool &)
int	GetPedestal (const daqchannelmap::dchan &, bool &)
FEB	GetFEB (geo::OfflineChan const &, bool &)
FEB	GetFEB (daqchannelmap::dchan const &, bool &)
float	GetGain (const geo::OfflineChan &, bool &)
float	GetGain (const daqchannelmap::dchan &, bool &)
float	GetPixelGain (geo::OfflineChan const &, bool &)
float	GetPixelGain (daqchannelmap::dchan const &, bool &)
std::vector< float >	GetPixelGains (geo::OfflineChan const &, bool &)
std::vector< float >	GetPixelGains (daqchannelmap::dchan const &, bool &)
std::vector< DQSubrunInfo >	GetDQSubrunInfo ()
void	SetDataType (nova::dbi::DataType dt)
void	SetAbort (bool abort)
void	SetAbortIfMissingRunInDB (bool abort)
nova::dbi::DataType	GetDataType ()
void	SetIsBad (geo::OfflineChan, bool, time_t)
bool	IsBad (geo::OfflineChan, time_t)
void	ClearBadChan ()
void	SetChanInfo (geo::OfflineChan, float, float, time_t)
float	Occupancy (geo::OfflineChan, time_t)
float	Coincidence (geo::OfflineChan, time_t)
void	ClearChanInfo ()
void	PrintChanInfo ()
std::string	BadChanVersion ()
void	SetBadChanVersion (std::string v)
int	NRetryLoads ()
void	SetNRetryLoads (int n)
void	SetDiBlockMaskTag (std::string s)
int	DetGainSetting ()
void	SetGainSettingTag (std::string tag)
std::string	GainSettingTag ()
bool	DetFineTimingSetting () const
void	SetVerbosity (int i)
int	Verbosity () const
void	SetCurrentSubrun (int isr)
int	CurrentSubrun () const
DataEpoch	GetDataEpoch ()

Protected Attributes
bool	_getDiBlockMaskFromCondb
std::string	_dbMaskTag

Private Member Functions
void	InvalidateCaches ()
	Call at new run/detector etc. More...
void	BuildMC ()
std::map< uint32_t, APDInfo >	PullAPDInfoFromDB ()
std::map< HardwareLocation, std::pair< FEBInfo, APDInfo > >	PullFEBInfoFromDB (std::map< uint32_t, APDInfo > apdinfomap)
void	MapHardwareToLocation ()

Private Attributes
std::map< int, int >	_diblockIndex
bool	_failedToFindRun
bool	_gotDAQRunHistory
bool	_gotPixelInfo
bool	_gotFEBMasks
bool	_gotPixelMasks
bool	_gotPedestals
bool	_gotHardwareInfo
bool	_gotAPDSettings
bool	_gotCoolingInfo
bool	_gotPOT
bool	_gotGoodDiBlockMask
bool	_timeQueries
bool	_timeParsing
bool	_analysisDiBlockMasking
bool	_useMasking
bool	_customMasking
bool	_isMC
bool	_abort
bool	_abortIfMissingRunInDB
bool	_gotDQSubrunInfo
bool	_gotDataEpoch
int	_customMask
int	_runNumber
int	_nsubrun
int	_nTotTrig
int	_nActiveChannels
int	_nTotalChannels
int	_nTotalFEBs
int	_nInstalledAPDs
int	_detId
nova::dbi::DataType	_dataType
int	_partition
int	_nDCMs
int	_nRetryLoads
int	_detGainSetting
int	_verbosity
int	_currentSR
float	_npot
float	_avgpot
std::string	_dbname
std::string	_dbhost
std::string	_dbuser
std::string	_dbport
std::string	_runType
std::string	_detGainTag
std::string	_detector
std::string	_tStart
std::string	_tEnd
std::string	_badChanVersion
std::vector< int >	_nEvtTrig
std::vector< DiBlock >	_dbList
std::vector< BNEVB >	_bnevbList
std::map< geo::OfflineChan, std::vector< BadChan_t > >	_badChan
std::map< geo::OfflineChan, std::vector< ChanInfo_t > >	_chanInfo
std::vector< Subrun >	_subrunList
std::vector< DQSubrunInfo >	_dqSRInfo
std::vector< int >	_ndRHCRunStart
std::vector< int >	_ndRHCRunStop
std::vector< int >	_fdRHCRunStart
std::vector< int >	_fdRHCRunStop
int64_t	_gCfgId
DataEpoch	_dataEpoch

Detailed Description

Utilities for accessing run history, calib. constants, etc.

Author

Jonathan Paley

Version

Revision

1.9

Date

2013/02/11 15:36:10

Definition at line 253 of file RunHistory.h.

Constructor & Destructor Documentation

nova::dbi::RunHistory::RunHistory

(

)

Definition at line 95 of file RunHistory.cxx.

References _analysisDiBlockMasking, _avgpot, _badChanVersion, _currentSR, _dataType, _dbMaskTag, _detGainTag, _fdRHCRunStart, _fdRHCRunStop, _getDiBlockMaskFromCondb, _ndRHCRunStart, _ndRHCRunStop, _nInstalledAPDs, _npot, _nRetryLoads, _runType, _timeParsing, _timeQueries, _verbosity, InvalidateCaches(), nova::dbi::kNDataType, novadaq::cnv::kUNKNOWN_DET, and SetDetector().

      : _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();
    }

nova::dbi::RunHistory::~RunHistory ( )

virtual

Definition at line 229 of file RunHistory.cxx.

    {
    }

nova::dbi::RunHistory::RunHistory	(	int	run,
		std::string	det
	)

Definition at line 140 of file RunHistory.cxx.

References _analysisDiBlockMasking, _avgpot, _badChanVersion, _currentSR, _dataType, _dbMaskTag, _detGainTag, _fdRHCRunStart, _fdRHCRunStop, _getDiBlockMaskFromCondb, _ndRHCRunStart, _ndRHCRunStop, _nInstalledAPDs, _npot, _nRetryLoads, _runType, _timeParsing, _timeQueries, _verbosity, InvalidateCaches(), nova::dbi::kNDataType, and SetDetector().

      : _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();
    }

nova::dbi::RunHistory::RunHistory	(	int	run,
		novadaq::cnv::DetId	detid
	)

Definition at line 185 of file RunHistory.cxx.

References _analysisDiBlockMasking, _avgpot, _badChanVersion, _currentSR, _dataType, _dbMaskTag, _detGainTag, _fdRHCRunStart, _fdRHCRunStop, _getDiBlockMaskFromCondb, _ndRHCRunStart, _ndRHCRunStop, _nInstalledAPDs, _npot, _nRetryLoads, _runType, _timeParsing, _timeQueries, _verbosity, InvalidateCaches(), nova::dbi::kNDataType, and SetDetector().

      : _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();
    }

Member Function Documentation

int nova::dbi::RunHistory::ApplyAnalysisDiBlockMask

(

const int

mask

)

const

converts normal mask to analysis rules mask (any continuous chunk of four or more diblocks kept)

Definition at line 1467 of file RunHistory.cxx.

Referenced by LoadGoodDiBlockMask().

    {

      // 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;
    }

float nova::dbi::RunHistory::AvgPOTPerSpill ( )

inline

Definition at line 392 of file RunHistory.h.

{ LoadPOT(); return _avgpot; }

std::string nova::dbi::RunHistory::BadChanVersion ( )

inline

Definition at line 464 of file RunHistory.h.

{ return _badChanVersion;}

void nova::dbi::RunHistory::BuildMC ( )

private

Definition at line 2669 of file RunHistory.cxx.

References _dbList, _detId, _diblockIndex, _gotAPDSettings, _gotCoolingInfo, _gotDAQRunHistory, _gotHardwareInfo, _gotPixelInfo, _gotPOT, _nsubrun, d, febshutoff_auto::db, nova::dbi::RunHistory::DiBlock::dcm, nova::dbi::RunHistory::DCM::diblock, nova::dbi::RunHistory::DCM::feb, nova::dbi::RunHistory::DiBlock::hasNoAPDs, nova::dbi::RunHistory::DCM::isActive, IsGoodDiBlock(), novadaq::cnv::kNEARDET, nova::dbi::RunHistory::DCM::nInstrumentedFEBs, nova::dbi::RunHistory::DiBlock::nInstrumentedFEBs, nova::dbi::RunHistory::DiBlock::num, and nova::dbi::RunHistory::DCM::position.

Referenced by LoadDAQRunHistory().

    {

      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;
    }

void nova::dbi::RunHistory::ClearBadChan ( )

inline

Definition at line 456 of file RunHistory.h.

{ _badChan.clear(); }

void nova::dbi::RunHistory::ClearChanInfo ( )

inline

Definition at line 461 of file RunHistory.h.

{ _chanInfo.clear(); }

float nova::dbi::RunHistory::Coincidence	(	geo::OfflineChan	chan,
		time_t	t
	)

Definition at line 2161 of file RunHistory.cxx.

References _chanInfo, febshutoff_auto::chan, MECModelEnuComparisons::i, and confusionMatrixTree::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.;
    }

int nova::dbi::RunHistory::CurrentSubrun ( ) const

inline

Definition at line 482 of file RunHistory.h.

{ return _currentSR; }

std::string nova::dbi::RunHistory::Detector ( ) const

inline

Definition at line 376 of file RunHistory.h.

Referenced by comi::NearlineAna::analyze(), nova::dbi::RunHistoryService::preBeginRun(), nova::dbi::RunHistoryService::preBeginSubrun(), and ifdb::IFDBSpillInfo::produce().

{ return _detector; }

bool nova::dbi::RunHistory::DetFineTimingSetting

(

)

const

Definition at line 1051 of file RunHistory.cxx.

References _detId, _runNumber, and novadaq::cnv::kFARDET.

Referenced by caf::CAFMaker::produce().

    {
      // 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;
    }

int nova::dbi::RunHistory::DetGainSetting

(

)

Definition at line 1007 of file RunHistory.cxx.

References _abort, _detector, _detGainSetting, _detGainTag, _runNumber, _timeParsing, _timeQueries, _verbosity, om::cerr, novadaq::cnv::DetInfo::DetNameOk(), allTimeWatchdog::endl, nova::dbi::kDataOnly, nova::dbi::kMCOnly, LOG_ERROR, LOG_INFO, LOG_WARNING, and confusionMatrixTree::t.

Referenced by rsim::CommonParameters::CommonParameters(), calib::Calibrator::postBeginRun(), and caf::CAFMaker::produce().

    {
      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;
    }

std::string nova::dbi::RunHistory::DiBlockMaskToString

(

const int

mask

)

const

Definition at line 1446 of file RunHistory.cxx.

References string.

Referenced by LoadGoodDiBlockMask(), nova::dbi::RunHistoryService::preBeginRun(), and nova::dbi::RunHistoryService::preBeginSubrun().

    {
      std::string answer = "";
      for (int iD=0;iD<14;iD++) {
        if (mask&(1<<(iD))) {
          answer += "#";
        }
        else {
          answer += "-";
        }
      }
      return answer;
    }

void nova::dbi::RunHistory::Dump

(

)

Definition at line 2234 of file RunHistory.cxx.

References _bnevbList, _dbList, _nActiveChannels, _nsubrun, _nTotalChannels, _nTotTrig, _runNumber, om::cout, febshutoff_auto::dcm, allTimeWatchdog::endl, MECModelEnuComparisons::i, calib::j, NLiveDCMs(), TStartAsString(), and TStopAsString().

                          {
      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;
      
    }

int nova::dbi::RunHistory::Duration ( )

inline

in units of seconds

Definition at line 389 of file RunHistory.h.

Referenced by mono::DataCheckMonopole::endSubRun(), photrans::ImprovedTransport::StepAlongHit(), and calib::Calibrator::SystematicUncertaintyScale().

std::string nova::dbi::RunHistory::GainSettingTag ( )

inline

Definition at line 474 of file RunHistory.h.

{return _detGainTag;}

std::vector<BNEVB> nova::dbi::RunHistory::GetBNEVBList ( )

inline

Definition at line 398 of file RunHistory.h.

References sr.

Referenced by zcl::FmmTrackerAna::endJob(), and mono::DataCheckMonopole::farm70_in_configuration().

{ return _bnevbList; }

int nova::dbi::RunHistory::GetConfiguration

(

)

Definition at line 1413 of file RunHistory.cxx.

References _dbList, _detector, gen_hdf5record::config, runNovaSAM::detId, novadaq::cnv::DetInfo::GetId(), MECModelEnuComparisons::i, novadaq::cnv::kFARDET, novadaq::cnv::kNEARDET, and LoadHardwareInfo().

Referenced by remid::ReMIdTrain::analyze(), numue::NumuEAna::analyze(), skim::CellHitSkimmer::CheckEvent(), skim::Evaluator::CheckSliceQuality(), skim::CosmicBeamComparison::FillNumuHistograms(), skim::ParametersNue::ParametersNue(), and skim::ParametersNumu::ParametersNumu().

    {
      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;
    }

DataEpoch nova::dbi::RunHistory::GetDataEpoch ( )

inline

Definition at line 484 of file RunHistory.h.

Referenced by skim::CellHitSkimmer::endRun(), and skim::POTSummary::event().

{ LoadDataEpoch(); return _dataEpoch; }

nova::dbi::DataType nova::dbi::RunHistory::GetDataType ( )

inline

Definition at line 452 of file RunHistory.h.

Referenced by calib::AttenFit::beginRun(), calib::DCMTimingOffset::beginRun(), and geo::LiveGeometry::SetInstrumentation().

{ return _dataType; }

RunHistory::DiBlock nova::dbi::RunHistory::GetDiBlock	(	int	i,
		bool	loadAll = true
	)

get ith diblock is RH list (which only includes diblocks with activity), starting with i=0. Set loadAll = false to prevent loading in pixel masks if not needed, as it can be very slow

Definition at line 1760 of file RunHistory.cxx.

References _dbList, allTimeWatchdog::endl, MECModelEnuComparisons::i, LoadAllDetInfo(), LoadHardwareInfo(), and LOG_ERROR.

Referenced by chaninfo::BadChanValidate::BadChansFromOM(), calib::PEResponse::beginRun(), comi::NearlineAna::beginRun(), comi::DataCheck::beginSubRun(), comi::DataCheck::endJob(), GetFEB(), geo::LiveGeometry::GetRHInfo(), chaninfo::BadChanList::NBadInSubRun(), and geo::LiveGeometry::SetInstrumentation().

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

bool nova::dbi::RunHistory::GetDiBlockMaskFromCondb ( ) const

inline

Definition at line 368 of file RunHistory.h.

Referenced by calhit::RemoveBadChannels::beginRun(), calhit::CalHit::beginRun(), caf::CAFMaker::beginRun(), calhit::RemoveBadChannels::beginSubRun(), calhit::CalHit::beginSubRun(), and caf::CAFMaker::beginSubRun().

{ return _getDiBlockMaskFromCondb; }

std::vector< DQSubrunInfo > nova::dbi::RunHistory::GetDQSubrunInfo

(

)

Definition at line 2072 of file RunHistory.cxx.

References _detector, _dqSRInfo, nova::dbi::DQSubrunInfo::_flag, _gotDQSubrunInfo, nova::dbi::DQSubrunInfo::_miprate, nova::dbi::DQSubrunInfo::_ngooddb, nova::dbi::DQSubrunInfo::_numslc, nova::dbi::DQSubrunInfo::_run, _runNumber, nova::dbi::DQSubrunInfo::_subrun, nova::dbi::DQSubrunInfo::_trkfrac, _verbosity, nova::dbi::DQSubrunInfo::_version, MECModelEnuComparisons::i, and string.

    {
      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;
    }

RunHistory::FEB nova::dbi::RunHistory::GetFEB	(	geo::OfflineChan const &	oChan,
		bool &	ok
	)

Definition at line 1927 of file RunHistory.cxx.

References _detId, geo::OfflineChan::Cell(), daqchannelmap::DAQChannelMap::encodeDChan(), daqchannelmap::DAQChannelMap::encodeLChan(), daqchannelmap::DAQChannelMap::getInstance(), and geo::OfflineChan::Plane().

Referenced by GetGain(), GetPixelGain(), and GetPixelGains().

    {
      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);
    }

RunHistory::FEB nova::dbi::RunHistory::GetFEB	(	daqchannelmap::dchan const &	daqChan,
		bool &	ok
	)

Definition at line 1884 of file RunHistory.cxx.

References _dbList, _detId, nova::dbi::RunHistory::DiBlock::dcm, APDHVSetting::feb, nova::dbi::RunHistory::DCM::feb, nova::dbi::RunHistory::DCM::febMask, daqchannelmap::DAQChannelMap::getDCM(), daqchannelmap::DAQChannelMap::getDiBlock(), GetDiBlock(), daqchannelmap::DAQChannelMap::getFEB(), daqchannelmap::DAQChannelMap::getInstance(), nova::dbi::RunHistory::FEB::hasAPD, nova::dbi::RunHistory::DiBlock::hasNoAPDs, nova::dbi::RunHistory::FEB::isEnabled, LoadAPDSettings(), num, and nova::dbi::RunHistory::DCM::position.

    {
      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;
    }

float nova::dbi::RunHistory::GetGain	(	const geo::OfflineChan &	oChan,
		bool &	ok
	)

Definition at line 1951 of file RunHistory.cxx.

References _detId, geo::OfflineChan::Cell(), daqchannelmap::DAQChannelMap::encodeDChan(), daqchannelmap::DAQChannelMap::encodeLChan(), daqchannelmap::DAQChannelMap::getInstance(), and geo::OfflineChan::Plane().

    {
      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 nova::dbi::RunHistory::GetGain	(	const daqchannelmap::dchan &	daqChan,
		bool &	ok
	)

Definition at line 1939 of file RunHistory.cxx.

References APDHVSetting::feb, nova::dbi::RunHistory::FEB::gain, and GetFEB().

    {
      float gain=0.;

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

      if(ok) return feb.gain;

      return gain;
    }

int nova::dbi::RunHistory::GetPedestal	(	const geo::OfflineChan &	oChan,
		bool &	ok
	)

Definition at line 632 of file RunHistory.cxx.

References _abort, _dbList, _detId, _diblockIndex, geo::OfflineChan::Cell(), febshutoff_auto::dcm, daqchannelmap::DAQChannelMap::encodeDChan(), daqchannelmap::DAQChannelMap::encodeLChan(), APDHVSetting::feb, daqchannelmap::DAQChannelMap::getDCM(), daqchannelmap::DAQChannelMap::getDiBlock(), daqchannelmap::DAQChannelMap::getFEB(), daqchannelmap::DAQChannelMap::getInstance(), daqchannelmap::DAQChannelMap::getPixel(), makeTrainCVSamples::int, LoadDAQRunHistory(), LoadFEBMasks(), LoadHardwareInfo(), LoadPedestals(), and geo::OfflineChan::Plane().

Referenced by rsim::IFPGAAlgorithm::FetchThresholds(), and chaninfo::BadChanList::IsBadUncached().

    {
      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 nova::dbi::RunHistory::GetPedestal	(	const daqchannelmap::dchan &	daqChan,
		bool &	ok
	)

Definition at line 669 of file RunHistory.cxx.

References _abort, _dbList, _detId, _diblockIndex, febshutoff_auto::dcm, APDHVSetting::feb, daqchannelmap::DAQChannelMap::getDCM(), daqchannelmap::DAQChannelMap::getDiBlock(), daqchannelmap::DAQChannelMap::getFEB(), daqchannelmap::DAQChannelMap::getInstance(), daqchannelmap::DAQChannelMap::getPixel(), makeTrainCVSamples::int, LoadDAQRunHistory(), LoadFEBMasks(), LoadHardwareInfo(), LoadPedestals(), and LoadPixelMasks().

    {
      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;

    }

float nova::dbi::RunHistory::GetPixelGain	(	geo::OfflineChan const &	oChan,
		bool &	ok
	)

Definition at line 1974 of file RunHistory.cxx.

References _detId, geo::OfflineChan::Cell(), daqchannelmap::DAQChannelMap::encodeDChan(), daqchannelmap::DAQChannelMap::encodeLChan(), daqchannelmap::DAQChannelMap::getInstance(), and geo::OfflineChan::Plane().

    {
      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);
    }

float nova::dbi::RunHistory::GetPixelGain	(	daqchannelmap::dchan const &	daqChan,
		bool &	ok
	)

Definition at line 1961 of file RunHistory.cxx.

References _detId, APDHVSetting::feb, GetFEB(), daqchannelmap::DAQChannelMap::getInstance(), daqchannelmap::DAQChannelMap::getPixel(), and nova::dbi::RunHistory::FEB::pixelGain.

    {

      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.;
    }

std::vector< float > nova::dbi::RunHistory::GetPixelGains	(	geo::OfflineChan const &	oChan,
		bool &	ok
	)

Definition at line 1997 of file RunHistory.cxx.

References _detId, geo::OfflineChan::Cell(), daqchannelmap::DAQChannelMap::encodeDChan(), daqchannelmap::DAQChannelMap::encodeLChan(), daqchannelmap::DAQChannelMap::getInstance(), and geo::OfflineChan::Plane().

    {
      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);
    }

std::vector< float > nova::dbi::RunHistory::GetPixelGains	(	daqchannelmap::dchan const &	daqChan,
		bool &	ok
	)

Definition at line 1985 of file RunHistory.cxx.

References APDHVSetting::feb, GetFEB(), and nova::dbi::RunHistory::FEB::pixelGain.

    {

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

int nova::dbi::RunHistory::GetThreshold	(	const geo::OfflineChan &	oChan,
		bool &	ok
	)

Definition at line 2057 of file RunHistory.cxx.

References _detId, _gotPixelInfo, geo::OfflineChan::Cell(), daqchannelmap::DAQChannelMap::encodeDChan(), daqchannelmap::DAQChannelMap::encodeLChan(), daqchannelmap::DAQChannelMap::getInstance(), LoadPixelInfo(), geo::OfflineChan::Plane(), and dump_to_simple_cpp::threshold.

    {
      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;
    }

int nova::dbi::RunHistory::GetThreshold	(	const daqchannelmap::dchan &	daqChan,
		bool &	ok
	)

Definition at line 2008 of file RunHistory.cxx.

References _dbList, _detId, _gotPixelInfo, nova::dbi::RunHistory::DCM::feb, nova::dbi::RunHistory::DCM::febMask, daqchannelmap::DAQChannelMap::getDCM(), daqchannelmap::DAQChannelMap::getDiBlock(), daqchannelmap::DAQChannelMap::getFEB(), daqchannelmap::DAQChannelMap::getInstance(), daqchannelmap::DAQChannelMap::getPixel(), nova::dbi::RunHistory::FEB::hasAPD, nova::dbi::RunHistory::FEB::isEnabled, LoadPixelInfo(), num, nova::dbi::RunHistory::FEB::pixelMask, nova::dbi::RunHistory::FEB::pixelThresh, nova::dbi::RunHistory::DCM::position, and dump_to_simple_cpp::threshold.

    {
      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 nova::dbi::RunHistory::GoodDiBlockMask	(	int	subrun = -1,
		bool	reload = false
	)

Definition at line 1167 of file RunHistory.cxx.

References _currentSR, _getDiBlockMaskFromCondb, _gotGoodDiBlockMask, _subrunList, allTimeWatchdog::endl, LoadGoodDiBlockMask(), LOG_WARNING, and getGoodRuns4SAM::subrun.

Referenced by remid::ReMIdTrain::analyze(), numue::NumuEAna::analyze(), calhit::RemoveBadChannels::beginRun(), calhit::CalHit::beginRun(), caf::CAFMaker::beginRun(), calhit::RemoveBadChannels::beginSubRun(), calhit::CalHit::beginSubRun(), caf::CAFMaker::beginSubRun(), skim::CellHitSkimmer::CheckEvent(), skim::Evaluator::CheckSliceQuality(), CondenseRunList(), skim::CosmicBeamComparison::FillNumuHistograms(), caf::CAFMaker::FillSpillVars(), skim::ParametersNue::ParametersNue(), skim::ParametersNumu::ParametersNumu(), nova::dbi::RunHistoryService::preBeginRun(), nova::dbi::RunHistoryService::preBeginSubrun(), and caf::CAFMaker::produce().

    {
      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 nova::dbi::RunHistory::HasAPD

(

const geo::OfflineChan &

oChan

)

basic check for if a channel should be live. Used by BadChannels. Checks if channel has instrumented APD, is active in run, and is not masked

Definition at line 1802 of file RunHistory.cxx.

References _detId, geo::OfflineChan::Cell(), daqchannelmap::DAQChannelMap::encodeDChan(), daqchannelmap::DAQChannelMap::encodeLChan(), daqchannelmap::DAQChannelMap::getInstance(), and geo::OfflineChan::Plane().

Referenced by chaninfo::BadChanList::IsBadUncached().

    {
      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 nova::dbi::RunHistory::HasAPD

(

const daqchannelmap::dchan &

daqChan

)

Definition at line 1772 of file RunHistory.cxx.

References _dbList, _detId, _gotHardwareInfo, _runNumber, _useMasking, febshutoff_auto::dcm, daqchannelmap::DAQChannelMap::getDCM(), daqchannelmap::DAQChannelMap::getDiBlock(), daqchannelmap::DAQChannelMap::getFEB(), daqchannelmap::DAQChannelMap::getInstance(), MECModelEnuComparisons::i, IsGoodDiBlock(), LoadHardwareInfo(), and num.

    {
      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;
    }

void nova::dbi::RunHistory::InvalidateCaches ( )

private

Call at new run/detector etc.

Definition at line 2257 of file RunHistory.cxx.

References _avgpot, _bnevbList, _customMask, _dbList, _detGainSetting, _diblockIndex, _failedToFindRun, _gotAPDSettings, _gotCoolingInfo, _gotDAQRunHistory, _gotDataEpoch, _gotDQSubrunInfo, _gotFEBMasks, _gotGoodDiBlockMask, _gotHardwareInfo, _gotPedestals, _gotPixelInfo, _gotPixelMasks, _gotPOT, _isMC, _nActiveChannels, _nInstalledAPDs, _npot, _nsubrun, _nTotalChannels, _nTotalFEBs, _nTotTrig, and _subrunList.

Referenced by RunHistory(), SetDetector(), and SetRunNumber().

    {
      _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();
    }

bool nova::dbi::RunHistory::IsBad	(	geo::OfflineChan	chan,
		time_t	t
	)

Definition at line 2185 of file RunHistory.cxx.

References _badChan, febshutoff_auto::chan, MECModelEnuComparisons::i, and confusionMatrixTree::t.

    {
      unsigned int i=0;
      for (; i<_badChan[chan].size() && _badChan[chan][i].tstart<t; ++i);
      return _badChan[chan][i-1].isBad;
    }

bool nova::dbi::RunHistory::IsCooled

(

const geo::OfflineChan &

oChan

)

Definition at line 1874 of file RunHistory.cxx.

References _detId, geo::OfflineChan::Cell(), daqchannelmap::DAQChannelMap::encodeDChan(), daqchannelmap::DAQChannelMap::encodeLChan(), daqchannelmap::DAQChannelMap::getInstance(), and geo::OfflineChan::Plane().

    {
      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);
    }

bool nova::dbi::RunHistory::IsCooled

(

const daqchannelmap::dchan &

daqChan

)

Definition at line 1834 of file RunHistory.cxx.

References _dbList, _detId, om::cerr, febshutoff_auto::dcm, allTimeWatchdog::endl, APDHVSetting::feb, daqchannelmap::DAQChannelMap::getDCM(), daqchannelmap::DAQChannelMap::getDiBlock(), daqchannelmap::DAQChannelMap::getFEB(), daqchannelmap::DAQChannelMap::getInstance(), nova::dbi::RunHistory::FEB::hasAPD, nova::dbi::RunHistory::FEB::isCooled, nova::dbi::RunHistory::FEB::isEnabled, LoadPixelInfo(), and num.

    {
      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 nova::dbi::RunHistory::IsDiBlockFullyInstrumented

(

int

idb

)

returns true if nInstrumentedFEBs in diblock (which counts FEBs that are instrumented, active, and unmasked only) is >= 700

Definition at line 1814 of file RunHistory.cxx.

References _dbList, _detector, runNovaSAM::detId, novadaq::cnv::DetInfo::GetId(), MECModelEnuComparisons::i, novadaq::cnv::kFARDET, novadaq::cnv::kNEARDET, LoadHardwareInfo(), and num.

Referenced by comi::NearlineAna::beginRun(), and geo::LiveGeometry::SetInstrumentation().

    {
      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 nova::dbi::RunHistory::IsGoodDiBlock	(	int	idb,
		int	subrun = -1
	)

< 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

Definition at line 1188 of file RunHistory.cxx.

References _currentSR, _getDiBlockMaskFromCondb, _subrunList, _useMasking, allTimeWatchdog::endl, LoadGoodDiBlockMask(), LOG_WARNING, and x1.

Referenced by BuildMC(), HasAPD(), LoadHardwareInfo(), NAnalysisChannels(), NAnalysisDiBlocks(), and chaninfo::BadChanList::NBadInSubRun().

    {
      
      ///< 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 nova::dbi::RunHistory::IsRHC

(

)

Definition at line 354 of file RunHistory.cxx.

References _detId, _fdRHCRunStart, _fdRHCRunStop, _ndRHCRunStart, _ndRHCRunStop, _runNumber, om::cerr, allTimeWatchdog::endl, MECModelEnuComparisons::i, novadaq::cnv::kFARDET, and novadaq::cnv::kNEARDET.

Referenced by ifdb::IFDBSpillInfo::produce().

    {
      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 nova::dbi::RunHistory::LoadAllDetInfo ( )

inline

Definition at line 349 of file RunHistory.h.

Referenced by GetDiBlock().

                            { return (LoadDAQRunHistory() && 
                                      LoadHardwareInfo() &&
                                      LoadPixelInfo() && 
                                      LoadAPDSettings()); };

bool nova::dbi::RunHistory::LoadAPDSettings

(

)

Definition at line 1070 of file RunHistory.cxx.

References _dbList, _detector, _gCfgId, _gotAPDSettings, _nInstalledAPDs, std::abs(), febshutoff_auto::apd, nova::dbi::RunHistory::FEB::apdV, febshutoff_auto::dcm, runNovaSAM::detId, MakeMiniprodValidationCuts::f, novadaq::cnv::DetInfo::GetId(), dbutils::dcs::APDSettings::getTemperature(), dbutils::dcs::APDSettings::getTemperatureEnable(), dbutils::dcs::APDSettings::getVoltage(), novadaq::cnv::kFARDET, LoadDAQRunHistory(), LoadHardwareInfo(), LOG_WARNING, MapHardwareToLocation(), num, string, APDHVSetting::temp, nova::dbi::RunHistory::FEB::tempEnabled, and nova::dbi::RunHistory::FEB::temperature.

Referenced by GetFEB().

    {
      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;
    }

bool nova::dbi::RunHistory::LoadCoolingInfo

(

)

Definition at line 992 of file RunHistory.cxx.

References _gotCoolingInfo.

    {
      if (_gotCoolingInfo) return true;

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

      return false;
    }

bool nova::dbi::RunHistory::LoadDAQRunHistory

(

)

Definition at line 1551 of file RunHistory.cxx.

References _abort, _abortIfMissingRunInDB, _bnevbList, _dbList, _detector, _diblockIndex, _failedToFindRun, _gCfgId, _gotDAQRunHistory, _isMC, _nActiveChannels, _nDCMs, _nsubrun, _partition, _runNumber, _runType, _tEnd, _timeParsing, _timeQueries, _tStart, _verbosity, nova::dbi::RunHistory::DCM::appname, nova::dbi::RunHistory::BNEVB::appname, b, BuildMC(), om::cerr, nova::dbi::Row::Col(), d, febshutoff_auto::db, nova::dbi::RunHistory::DiBlock::dcm, runNovaSAM::detector, runNovaSAM::detId, novadaq::cnv::DetInfo::DetNameOk(), nova::dbi::RunHistory::DCM::diblock, allTimeWatchdog::endl, nova::dbi::RunHistory::DCM::feb, Get, nova::dbi::Column::Get(), novadaq::cnv::DetInfo::GetId(), nova::dbi::RunHistory::DiBlock::hasNoAPDs, MECModelEnuComparisons::i, nova::dbi::RunHistory::DCM::isActive, novadaq::cnv::kFARDET, novadaq::cnv::kNEARDET, LOG_ERROR, LOG_INFO, nova::dbi::RunHistory::DCM::nInstrumentedFEBs, nova::dbi::RunHistory::DiBlock::nInstrumentedFEBs, num, nova::dbi::RunHistory::DiBlock::num, elec2geo::pos, nova::dbi::RunHistory::DCM::position, check_grl::row, nova::dbi::SortDiBlocks(), and string.

Referenced by comi::NearlineAna::beginRun(), comi::DataCheck::beginSubRun(), comi::DataCheck::endJob(), GetPedestal(), LoadAPDSettings(), LoadFEBMasks(), LoadFEBMasksFromDAQDB(), LoadHardwareInfo(), LoadPedestals(), LoadPixelInfo(), LoadPixelMasks(), NAnalysisChannels(), NAnalysisDiBlocks(), SubrunTStart(), SubrunTStop(), TStart(), and TStop().

    {
      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;
    }

bool nova::dbi::RunHistory::LoadDataEpoch

(

)

Definition at line 1214 of file RunHistory.cxx.

References _dataEpoch, _detector, _gotDataEpoch, _runNumber, _timeParsing, _timeQueries, _verbosity, novadaq::cnv::DetInfo::DetNameOk(), allTimeWatchdog::endl, MECModelEnuComparisons::i, LOG_ERROR, nova::dbi::DataEpoch::name, nova::dbi::DataEpoch::run_end, nova::dbi::DataEpoch::run_start, and confusionMatrixTree::t.

    {
      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 nova::dbi::RunHistory::LoadDCSAlarms

(

int

subrun = -1

)

Definition at line 399 of file RunHistory.cxx.

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

      return false;
    }

bool nova::dbi::RunHistory::LoadFEBMasks

(

)

Definition at line 785 of file RunHistory.cxx.

References _abort, _dbList, _detector, _gotFEBMasks, _runNumber, _timeParsing, _timeQueries, _verbosity, om::cerr, nova::dbi::Row::Col(), febshutoff_auto::dcm, runNovaSAM::detId, novadaq::cnv::DetInfo::DetNameOk(), allTimeWatchdog::endl, nova::dbi::Column::Get(), novadaq::cnv::DetInfo::GetId(), nova::dbi::kDataOnly, LoadDAQRunHistory(), LoadHardwareInfo(), LOG_ERROR, LOG_INFO, LOG_WARNING, check_grl::row, and confusionMatrixTree::t.

Referenced by GetPedestal(), LoadPedestals(), and LoadPixelMasks().

    {
      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 nova::dbi::RunHistory::LoadFEBMasksFromDAQDB

(

)

Definition at line 853 of file RunHistory.cxx.

References _dbList, _detector, _gCfgId, _gotFEBMasks, _gotPixelInfo, _nTotalChannels, _nTotalFEBs, febshutoff_auto::dcm, allTimeWatchdog::endl, dbutils::daqconfig::PixelEnableMasks::getFEBEnableMask(), dbutils::daqconfig::PixelEnableMasks::hasValidData(), MECModelEnuComparisons::i, calib::j, LoadDAQRunHistory(), LoadHardwareInfo(), LOG_INFO, and string.

    {
      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 nova::dbi::RunHistory::LoadGoodDiBlockMask

(

)

Definition at line 1273 of file RunHistory.cxx.

References _abort, _analysisDiBlockMasking, _customMask, _customMasking, _dbMaskTag, _detector, _getDiBlockMaskFromCondb, _gotGoodDiBlockMask, _runNumber, _subrunList, _timeParsing, _timeQueries, _useMasking, _verbosity, ApplyAnalysisDiBlockMask(), om::cerr, nova::dbi::Row::Col(), runNovaSAM::detId, novadaq::cnv::DetInfo::DetNameOk(), DiBlockMaskToString(), allTimeWatchdog::endl, nova::dbi::Column::Get(), novadaq::cnv::DetInfo::GetId(), nova::dbi::kDataOnly, novadaq::cnv::kFARDET, novadaq::cnv::kNEARDET, LOG_DEBUG, LOG_ERROR, LOG_INFO, LOG_WARNING, check_grl::row, string, and confusionMatrixTree::t.

Referenced by GoodDiBlockMask(), and IsGoodDiBlock().

    {
      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;
    }

bool nova::dbi::RunHistory::LoadHardwareInfo

(

)

Definition at line 412 of file RunHistory.cxx.

References _dbList, _detector, _diblockIndex, _gotHardwareInfo, _nInstalledAPDs, _nRetryLoads, _timeQueries, _tStart, _useMasking, _verbosity, om::cerr, febshutoff_auto::dcm, runNovaSAM::detId, novadaq::cnv::DetInfo::DetNameOk(), geo2elec::diblock, allTimeWatchdog::endl, APDHVSetting::feb, novadaq::cnv::DetInfo::GetId(), MECModelEnuComparisons::i, IsGoodDiBlock(), novadaq::cnv::kFARDET, nova::dbi::kHardwareTable, novadaq::cnv::kNEARDET, LoadDAQRunHistory(), LOG_ERROR, LOG_INFO, febshutoff_auto::query, and string.

Referenced by GetConfiguration(), GetDiBlock(), GetPedestal(), HasAPD(), IsDiBlockFullyInstrumented(), LoadAPDSettings(), LoadFEBMasks(), LoadFEBMasksFromDAQDB(), LoadPedestals(), LoadPixelInfo(), LoadPixelMasks(), NAnalysisChannels(), NAnalysisDiBlocks(), NDCMs(), and NLiveDCMs().

    {
      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 nova::dbi::RunHistory::LoadPedestals

(

)

Definition at line 541 of file RunHistory.cxx.

References _abort, _dbList, _detector, _gotPedestals, _runNumber, _timeParsing, _timeQueries, _verbosity, getBrightness::cell, om::cerr, febshutoff_auto::chan, nova::dbi::Row::Col(), febshutoff_auto::dcm, runNovaSAM::detId, novadaq::cnv::DetInfo::DetNameOk(), daqchannelmap::DAQChannelMap::encodeDChan(), daqchannelmap::DAQChannelMap::encodeLChan(), allTimeWatchdog::endl, nova::dbi::Column::Get(), daqchannelmap::DAQChannelMap::getCell(), novadaq::cnv::DetInfo::GetId(), daqchannelmap::DAQChannelMap::getInstance(), daqchannelmap::DAQChannelMap::getPlane(), ip, nova::dbi::kDataOnly, LoadDAQRunHistory(), LoadFEBMasks(), LoadHardwareInfo(), LoadPixelMasks(), LOG_ERROR, LOG_INFO, LOG_WARNING, NDAPDHVSetting::plane, check_grl::row, confusionMatrixTree::t, geo::OfflineChan::ToDBValidityChan(), and x1.

Referenced by GetPedestal().

    {
      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;
    }

bool nova::dbi::RunHistory::LoadPixelInfo

(

int

nAttempt = 0

)

Definition at line 903 of file RunHistory.cxx.

References _dbList, _detector, _gCfgId, _gotPixelInfo, _nRetryLoads, _nTotalChannels, _nTotalFEBs, om::cerr, febshutoff_auto::dcm, allTimeWatchdog::endl, MakeMiniprodValidationCuts::f, dbutils::daqconfig::PixelEnableMasks::febIsEnabled(), dbutils::daqconfig::PixelEnableMasks::getFEBEnableMask(), dbutils::daqconfig::PixelEnableMasks::getPixelEnableMask(), dbutils::daqconfig::PixelThresholds::getThresholdsForFEB(), dbutils::daqconfig::PixelThresholds::hasValidData(), dbutils::daqconfig::PixelEnableMasks::hasValidData(), MECModelEnuComparisons::i, nova::dbi::RunHistory::FEB::isEnabled, calib::j, LoadDAQRunHistory(), LoadHardwareInfo(), LOG_INFO, nova::dbi::RunHistory::FEB::nActivePix, nova::dbi::RunHistory::FEB::pixelMask, nova::dbi::RunHistory::FEB::pixelThresh, and string.

Referenced by calib::PEResponse::beginRun(), GetThreshold(), and IsCooled().

    {
      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 nova::dbi::RunHistory::LoadPixelMasks

(

)

Definition at line 709 of file RunHistory.cxx.

References _abort, _dbList, _detector, _gotPixelMasks, _runNumber, _timeParsing, _timeQueries, _verbosity, om::cerr, nova::dbi::Row::Col(), febshutoff_auto::dcm, runNovaSAM::detId, novadaq::cnv::DetInfo::DetNameOk(), allTimeWatchdog::endl, nova::dbi::Column::Get(), novadaq::cnv::DetInfo::GetId(), nova::dbi::kDataOnly, LoadDAQRunHistory(), LoadFEBMasks(), LoadHardwareInfo(), LOG_ERROR, LOG_INFO, LOG_WARNING, check_grl::row, and confusionMatrixTree::t.

Referenced by GetPedestal(), and LoadPedestals().

    {
      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 nova::dbi::RunHistory::LoadPOT

(

)

Definition at line 1511 of file RunHistory.cxx.

References _avgpot, _detector, _gotPOT, _npot, _runNumber, _timeParsing, _timeQueries, _verbosity, om::cerr, novadaq::cnv::DetInfo::DetNameOk(), and allTimeWatchdog::endl.

    {
      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;

    }

void nova::dbi::RunHistory::MapHardwareToLocation ( )

private

Definition at line 2628 of file RunHistory.cxx.

References nova::dbi::HardwareLocation::_dcm, nova::dbi::HardwareLocation::_detid, _detId, nova::dbi::HardwareLocation::_diblock, nova::dbi::HardwareLocation::_feb, nova::dbi::gLocToFA, calib::j, novadaq::cnv::kFARDET, LOG_DEBUG, PullAPDInfoFromDB(), and PullFEBInfoFromDB().

Referenced by LoadAPDSettings().

    {
      //       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;
    }

int nova::dbi::RunHistory::NActiveChannels ( )

inline

Definition at line 402 of file RunHistory.h.

Referenced by mono::DataCheckMonopole::endSubRun(), and geo::LiveGeometry::LiveDetectorVolume().

{ LoadDAQRunHistory(); return _nActiveChannels; }

int nova::dbi::RunHistory::NAnalysisChannels

(

int

sr = 0

)

Definition at line 285 of file RunHistory.cxx.

References _dbList, _subrunList, MECModelEnuComparisons::i, IsGoodDiBlock(), LoadDAQRunHistory(), LoadHardwareInfo(), and sr.

Referenced by caf::CAFMaker::produce().

    {
      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;
      
    }

int nova::dbi::RunHistory::NAnalysisDiBlocks

(

int

sr = 0

)

Definition at line 256 of file RunHistory.cxx.

References _dbList, _subrunList, MECModelEnuComparisons::i, IsGoodDiBlock(), LoadDAQRunHistory(), LoadHardwareInfo(), and 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;
      
    }

int nova::dbi::RunHistory::NAPDInstalled ( )

inline

Definition at line 413 of file RunHistory.h.

{ LoadHardwareInfo(); return _nInstalledAPDs; }

int nova::dbi::RunHistory::NBNEVBs ( )

inline

Definition at line 397 of file RunHistory.h.

Referenced by mono::DataCheckMonopole::endSubRun().

{ LoadDAQRunHistory(); return _bnevbList.size(); }

int nova::dbi::RunHistory::NDCMs

(

)

Definition at line 235 of file RunHistory.cxx.

References _gotHardwareInfo, _nDCMs, and LoadHardwareInfo().

Referenced by chaninfo::BadChanValidate::BadChansFromOM(), and caf::CAFMaker::FillSpillVars().

    {
      if (! _gotHardwareInfo) LoadHardwareInfo();
      return _nDCMs;
    }

int nova::dbi::RunHistory::NDiBlocks ( )

inline

gives number of active diblocks only, may be less than 14

Definition at line 394 of file RunHistory.h.

Referenced by chaninfo::BadChanValidate::BadChansFromOM(), calib::PEResponse::beginRun(), comi::NearlineAna::beginRun(), comi::DataCheck::beginSubRun(), comi::DataCheck::endJob(), mono::DataCheckMonopole::endSubRun(), geo::LiveGeometry::GetRHInfo(), chaninfo::BadChanList::NBadInSubRun(), and geo::LiveGeometry::SetInstrumentation().

int nova::dbi::RunHistory::NFEBs ( )

inline

Definition at line 404 of file RunHistory.h.

References getGoodRuns4SAM::subrun.

{ LoadPixelInfo(); return _nTotalFEBs; }

int nova::dbi::RunHistory::NLiveDCMs

(

)

Definition at line 243 of file RunHistory.cxx.

References _dbList, _gotHardwareInfo, febshutoff_auto::dcm, MECModelEnuComparisons::i, calib::j, and LoadHardwareInfo().

Referenced by Dump(), and mono::DataCheckMonopole::endSubRun().

    {
      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;
    }

float nova::dbi::RunHistory::NPOT ( )

inline

Definition at line 391 of file RunHistory.h.

Referenced by CondenseRunList().

{ LoadPOT(); return _npot; }

int nova::dbi::RunHistory::NRetryLoads ( )

inline

Definition at line 467 of file RunHistory.h.

{ return _nRetryLoads; }

int nova::dbi::RunHistory::NSubruns ( )

inline

Definition at line 375 of file RunHistory.h.

Referenced by mono::DataCheckMonopole::endSubRun(), chaninfo::BadChanList::IsBadUncached(), chaninfo::BadChanList::LoadNewData(), chaninfo::BadChanList::NBadInSubRun(), and chaninfo::BadChanList::postBeginSubRun().

{ LoadDAQRunHistory(); return _nsubrun; }

int nova::dbi::RunHistory::NTotalChannels ( )

inline

Definition at line 403 of file RunHistory.h.

{ LoadDAQRunHistory(); return _nTotalChannels; }

int nova::dbi::RunHistory::NTriggers ( )

inline

Definition at line 390 of file RunHistory.h.

Referenced by mono::DataCheckMonopole::endSubRun().

{ LoadDAQRunHistory(); return _nTotTrig; }

float nova::dbi::RunHistory::Occupancy	(	geo::OfflineChan	chan,
		time_t	t
	)

Definition at line 2147 of file RunHistory.cxx.

References _chanInfo, febshutoff_auto::chan, MECModelEnuComparisons::i, and confusionMatrixTree::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.;
    }

int nova::dbi::RunHistory::Partition ( )

inline

Definition at line 378 of file RunHistory.h.

Referenced by mono::DataCheckMonopole::endSubRun().

{ LoadDAQRunHistory(); return _partition;}

void nova::dbi::RunHistory::PrintChanInfo

(

)

Definition at line 2121 of file RunHistory.cxx.

References _chanInfo, geo::OfflineChan::Cell(), febshutoff_auto::chan, om::cout, allTimeWatchdog::endl, it, calib::j, and geo::OfflineChan::Plane().

    {
      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;
      }
    }

std::map< uint32_t, APDInfo > nova::dbi::RunHistory::PullAPDInfoFromDB ( )

private

Definition at line 2304 of file RunHistory.cxx.

References nova::dbi::APDInfo::_barcode, nova::dbi::APDInfo::_batch, _detector, _detId, nova::dbi::APDInfo::_installed, nova::dbi::APDInfo::_modcon, nova::dbi::APDInfo::_module, nova::dbi::APDInfo::_pixelGain, nova::dbi::APDInfo::_sn, nova::dbi::APDInfo::_temp, _timeQueries, _tStart, _verbosity, nova::dbi::APDInfo::_voltage, APDHVSetting::batch, col, daqchannelmap::DAQChannelMap::computeFiberInModule(), novadaq::cnv::DetInfo::DetNameOk(), daqchannelmap::DAQChannelMap::encodeDChan(), allTimeWatchdog::endl, daqchannelmap::DAQChannelMap::getInstance(), novadaq::cnv::kFARDET, nova::dbi::kHardwareTable, LOG_DEBUG, LOG_ERROR, LOG_INFO, nova::dbi::PerformPGQuery(), r(), check_grl::row, fillBadChanDBTables::SQL, and string.

Referenced by MapHardwareToLocation().

    {
      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")
<