nova::dbi::RunHistoryService Class Reference

Simple service to provide a RunHistory configured to the right run. More...

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

Inheritance diagram for nova::dbi::RunHistoryService:

Public Member Functions
	RunHistoryService (const fhicl::ParameterSet &pset, art::ActivityRegistry &reg)
virtual	~RunHistoryService ()
void	reconfigure (const fhicl::ParameterSet &pset)
void	preBeginRun (const art::Run &run)
void	preBeginSubrun (const art::SubRun &subrun)
void	SetDBInfo (std::string dbname="", std::string dbhost="", std::string user="", std::string port="")
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
int	fFakeRunNumber
bool	fTimeQueries
bool	fUseMasking
bool	fAnalysisDiBlockMasking
bool	fCustomMasking
std::vector< int >	fCustomMask
std::string	fCalHitLabel
bool	fAbort
bool	fAbortIfMissingRunInDB
bool	_getDiBlockMaskFromCondb
std::string	_dbMaskTag

Private Member Functions
void	SetRunNumber (int run)
void	SetDetector (const std::string &det)
void	SetDetector (novadaq::cnv::DetId det)

Detailed Description

Simple service to provide a RunHistory configured to the right run.

Definition at line 22 of file RunHistoryService.h.

Constructor & Destructor Documentation

nova::dbi::RunHistoryService::RunHistoryService	(	const fhicl::ParameterSet &	pset,
		art::ActivityRegistry &	reg
	)

Definition at line 30 of file RunHistory_service.cc.

References preBeginRun(), preBeginSubrun(), reconfigure(), art::ActivityRegistry::sPreBeginRun, and art::ActivityRegistry::sPreBeginSubRun.

  {
    reconfigure(pset);
    reg.sPreBeginRun.watch(this, &RunHistoryService::preBeginRun);
    reg.sPreBeginSubRun.watch(this, &RunHistoryService::preBeginSubrun);
  }

nova::dbi::RunHistoryService::~RunHistoryService ( )

virtual

Definition at line 40 of file RunHistory_service.cc.

  {
  }

Member Function Documentation

int nova::dbi::RunHistory::ApplyAnalysisDiBlockMask ( const int  mask ) const

inherited

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

inlineinherited

Definition at line 392 of file RunHistory.h.

{ LoadPOT(); return _avgpot; }

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

inlineinherited

Definition at line 464 of file RunHistory.h.

{ return _badChanVersion;}

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

inlineinherited

Definition at line 456 of file RunHistory.h.

{ _badChan.clear(); }

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

inlineinherited

Definition at line 461 of file RunHistory.h.

{ _chanInfo.clear(); }

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

inherited

Definition at line 2161 of file RunHistory.cxx.

References nova::dbi::RunHistory::_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

inlineinherited

Definition at line 482 of file RunHistory.h.

{ return _currentSR; }

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

inlineinherited

Definition at line 376 of file RunHistory.h.

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

{ return _detector; }

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

inherited

Definition at line 1051 of file RunHistory.cxx.

References nova::dbi::RunHistory::_detId, nova::dbi::RunHistory::_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 ( )

inherited

Definition at line 1007 of file RunHistory.cxx.

References nova::dbi::RunHistory::_abort, nova::dbi::RunHistory::_detector, nova::dbi::RunHistory::_detGainSetting, nova::dbi::RunHistory::_detGainTag, nova::dbi::RunHistory::_runNumber, nova::dbi::RunHistory::_timeParsing, nova::dbi::RunHistory::_timeQueries, nova::dbi::RunHistory::_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

inherited

Definition at line 1446 of file RunHistory.cxx.

References string.

Referenced by nova::dbi::RunHistory::LoadGoodDiBlockMask(), preBeginRun(), and 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 ( )

inherited

Definition at line 2234 of file RunHistory.cxx.

References nova::dbi::RunHistory::_bnevbList, nova::dbi::RunHistory::_dbList, nova::dbi::RunHistory::_nActiveChannels, nova::dbi::RunHistory::_nsubrun, nova::dbi::RunHistory::_nTotalChannels, nova::dbi::RunHistory::_nTotTrig, nova::dbi::RunHistory::_runNumber, om::cout, febshutoff_auto::dcm, allTimeWatchdog::endl, MECModelEnuComparisons::i, calib::j, nova::dbi::RunHistory::NLiveDCMs(), nova::dbi::RunHistory::TStartAsString(), and nova::dbi::RunHistory::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 ( )

inlineinherited

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 ( )

inlineinherited

Definition at line 474 of file RunHistory.h.

{return _detGainTag;}

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

inlineinherited

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 ( )

inherited

Definition at line 1413 of file RunHistory.cxx.

References nova::dbi::RunHistory::_dbList, nova::dbi::RunHistory::_detector, gen_hdf5record::config, runNovaSAM::detId, novadaq::cnv::DetInfo::GetId(), MECModelEnuComparisons::i, novadaq::cnv::kFARDET, novadaq::cnv::kNEARDET, and nova::dbi::RunHistory::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 ( )

inlineinherited

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 ( )

inlineinherited

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  )

inherited

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 nova::dbi::RunHistory::_dbList, allTimeWatchdog::endl, MECModelEnuComparisons::i, nova::dbi::RunHistory::LoadAllDetInfo(), nova::dbi::RunHistory::LoadHardwareInfo(), and LOG_ERROR.

Referenced by chaninfo::BadChanValidate::BadChansFromOM(), calib::PEResponse::beginRun(), comi::NearlineAna::beginRun(), comi::DataCheck::beginSubRun(), comi::DataCheck::endJob(), nova::dbi::RunHistory::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

inlineinherited

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 ( )

inherited

Definition at line 2072 of file RunHistory.cxx.

References nova::dbi::RunHistory::_detector, nova::dbi::RunHistory::_dqSRInfo, nova::dbi::DQSubrunInfo::_flag, nova::dbi::RunHistory::_gotDQSubrunInfo, nova::dbi::DQSubrunInfo::_miprate, nova::dbi::DQSubrunInfo::_ngooddb, nova::dbi::DQSubrunInfo::_numslc, nova::dbi::DQSubrunInfo::_run, nova::dbi::RunHistory::_runNumber, nova::dbi::DQSubrunInfo::_subrun, nova::dbi::DQSubrunInfo::_trkfrac, nova::dbi::RunHistory::_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  )

inherited

Definition at line 1927 of file RunHistory.cxx.

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

Referenced by nova::dbi::RunHistory::GetGain(), nova::dbi::RunHistory::GetPixelGain(), and nova::dbi::RunHistory::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  )

inherited

Definition at line 1884 of file RunHistory.cxx.

References nova::dbi::RunHistory::_dbList, nova::dbi::RunHistory::_detId, nova::dbi::RunHistory::DiBlock::dcm, APDHVSetting::feb, nova::dbi::RunHistory::DCM::feb, nova::dbi::RunHistory::DCM::febMask, daqchannelmap::DAQChannelMap::getDCM(), daqchannelmap::DAQChannelMap::getDiBlock(), nova::dbi::RunHistory::GetDiBlock(), daqchannelmap::DAQChannelMap::getFEB(), daqchannelmap::DAQChannelMap::getInstance(), nova::dbi::RunHistory::FEB::hasAPD, nova::dbi::RunHistory::DiBlock::hasNoAPDs, nova::dbi::RunHistory::FEB::isEnabled, nova::dbi::RunHistory::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  )

inherited

Definition at line 1951 of file RunHistory.cxx.

References nova::dbi::RunHistory::_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  )

inherited

Definition at line 1939 of file RunHistory.cxx.

References APDHVSetting::feb, nova::dbi::RunHistory::FEB::gain, and nova::dbi::RunHistory::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  )

inherited

Definition at line 632 of file RunHistory.cxx.

References nova::dbi::RunHistory::_abort, nova::dbi::RunHistory::_dbList, nova::dbi::RunHistory::_detId, nova::dbi::RunHistory::_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, nova::dbi::RunHistory::LoadDAQRunHistory(), nova::dbi::RunHistory::LoadFEBMasks(), nova::dbi::RunHistory::LoadHardwareInfo(), nova::dbi::RunHistory::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  )

inherited

Definition at line 669 of file RunHistory.cxx.

References nova::dbi::RunHistory::_abort, nova::dbi::RunHistory::_dbList, nova::dbi::RunHistory::_detId, nova::dbi::RunHistory::_diblockIndex, febshutoff_auto::dcm, APDHVSetting::feb, daqchannelmap::DAQChannelMap::getDCM(), daqchannelmap::DAQChannelMap::getDiBlock(), daqchannelmap::DAQChannelMap::getFEB(), daqchannelmap::DAQChannelMap::getInstance(), daqchannelmap::DAQChannelMap::getPixel(), makeTrainCVSamples::int, nova::dbi::RunHistory::LoadDAQRunHistory(), nova::dbi::RunHistory::LoadFEBMasks(), nova::dbi::RunHistory::LoadHardwareInfo(), nova::dbi::RunHistory::LoadPedestals(), and nova::dbi::RunHistory::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  )

inherited

Definition at line 1974 of file RunHistory.cxx.

References nova::dbi::RunHistory::_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  )

inherited

Definition at line 1961 of file RunHistory.cxx.

References nova::dbi::RunHistory::_detId, APDHVSetting::feb, nova::dbi::RunHistory::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  )

inherited

Definition at line 1997 of file RunHistory.cxx.

References nova::dbi::RunHistory::_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  )

inherited

Definition at line 1985 of file RunHistory.cxx.

References APDHVSetting::feb, nova::dbi::RunHistory::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  )

inherited

Definition at line 2057 of file RunHistory.cxx.

References nova::dbi::RunHistory::_detId, nova::dbi::RunHistory::_gotPixelInfo, geo::OfflineChan::Cell(), daqchannelmap::DAQChannelMap::encodeDChan(), daqchannelmap::DAQChannelMap::encodeLChan(), daqchannelmap::DAQChannelMap::getInstance(), nova::dbi::RunHistory::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  )

inherited

Definition at line 2008 of file RunHistory.cxx.

References nova::dbi::RunHistory::_dbList, nova::dbi::RunHistory::_detId, nova::dbi::RunHistory::_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, nova::dbi::RunHistory::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  )

inherited

Definition at line 1167 of file RunHistory.cxx.

References nova::dbi::RunHistory::_currentSR, nova::dbi::RunHistory::_getDiBlockMaskFromCondb, nova::dbi::RunHistory::_gotGoodDiBlockMask, nova::dbi::RunHistory::_subrunList, allTimeWatchdog::endl, nova::dbi::RunHistory::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(), preBeginRun(), 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 )

inherited

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 nova::dbi::RunHistory::_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 )

inherited

Definition at line 1772 of file RunHistory.cxx.

References nova::dbi::RunHistory::_dbList, nova::dbi::RunHistory::_detId, nova::dbi::RunHistory::_gotHardwareInfo, nova::dbi::RunHistory::_runNumber, nova::dbi::RunHistory::_useMasking, febshutoff_auto::dcm, daqchannelmap::DAQChannelMap::getDCM(), daqchannelmap::DAQChannelMap::getDiBlock(), daqchannelmap::DAQChannelMap::getFEB(), daqchannelmap::DAQChannelMap::getInstance(), MECModelEnuComparisons::i, nova::dbi::RunHistory::IsGoodDiBlock(), nova::dbi::RunHistory::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;
    }

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

inherited

Definition at line 2185 of file RunHistory.cxx.

References nova::dbi::RunHistory::_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 )

inherited

Definition at line 1874 of file RunHistory.cxx.

References nova::dbi::RunHistory::_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 )

inherited

Definition at line 1834 of file RunHistory.cxx.

References nova::dbi::RunHistory::_dbList, nova::dbi::RunHistory::_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, nova::dbi::RunHistory::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 )

inherited

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 nova::dbi::RunHistory::_dbList, nova::dbi::RunHistory::_detector, runNovaSAM::detId, novadaq::cnv::DetInfo::GetId(), MECModelEnuComparisons::i, novadaq::cnv::kFARDET, novadaq::cnv::kNEARDET, nova::dbi::RunHistory::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  )

inherited

< 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 nova::dbi::RunHistory::_currentSR, nova::dbi::RunHistory::_getDiBlockMaskFromCondb, nova::dbi::RunHistory::_subrunList, nova::dbi::RunHistory::_useMasking, allTimeWatchdog::endl, nova::dbi::RunHistory::LoadGoodDiBlockMask(), LOG_WARNING, and x1.

Referenced by nova::dbi::RunHistory::BuildMC(), nova::dbi::RunHistory::HasAPD(), nova::dbi::RunHistory::LoadHardwareInfo(), nova::dbi::RunHistory::NAnalysisChannels(), nova::dbi::RunHistory::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 ( )

inherited

Definition at line 354 of file RunHistory.cxx.

References nova::dbi::RunHistory::_detId, nova::dbi::RunHistory::_fdRHCRunStart, nova::dbi::RunHistory::_fdRHCRunStop, nova::dbi::RunHistory::_ndRHCRunStart, nova::dbi::RunHistory::_ndRHCRunStop, nova::dbi::RunHistory::_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 ( )

inlineinherited

Definition at line 349 of file RunHistory.h.

Referenced by nova::dbi::RunHistory::GetDiBlock().

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

bool nova::dbi::RunHistory::LoadAPDSettings ( )

inherited

Definition at line 1070 of file RunHistory.cxx.

References nova::dbi::RunHistory::_dbList, nova::dbi::RunHistory::_detector, nova::dbi::RunHistory::_gCfgId, nova::dbi::RunHistory::_gotAPDSettings, nova::dbi::RunHistory::_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, nova::dbi::RunHistory::LoadDAQRunHistory(), nova::dbi::RunHistory::LoadHardwareInfo(), LOG_WARNING, nova::dbi::RunHistory::MapHardwareToLocation(), num, string, APDHVSetting::temp, nova::dbi::RunHistory::FEB::tempEnabled, and nova::dbi::RunHistory::FEB::temperature.

Referenced by nova::dbi::RunHistory::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 ( )

inherited

Definition at line 992 of file RunHistory.cxx.

References nova::dbi::RunHistory::_gotCoolingInfo.

    {
      if (_gotCoolingInfo) return true;

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

      return false;
    }

bool nova::dbi::RunHistory::LoadDAQRunHistory ( )

inherited

Definition at line 1551 of file RunHistory.cxx.

References nova::dbi::RunHistory::_abort, nova::dbi::RunHistory::_abortIfMissingRunInDB, nova::dbi::RunHistory::_bnevbList, nova::dbi::RunHistory::_dbList, nova::dbi::RunHistory::_detector, nova::dbi::RunHistory::_diblockIndex, nova::dbi::RunHistory::_failedToFindRun, nova::dbi::RunHistory::_gCfgId, nova::dbi::RunHistory::_gotDAQRunHistory, nova::dbi::RunHistory::_isMC, nova::dbi::RunHistory::_nActiveChannels, nova::dbi::RunHistory::_nDCMs, nova::dbi::RunHistory::_nsubrun, nova::dbi::RunHistory::_partition, nova::dbi::RunHistory::_runNumber, nova::dbi::RunHistory::_runType, nova::dbi::RunHistory::_tEnd, nova::dbi::RunHistory::_timeParsing, nova::dbi::RunHistory::_timeQueries, nova::dbi::RunHistory::_tStart, nova::dbi::RunHistory::_verbosity, nova::dbi::RunHistory::DCM::appname, nova::dbi::RunHistory::BNEVB::appname, b, nova::dbi::RunHistory::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(), nova::dbi::RunHistory::GetPedestal(), nova::dbi::RunHistory::LoadAPDSettings(), nova::dbi::RunHistory::LoadFEBMasks(), nova::dbi::RunHistory::LoadFEBMasksFromDAQDB(), nova::dbi::RunHistory::LoadHardwareInfo(), nova::dbi::RunHistory::LoadPedestals(), nova::dbi::RunHistory::LoadPixelInfo(), nova::dbi::RunHistory::LoadPixelMasks(), nova::dbi::RunHistory::NAnalysisChannels(), nova::dbi::RunHistory::NAnalysisDiBlocks(), nova::dbi::RunHistory::SubrunTStart(), nova::dbi::RunHistory::SubrunTStop(), nova::dbi::RunHistory::TStart(), and nova::dbi::RunHistory::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 ( )

inherited

Definition at line 1214 of file RunHistory.cxx.

References nova::dbi::RunHistory::_dataEpoch, nova::dbi::RunHistory::_detector, nova::dbi::RunHistory::_gotDataEpoch, nova::dbi::RunHistory::_runNumber, nova::dbi::RunHistory::_timeParsing, nova::dbi::RunHistory::_timeQueries, nova::dbi::RunHistory::_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 )

inherited

Definition at line 399 of file RunHistory.cxx.

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

      return false;
    }

bool nova::dbi::RunHistory::LoadFEBMasks ( )

inherited

Definition at line 785 of file RunHistory.cxx.

References nova::dbi::RunHistory::_abort, nova::dbi::RunHistory::_dbList, nova::dbi::RunHistory::_detector, nova::dbi::RunHistory::_gotFEBMasks, nova::dbi::RunHistory::_runNumber, nova::dbi::RunHistory::_timeParsing, nova::dbi::RunHistory::_timeQueries, nova::dbi::RunHistory::_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, nova::dbi::RunHistory::LoadDAQRunHistory(), nova::dbi::RunHistory::LoadHardwareInfo(), LOG_ERROR, LOG_INFO, LOG_WARNING, check_grl::row, and confusionMatrixTree::t.

Referenced by nova::dbi::RunHistory::GetPedestal(), nova::dbi::RunHistory::LoadPedestals(), and nova::dbi::RunHistory::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 ( )

inherited

Definition at line 853 of file RunHistory.cxx.

References nova::dbi::RunHistory::_dbList, nova::dbi::RunHistory::_detector, nova::dbi::RunHistory::_gCfgId, nova::dbi::RunHistory::_gotFEBMasks, nova::dbi::RunHistory::_gotPixelInfo, nova::dbi::RunHistory::_nTotalChannels, nova::dbi::RunHistory::_nTotalFEBs, febshutoff_auto::dcm, allTimeWatchdog::endl, dbutils::daqconfig::PixelEnableMasks::getFEBEnableMask(), dbutils::daqconfig::PixelEnableMasks::hasValidData(), MECModelEnuComparisons::i, calib::j, nova::dbi::RunHistory::LoadDAQRunHistory(), nova::dbi::RunHistory::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 ( )

inherited

Definition at line 1273 of file RunHistory.cxx.

References nova::dbi::RunHistory::_abort, nova::dbi::RunHistory::_analysisDiBlockMasking, nova::dbi::RunHistory::_customMask, nova::dbi::RunHistory::_customMasking, nova::dbi::RunHistory::_dbMaskTag, nova::dbi::RunHistory::_detector, nova::dbi::RunHistory::_getDiBlockMaskFromCondb, nova::dbi::RunHistory::_gotGoodDiBlockMask, nova::dbi::RunHistory::_runNumber, nova::dbi::RunHistory::_subrunList, nova::dbi::RunHistory::_timeParsing, nova::dbi::RunHistory::_timeQueries, nova::dbi::RunHistory::_useMasking, nova::dbi::RunHistory::_verbosity, nova::dbi::RunHistory::ApplyAnalysisDiBlockMask(), om::cerr, nova::dbi::Row::Col(), runNovaSAM::detId, novadaq::cnv::DetInfo::DetNameOk(), nova::dbi::RunHistory::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 nova::dbi::RunHistory::GoodDiBlockMask(), and nova::dbi::RunHistory::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 ( )

inherited

Definition at line 412 of file RunHistory.cxx.

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

Referenced by nova::dbi::RunHistory::GetConfiguration(), nova::dbi::RunHistory::GetDiBlock(), nova::dbi::RunHistory::GetPedestal(), nova::dbi::RunHistory::HasAPD(), nova::dbi::RunHistory::IsDiBlockFullyInstrumented(), nova::dbi::RunHistory::LoadAPDSettings(), nova::dbi::RunHistory::LoadFEBMasks(), nova::dbi::RunHistory::LoadFEBMasksFromDAQDB(), nova::dbi::RunHistory::LoadPedestals(), nova::dbi::RunHistory::LoadPixelInfo(), nova::dbi::RunHistory::LoadPixelMasks(), nova::dbi::RunHistory::NAnalysisChannels(), nova::dbi::RunHistory::NAnalysisDiBlocks(), nova::dbi::RunHistory::NDCMs(), and nova::dbi::RunHistory::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 ( )

inherited

Definition at line 541 of file RunHistory.cxx.

References nova::dbi::RunHistory::_abort, nova::dbi::RunHistory::_dbList, nova::dbi::RunHistory::_detector, nova::dbi::RunHistory::_gotPedestals, nova::dbi::RunHistory::_runNumber, nova::dbi::RunHistory::_timeParsing, nova::dbi::RunHistory::_timeQueries, nova::dbi::RunHistory::_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, nova::dbi::RunHistory::LoadDAQRunHistory(), nova::dbi::RunHistory::LoadFEBMasks(), nova::dbi::RunHistory::LoadHardwareInfo(), nova::dbi::RunHistory::LoadPixelMasks(), LOG_ERROR, LOG_INFO, LOG_WARNING, NDAPDHVSetting::plane, check_grl::row, confusionMatrixTree::t, geo::OfflineChan::ToDBValidityChan(), and x1.

Referenced by nova::dbi::RunHistory::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 )

inherited

Definition at line 903 of file RunHistory.cxx.

References nova::dbi::RunHistory::_dbList, nova::dbi::RunHistory::_detector, nova::dbi::RunHistory::_gCfgId, nova::dbi::RunHistory::_gotPixelInfo, nova::dbi::RunHistory::_nRetryLoads, nova::dbi::RunHistory::_nTotalChannels, nova::dbi::RunHistory::_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, nova::dbi::RunHistory::LoadDAQRunHistory(), nova::dbi::RunHistory::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(), nova::dbi::RunHistory::GetThreshold(), and nova::dbi::RunHistory::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 ( )

inherited

Definition at line 709 of file RunHistory.cxx.

References nova::dbi::RunHistory::_abort, nova::dbi::RunHistory::_dbList, nova::dbi::RunHistory::_detector, nova::dbi::RunHistory::_gotPixelMasks, nova::dbi::RunHistory::_runNumber, nova::dbi::RunHistory::_timeParsing, nova::dbi::RunHistory::_timeQueries, nova::dbi::RunHistory::_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, nova::dbi::RunHistory::LoadDAQRunHistory(), nova::dbi::RunHistory::LoadFEBMasks(), nova::dbi::RunHistory::LoadHardwareInfo(), LOG_ERROR, LOG_INFO, LOG_WARNING, check_grl::row, and confusionMatrixTree::t.

Referenced by nova::dbi::RunHistory::GetPedestal(), and nova::dbi::RunHistory::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 ( )

inherited

Definition at line 1511 of file RunHistory.cxx.

References nova::dbi::RunHistory::_avgpot, nova::dbi::RunHistory::_detector, nova::dbi::RunHistory::_gotPOT, nova::dbi::RunHistory::_npot, nova::dbi::RunHistory::_runNumber, nova::dbi::RunHistory::_timeParsing, nova::dbi::RunHistory::_timeQueries, nova::dbi::RunHistory::_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;

    }

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

inlineinherited

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 )

inherited

Definition at line 285 of file RunHistory.cxx.

References nova::dbi::RunHistory::_dbList, nova::dbi::RunHistory::_subrunList, MECModelEnuComparisons::i, nova::dbi::RunHistory::IsGoodDiBlock(), nova::dbi::RunHistory::LoadDAQRunHistory(), nova::dbi::RunHistory::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 )

inherited

Definition at line 256 of file RunHistory.cxx.

References nova::dbi::RunHistory::_dbList, nova::dbi::RunHistory::_subrunList, MECModelEnuComparisons::i, nova::dbi::RunHistory::IsGoodDiBlock(), nova::dbi::RunHistory::LoadDAQRunHistory(), nova::dbi::RunHistory::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 ( )

inlineinherited

Definition at line 413 of file RunHistory.h.

{ LoadHardwareInfo(); return _nInstalledAPDs; }

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

inlineinherited

Definition at line 397 of file RunHistory.h.

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

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

int nova::dbi::RunHistory::NDCMs ( )

inherited

Definition at line 235 of file RunHistory.cxx.

References nova::dbi::RunHistory::_gotHardwareInfo, nova::dbi::RunHistory::_nDCMs, and nova::dbi::RunHistory::LoadHardwareInfo().

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

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

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

inlineinherited

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 ( )

inlineinherited

Definition at line 404 of file RunHistory.h.

References getGoodRuns4SAM::subrun.

{ LoadPixelInfo(); return _nTotalFEBs; }

int nova::dbi::RunHistory::NLiveDCMs ( )

inherited

Definition at line 243 of file RunHistory.cxx.

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

Referenced by nova::dbi::RunHistory::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 ( )

inlineinherited

Definition at line 391 of file RunHistory.h.

Referenced by CondenseRunList().

{ LoadPOT(); return _npot; }

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

inlineinherited

Definition at line 467 of file RunHistory.h.

{ return _nRetryLoads; }

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

inlineinherited

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 ( )

inlineinherited

Definition at line 403 of file RunHistory.h.

{ LoadDAQRunHistory(); return _nTotalChannels; }

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

inlineinherited

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  )

inherited

Definition at line 2147 of file RunHistory.cxx.

References nova::dbi::RunHistory::_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 ( )

inlineinherited

Definition at line 378 of file RunHistory.h.

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

{ LoadDAQRunHistory(); return _partition;}

void nova::dbi::RunHistoryService::preBeginRun

(

const art::Run &

run

)

Definition at line 68 of file RunHistory_service.cc.

References art::Run::beginTime(), nova::dbi::RunHistory::Detector(), ds::DetectorService::DetId(), nova::dbi::RunHistory::DiBlockMaskToString(), allTimeWatchdog::endl, fAbort, fAbortIfMissingRunInDB, art::Handle< T >::failedToGet(), fAnalysisDiBlockMasking, fCalHitLabel, fCustomMask, fCustomMasking, fFakeRunNumber, fTimeQueries, fUseMasking, art::DataViewImpl::getByLabel(), novadaq::cnv::DetInfo::GetId(), nova::dbi::RunHistory::GoodDiBlockMask(), MECModelEnuComparisons::i, nova::dbi::kDataOnly, novadaq::cnv::kFARDET, nova::dbi::kMCOnly, nova::dbi::kNDataType, novadaq::cnv::kNEARDET, LOG_DEBUG, LOG_INFO, LOG_WARNING, lem_server::mask, art::Run::run(), nova::dbi::RunHistory::SetAbort(), nova::dbi::RunHistory::SetAbortIfMissingRunInDB(), nova::dbi::RunHistory::SetAnalysisDiBlockMasking(), nova::dbi::RunHistory::SetCurrentSubrun(), nova::dbi::RunHistory::SetCustomMask(), nova::dbi::RunHistory::SetDataType(), nova::dbi::RunHistory::SetDetector(), nova::dbi::RunHistory::SetGoodDiBlockMask(), nova::dbi::RunHistory::SetIfAnyMasking(), nova::dbi::RunHistory::SetIfCustomMasking(), nova::dbi::RunHistory::SetRunNumber(), nova::dbi::RunHistory::SetTimeParsing(), nova::dbi::RunHistory::SetTimeQueries(), art::Timestamp::timeHigh(), art::Timestamp::timeLow(), and Munits::year.

Referenced by RunHistoryService().

  {
    art::ServiceHandle<ds::DetectorService> ds;
    RunHistory::SetDetector(ds->DetId(run));
    int runNumber = (fFakeRunNumber == 0) ? run.run() : fFakeRunNumber;

    RunHistory::SetRunNumber(runNumber);

    this->SetTimeQueries(fTimeQueries);
    this->SetTimeParsing(fTimeQueries);
    this->SetIfAnyMasking(fUseMasking);
    this->SetAnalysisDiBlockMasking(fAnalysisDiBlockMasking);
    this->SetIfCustomMasking(fCustomMasking);
    this->SetAbort(fAbort);
    this->SetAbortIfMissingRunInDB(fAbortIfMissingRunInDB);
    this->SetCurrentSubrun(0);

    // determine whether we are dealing with MC, data, or a mixture of the two
    // for now just test on the date of the file.  MC has a timestamp before 2010
    art::Timestamp ts = run.beginTime();
    
    // make it into a TTimeStamp
    TTimeStamp tts(ts.timeHigh(), ts.timeLow());
    
    // Get the year of the timestamp from YYYYMMDD format
    uint32_t year = tts.GetDate()/10000;
    
    this->SetDataType(nova::dbi::kNDataType);
    if(year < 2010) this->SetDataType(nova::dbi::kMCOnly);
    else            this->SetDataType(nova::dbi::kDataOnly);

    if (runNumber > 1000000 || runNumber < 10000) {
      this->SetDataType(nova::dbi::kMCOnly);
      this->SetIfAnyMasking(false);      
    }

    // get detector diblock masks

    if (novadaq::cnv::DetInfo::GetId(RunHistory::Detector()) == novadaq::cnv::kNEARDET) {
      this->SetIfAnyMasking(false);
    }

    if (novadaq::cnv::DetInfo::GetId(RunHistory::Detector()) == novadaq::cnv::kFARDET) { // only worry about masking for FD
      std::vector<bool> cmask;  // let people put 1s and 0s into fcl instead of trues and falses
      
      for(unsigned int i = 0; i < 14; i++) {
        if(fCustomMask[i] == 1) cmask.push_back(true);
        else cmask.push_back(false);
      }
      this->SetCustomMask(cmask);
      
      art::Handle<int> mask;
      run.getByLabel(fCalHitLabel,mask);
      
      if(mask.failedToGet()) {
        if(fCustomMasking) {
          LOG_WARNING("RunHistoryService") << "RunHistory: No mask in file.  Custom mask requested." << std::endl;
          RunHistory::GoodDiBlockMask();
        }
        else if(runNumber >= 1000000 || runNumber < 10000) {  // clear MC that can't access DB
          LOG_INFO("RunHistoryService") << __PRETTY_FUNCTION__
          << ": this looks like ideal conditions MC.  No mask applied: "
          << RunHistory::DiBlockMaskToString((1<<15)-1) << std::endl;
          RunHistory::GoodDiBlockMask();
        }
        else {
          if(fAbort) {
            if (!(RunHistory::GoodDiBlockMask()!=(1<<16)-1))
                // running in mode that absolutely requires a mask, and there was not one
              std::abort();
          }
          
           if(RunHistory::GoodDiBlockMask()==0)
             LOG_WARNING("RunHistoryService") << __PRETTY_FUNCTION__
             << ": did not find mask in file, using current fcl settings of: detector fully masked off! "
             << RunHistory::DiBlockMaskToString(0) << std::endl;
           else
             LOG_DEBUG("RunHistoryService") << __PRETTY_FUNCTION__
             << ": did not find mask in file, using current fcl settings of: "
             << RunHistory::DiBlockMaskToString(RunHistory::GoodDiBlockMask())
             << std::endl;
        }
      }
      else { // got mask from file
        // running in mode that absolutely requires a mask, and there was not one
        if(fAbort && runNumber < 1000000 && runNumber > 10000)  {if(!(*mask!= (1<<16)-1)) std::abort();}
        
        RunHistory::SetGoodDiBlockMask(*mask);
        if(*mask==0) {
          LOG_WARNING("RunHistoryService") << __PRETTY_FUNCTION__
          << ": found mask in file: detector fully masked off! "
          << RunHistory::DiBlockMaskToString(RunHistory::GoodDiBlockMask())
          << std::endl;
        }
        else if(*mask==(1<<16)-1) {
          LOG_WARNING("RunHistoryService") << __PRETTY_FUNCTION__
          << ": no run was found in good runs DB when this file was processed, "
          << "so we assume perfect.  LiveGeometry should still catch any empty "
          << "regions, but check badboxes in the event display to be sure."
          << std::endl;
        }
        else if(*mask==(1<<17)-1) {
          LOG_WARNING("RunHistoryService") << __PRETTY_FUNCTION__
          << ": masking was turned off when file was processed, so apply no mask. "
          << RunHistory::DiBlockMaskToString(RunHistory::GoodDiBlockMask())
          << std::endl;
        }
        else {
          LOG_INFO("RunHistoryService") << __PRETTY_FUNCTION__
          << ": found mask in file: "
          << RunHistory::DiBlockMaskToString(*mask) << std::endl;
        }
      }
    }

    return;
  }

void nova::dbi::RunHistoryService::preBeginSubrun

(

const art::SubRun &

subrun

)

Definition at line 187 of file RunHistory_service.cc.

References nova::dbi::RunHistory::_getDiBlockMaskFromCondb, DEFINE_ART_SERVICE, nova::dbi::RunHistory::Detector(), nova::dbi::RunHistory::DiBlockMaskToString(), allTimeWatchdog::endl, fAbort, art::Handle< T >::failedToGet(), fCalHitLabel, fCustomMasking, art::DataViewImpl::getByLabel(), novadaq::cnv::DetInfo::GetId(), nova::dbi::RunHistory::GoodDiBlockMask(), novadaq::cnv::kFARDET, LOG_DEBUG, LOG_ERROR, LOG_INFO, LOG_WARNING, lem_server::mask, nova::dbi::RunHistory::RunNumber(), nova::dbi::RunHistory::SetCurrentSubrun(), nova::dbi::RunHistory::SetSubrunDiBlockMask(), and art::SubRun::subRun().

Referenced by RunHistoryService().

  {
    if (novadaq::cnv::DetInfo::GetId(RunHistory::Detector()) != novadaq::cnv::kFARDET)  // only worry about masking for FD
      return;
    
    // don't do anything if we're not using subrun-by-subrun diblock masks
    if (!this->_getDiBlockMaskFromCondb) return;

    int isr = subrun.subRun();
    int runNumber = this->RunNumber();

    LOG_DEBUG("RunHistory")
    << "runNumber = " << runNumber;
    
    // use a realistic subrun number for ideal conditions
    if (runNumber >= 1000000) {
      isr = isr%64;
    }
    
    this->SetCurrentSubrun(isr);
    
    art::Handle<int> mask;
    subrun.getByLabel(fCalHitLabel,mask);

    if(mask.failedToGet()) {
      if(fCustomMasking) {
        LOG_WARNING("RunHistoryService") << __PRETTY_FUNCTION__
        << ": No mask in file.  Custom mask requested." << std::endl;
        RunHistory::GoodDiBlockMask();
      }
      else if(runNumber >= 1000000 || runNumber < 10000) {  // clear MC that can't access DB
        LOG_INFO("RunHistoryService") << __PRETTY_FUNCTION__ << ": this looks like ideal conditions MC.  No mask applied: "
        << RunHistory::DiBlockMaskToString((1<<15)-1) << std::endl;
        RunHistory::GoodDiBlockMask(isr);
      }
      else {
        // running in mode that absolutely requires a mask, and there was not one
        if(fAbort) {
          if (!(RunHistory::GoodDiBlockMask()!=(1<<16)-1)) {
            // running in mode that absolutely requires a mask, and there was not one
            LOG_ERROR("RunHistoryService") << __PRETTY_FUNCTION__ << ": failed to get subrun diblock mask, aborting." << std::endl;
            std::abort();
          }
          else
            LOG_DEBUG("RunHistoryService") << __PRETTY_FUNCTION__ << ": did not find subrun mask in file, using mask: "
            << RunHistory::DiBlockMaskToString(RunHistory::GoodDiBlockMask()) << std::endl;
        }
      }
    }
    else { // got mask from file
      
      if(fAbort && runNumber < 1000000 && runNumber > 10000)  {
        if (!(*mask!= (1<<16)-1))
          // running in mode that absolutely requires a mask, and there was not one
          std::abort();
      } 
      
      RunHistory::SetSubrunDiBlockMask(isr, *mask);
      if(*mask==0) {
        LOG_WARNING("RunHistoryService") << __PRETTY_FUNCTION__ << ": found subrun diblock mask in file: detector fully masked off! "
        << RunHistory::DiBlockMaskToString(RunHistory::GoodDiBlockMask(isr)) << std::endl;
      }
      else if(*mask==(1<<16)-1) {
        LOG_WARNING("RunHistoryService") << __PRETTY_FUNCTION__ << ": no run was found in good runs DB when this file was processed, "
        << "so we assume perfect.  LiveGeometry should still catch any empty regions, but check badboxes in "
        << "the event display to be sure."  << std::endl;
      }
      else if(*mask==(1<<17)-1) {
        LOG_WARNING("RunHistoryService") << __PRETTY_FUNCTION__ << ": masking was turned off when file was processed, so apply no mask. "
        << RunHistory::DiBlockMaskToString(RunHistory::GoodDiBlockMask(isr)) << std::endl;
      }
      else {
        LOG_INFO("RunHistoryService") << __PRETTY_FUNCTION__ << ": subrun diblock found mask in file: "
        << RunHistory::DiBlockMaskToString(*mask) << std::endl;
      }
    }

    return;
  }

void nova::dbi::RunHistory::PrintChanInfo ( )

inherited

Definition at line 2121 of file RunHistory.cxx.

References nova::dbi::RunHistory::_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;
      }
    }

void nova::dbi::RunHistoryService::reconfigure

(

const fhicl::ParameterSet &

pset

)

Definition at line 45 of file RunHistory_service.cc.

References nova::dbi::RunHistory::_dbMaskTag, nova::dbi::RunHistory::_getDiBlockMaskFromCondb, fAbort, fAbortIfMissingRunInDB, fAnalysisDiBlockMasking, fCalHitLabel, fCustomMask, fCustomMasking, fFakeRunNumber, fTimeQueries, fUseMasking, fhicl::ParameterSet::get(), nova::dbi::RunHistory::SetFDRHCRunStart(), nova::dbi::RunHistory::SetFDRHCRunStop(), nova::dbi::RunHistory::SetGainSettingTag(), nova::dbi::RunHistory::SetNDRHCRunStart(), nova::dbi::RunHistory::SetNDRHCRunStop(), nova::dbi::RunHistory::SetVerbosity(), and string.

Referenced by RunHistoryService().

  {
    fCalHitLabel            = pset.get< std::string >("CalHitLabel");
    fFakeRunNumber          = pset.get< int >("FakeRunNumber", 0);
    fTimeQueries            = pset.get< bool >("TimeQueries", false);
    fUseMasking             = pset.get< bool >("UseMasking", false);
    fAnalysisDiBlockMasking = pset.get< bool >("AnalysisDiBlockMasking", false);
    fCustomMasking          = pset.get< bool >("CustomMasking", false);
    fCustomMask             = pset.get< std::vector<int> >("CustomMask");
    fAbort                  = pset.get< bool >("AbortIfNoMask", false);
    fAbortIfMissingRunInDB  = pset.get< bool >("AbortIfMissingRunInDB", true);
    this->_getDiBlockMaskFromCondb = pset.get< bool >("GetDiBlockMaskFromCondb", false);
    this->_dbMaskTag        = pset.get< std::string >("DiBlockMaskTag");
    this->SetGainSettingTag(pset.get< std::string >("DetGainTag"));
    this->SetVerbosity(pset.get< int >("Verbosity"));
    this->SetNDRHCRunStart(pset.get<std::vector<int> >("NDRHCRunStart"));
    this->SetNDRHCRunStop(pset.get<std::vector<int> >("NDRHCRunStop"));
    this->SetFDRHCRunStart(pset.get<std::vector<int> >("FDRHCRunStart"));
    this->SetFDRHCRunStop(pset.get<std::vector<int> >("FDRHCRunStop"));
    
  }

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

inlineinherited

Definition at line 374 of file RunHistory.h.

Referenced by chaninfo::BadChanList::LoadNewData(), chaninfo::BadChanList::NBadInSubRun(), calib::Calibrator::postBeginRun(), and preBeginSubrun().

{ return _runNumber; }

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

inlineinherited

Definition at line 379 of file RunHistory.h.

{ LoadDAQRunHistory(); return _runType; }

void nova::dbi::RunHistory::SetAbort ( bool  abort )

inlineinherited

Definition at line 449 of file RunHistory.h.

Referenced by preBeginRun().

{ _abort=abort; }

void nova::dbi::RunHistory::SetAbortIfMissingRunInDB ( bool  abort )

inlineinherited

Definition at line 450 of file RunHistory.h.

Referenced by preBeginRun().

{ _abortIfMissingRunInDB=abort; }

void nova::dbi::RunHistory::SetAnalysisDiBlockMasking ( bool  f )

inlineinherited

set from fcl: do we want to use the analysis rules when we mask (not for custom masking)?

Definition at line 364 of file RunHistory.h.

References MakeMiniprodValidationCuts::f.

Referenced by preBeginRun().

void nova::dbi::RunHistory::SetBadChanVersion ( std::string  v )

inlineinherited

Definition at line 465 of file RunHistory.h.

References registry_explorer::v.

{ _badChanVersion=v;}

void nova::dbi::RunHistory::SetChanInfo ( geo::OfflineChan  chan, float  occ, float  coinc, time_t  t  )

inherited

Definition at line 2135 of file RunHistory.cxx.

References nova::dbi::RunHistory::_chanInfo, febshutoff_auto::chan, nova::dbi::ChanInfo_t::coinc, nova::dbi::ChanInfo_t::occ, confusionMatrixTree::t, and nova::dbi::ChanInfo_t::tstart.

    {
      ChanInfo_t ci;
      ci.occ    = occ;
      ci.coinc  = coinc;
      ci.tstart = t;
      _chanInfo[chan].push_back(ci);
    }

void nova::dbi::RunHistory::SetCurrentSubrun ( int  isr )

inlineinherited

Definition at line 481 of file RunHistory.h.

Referenced by preBeginRun(), and preBeginSubrun().

{ _currentSR = isr; }

void nova::dbi::RunHistory::SetCustomMask ( std::vector< bool >  f )

inlineinherited

set from fcl: what is our custom mask?

Definition at line 366 of file RunHistory.h.

References MECModelEnuComparisons::i.

Referenced by preBeginRun().

void nova::dbi::RunHistory::SetDataType ( nova::dbi::DataType  dt )

inlineinherited

Definition at line 448 of file RunHistory.h.

References makeHTMLView::dt.

Referenced by CondenseRunList(), and preBeginRun().

{ _dataType = dt; }

void nova::dbi::RunHistory::SetDBInfo ( std::string  dbname = "", std::string  dbhost = "", std::string  user = "", std::string  port = ""  )

inherited

Definition at line 305 of file RunHistory.cxx.

References nova::dbi::RunHistory::_dbhost, nova::dbi::RunHistory::_dbname, nova::dbi::RunHistory::_dbport, nova::dbi::RunHistory::_dbuser, and drop_table::user.

    {
      _dbname = dbname;
      _dbhost = dbhost;
      _dbuser = user;
      _dbport = dbport;

    }

void nova::dbi::RunHistoryService::SetDetector ( const std::string &  det )

private

void nova::dbi::RunHistoryService::SetDetector ( novadaq::cnv::DetId  det )

private

void nova::dbi::RunHistory::SetDiBlockMaskTag ( std::string  s )

inlineinherited

Definition at line 470 of file RunHistory.h.

{ _dbMaskTag = s; }

void nova::dbi::RunHistory::SetFDRHCRunStart ( std::vector< int >  r )

inlineinherited

Definition at line 358 of file RunHistory.h.

References r().

Referenced by reconfigure().

{ _fdRHCRunStart = r; }

void nova::dbi::RunHistory::SetFDRHCRunStop ( std::vector< int >  r )

inlineinherited

Definition at line 359 of file RunHistory.h.

References r().

Referenced by reconfigure().

{ _fdRHCRunStop = r; }

void nova::dbi::RunHistory::SetGainSettingTag ( std::string  tag )

inlineinherited

Definition at line 473 of file RunHistory.h.

References getGoodRuns4SAM::tag.

Referenced by reconfigure().

{_detGainTag = tag;}

void nova::dbi::RunHistory::SetGetDiBlockMaskFromCondb ( bool  f )

inlineinherited

Definition at line 367 of file RunHistory.h.

References MakeMiniprodValidationCuts::f.

Referenced by CondenseRunList().

{_getDiBlockMaskFromCondb = f;}

void nova::dbi::RunHistory::SetGoodDiBlockMask ( int  newmask )

inlineinherited

Definition at line 408 of file RunHistory.h.

References MECModelEnuComparisons::i, and getGoodRuns4SAM::subrun.

Referenced by preBeginRun().

{for (size_t isr=0; isr<64; ++isr) _subrunList[isr].goodDiBlockMask=newmask; _gotGoodDiBlockMask=true;}

void nova::dbi::RunHistory::SetIfAnyMasking ( bool  f )

inlineinherited

set from fcl: do we want to use any masking at all? If no, other masking options irrelevant

Definition at line 363 of file RunHistory.h.

References MakeMiniprodValidationCuts::f.

Referenced by CondenseRunList(), and preBeginRun().

void nova::dbi::RunHistory::SetIfCustomMasking ( bool  f )

inlineinherited

set from fcl: do we want to use a custom mask?

Definition at line 365 of file RunHistory.h.

References MakeMiniprodValidationCuts::f.

Referenced by CondenseRunList(), and preBeginRun().

void nova::dbi::RunHistory::SetIsBad ( geo::OfflineChan  chan, bool  isBad, time_t  t  )

inherited

Definition at line 2175 of file RunHistory.cxx.

References nova::dbi::RunHistory::_badChan, b, febshutoff_auto::chan, nova::dbi::BadChan_t::isBad, confusionMatrixTree::t, and nova::dbi::BadChan_t::tstart.

    {
      BadChan_t b;
      b.isBad = isBad;
      b.tstart = t;
      _badChan[chan].push_back(b);
    }

void nova::dbi::RunHistory::SetNDRHCRunStart ( std::vector< int >  r )

inlineinherited

Definition at line 356 of file RunHistory.h.

References r().

Referenced by reconfigure().

{ _ndRHCRunStart = r; }

void nova::dbi::RunHistory::SetNDRHCRunStop ( std::vector< int >  r )

inlineinherited

Definition at line 357 of file RunHistory.h.

References r().

Referenced by reconfigure().

{ _ndRHCRunStop = r; }

void nova::dbi::RunHistory::SetNRetryLoads ( int  n )

inlineinherited

Definition at line 468 of file RunHistory.h.

References getGoodRuns4SAM::n.

{ _nRetryLoads = n;}

void nova::dbi::RunHistoryService::SetRunNumber ( int  run )

private

void nova::dbi::RunHistory::SetSubrunDiBlockMask ( int  isr, int  m  )

inlineinherited

Definition at line 370 of file RunHistory.h.

References m, lem_server::mask, and string.

Referenced by preBeginSubrun().

{ _subrunList[isr].goodDiBlockMask=m; }     

void nova::dbi::RunHistory::SetTimeParsing ( bool  f )

inlineinherited

Definition at line 362 of file RunHistory.h.

References MakeMiniprodValidationCuts::f.

Referenced by preBeginRun().

{_timeParsing=f;}

void nova::dbi::RunHistory::SetTimeQueries ( bool  f )

inlineinherited

Definition at line 361 of file RunHistory.h.

References MakeMiniprodValidationCuts::f.

Referenced by preBeginRun().

{_timeQueries=f;}

void nova::dbi::RunHistory::SetVerbosity ( int  i )

inlineinherited

Definition at line 478 of file RunHistory.h.

References MECModelEnuComparisons::i.

Referenced by reconfigure().

{ _verbosity = i; }

time_t nova::dbi::RunHistory::SubrunTStart ( int  isr )

inherited

Definition at line 2193 of file RunHistory.cxx.

References nova::dbi::RunHistory::_nsubrun, nova::dbi::RunHistory::_subrunList, nova::dbi::RunHistory::LoadDAQRunHistory(), and nova::dbi::RunHistory::TStart().

                                           {
      LoadDAQRunHistory();
      if (isr < 0 || isr > _nsubrun) return 0;
      if (isr == 0) return this->TStart();
      return _subrunList[isr].tstart; 
    }

time_t nova::dbi::RunHistory::SubrunTStop ( int  isr )

inherited

Definition at line 2201 of file RunHistory.cxx.

References nova::dbi::RunHistory::_nsubrun, nova::dbi::RunHistory::_subrunList, nova::dbi::RunHistory::LoadDAQRunHistory(), and nova::dbi::RunHistory::TStop().

                                          {
      LoadDAQRunHistory();
      if (isr < 0 || isr > _nsubrun) return 0;
      if (isr == _nsubrun-1) return this->TStop();
      return _subrunList[isr+1].tstart; 
    }

time_t nova::dbi::RunHistory::TStart ( )

inherited

Definition at line 2209 of file RunHistory.cxx.

References nova::dbi::RunHistory::_tStart, nova::dbi::RunHistory::LoadDAQRunHistory(), confusionMatrixTree::t, and nova::dbi::Util::TimeAsStringToTime_t().

Referenced by CondenseRunList(), calib::Calibrator::EnsureTimingCacheVldTime(), plotTime(), photrans::ImprovedTransport::StepAlongHit(), nova::dbi::RunHistory::SubrunTStart(), and calib::Calibrator::SystematicUncertaintyScale().

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

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

inlineinherited

Definition at line 383 of file RunHistory.h.

Referenced by nova::dbi::RunHistory::Dump().

{ LoadDAQRunHistory(); return _tStart;}

time_t nova::dbi::RunHistory::TStop ( )

inherited

Definition at line 2220 of file RunHistory.cxx.

References nova::dbi::RunHistory::_tEnd, nova::dbi::RunHistory::LoadDAQRunHistory(), string, confusionMatrixTree::t, and nova::dbi::Util::TimeAsStringToTime_t().

Referenced by CondenseRunList(), calib::Calibrator::EnsureTimingCacheVldTime(), plotTime(), and nova::dbi::RunHistory::SubrunTStop().

                             {
      LoadDAQRunHistory();
      time_t t;