BadDataFilter_module.cc

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////
///
/// \file    BadDataFilter.cxx
/// \brief   Filter events from periods of bad data taking.
/// \author  messier@indiana.edu
/// \date    04/24/2014
///
/////////////////////////////////////////////////////////////////////////
// System includes
#include <sstream>
// ROOT includes
#include "TTimeStamp.h"
// ART includes
#include <cetlib_except/exception.h>
#include "art/Framework/Core/ModuleMacros.h"
#include "canvas/Persistency/Provenance/Timestamp.h"
#include "art/Framework/Core/EDFilter.h"
#include "art/Framework/Principal/Run.h"
#include "art/Framework/Principal/SubRun.h"
#include "art/Framework/Principal/Event.h"
// NOVA includes
#ifdef NOVACMAKE
#include "Database/cxx/include/Table.h"
#include "Database/cxx/include/Util.h"
#else
#include "Database/Table.h"
#include "Database/Util.h"
#endif
#include "NovaDAQConventions/DAQConventions.h"
#include "SummaryData/RunData.h"


namespace runh 
{
  class BadDataFilter : public art::EDFilter
  {
  private:
    int          fRun;         ///< Current run
    int          fSubrun;      ///< Current subrun
    bool         fGoodRun;     ///< Is the current run good?
    bool         fGoodSubrun;  ///< Is the current subrun good?
    unsigned int fBadSubrunSz; ///< # of bad subrun ranges for this run
    unsigned int fBadTimeSz;   ///< # of bad time ranges for this run
    ///
    /// Encapsulation of the database tables
    ///
    typedef std::pair<int,int>                           SubrunPair_t;
    typedef std::pair<art::TimeValue_t,art::TimeValue_t> TimeValuePair_t;
    std::vector<SubrunPair_t>    fBadSubrun;
    std::vector<TimeValuePair_t> fBadTime;
    
  public:
    explicit BadDataFilter(fhicl::ParameterSet const& p) {}
    virtual ~BadDataFilter() {}
    virtual void reconfigure(fhicl::ParameterSet const& p) {}

    ///..................................................................
    /// Load the data from the bad_subruns table into the module
    ///
    void LoadBadSubruns(int run, const std::string& det) 
    {
      //
      // Construct the handle to the bad_subruns database table
      //
      static const char* dbxml = "RunHistory/tables/BadSubruns.xml";
      std::unique_ptr<nova::dbi::Table> table =
        std::unique_ptr<nova::dbi::Table>(new nova::dbi::Table(dbxml));
      table->SetDetector(det);
      table->SetValidityRange("run",run);
      table->LoadFromDB();
    //if(table->LoadFromDB()) std::abort();
   bool sucess = table->LoadFromDB();
   if(sucess) std::cout<<"DEBUG:sucess"<<std::endl;
  else std::cout<<"DEBUG:faiure"<<std::endl;
      int sr1Idx = table->GetColIndex("subrun1");
      int sr2Idx = table->GetColIndex("subrun2");

      //
      // Add each row to the list of bad subrun periods
      //
      for (int i=0; i<table->NRow(); ++i) {
        nova::dbi::Row* row = table->GetRow(i);
        
        int subrun1, subrun2;
        row->Col(sr1Idx).Get(subrun1);
        row->Col(sr2Idx).Get(subrun2);
        fBadSubrun.push_back(SubrunPair_t(subrun1, subrun2));
      }
      fBadSubrunSz = fBadSubrun.size();
    }

    ///.................................................................
    /// Shuffle the text time stamp into a 64-bit word in the ART
    /// format. Time is only accurate to nearest second; as such
    /// its OK to leave the lower 32 bits set to 0
    ///
    /// @param t - text time stamp in format 1970-12-12 10:11:12
    ///
    art::TimeValue_t TextToTimeValue(const std::string& t) {
      struct tm tm1;
      strptime(t.c_str(), "%Y-%m-%d %H:%M:%S",&tm1);
      tm1.tm_year += 1900;
      TTimeStamp ts(tm1.tm_year, tm1.tm_mon, tm1.tm_mday, 
                    tm1.tm_hour, tm1.tm_min, tm1.tm_sec);
      art::TimeValue_t tv = (ts.GetSec() << 32);
      return tv;
    }

    ///.................................................................
    /// This method should eventually read a database table of bad
    /// time ranges into memory. Its a hook for possible future
    /// implementation. Currently we have no mechanism for flagging
    /// bad time ranges. Pattern should follow LoadBadSubruns above.
    ///
    void LoadBadTimeRanges(int run, const std::string& det)
    {
      //
      // Construct the handle to the bad_time_ranges database table
      //
      static const char* dbxml = "RunHistory/tables/BadTimeRanges.xml";
      std::unique_ptr<nova::dbi::Table> table =
        std::unique_ptr<nova::dbi::Table>(new nova::dbi::Table(dbxml));
      table->SetDetector(det);
      table->SetValidityRange("run",run);
      table->LoadFromDB();
  bool sucess = table->LoadFromDB();
   if(sucess) std::cout<<"DEBUG:sucess"<<std::endl;
 else std::cout<<"DEBUG:faiure"<<std::endl;





//    if(!table->LoadFromDB()) std::abort();

      // Add each row to the list of bad subrun periods
      //
      int t1Idx=table->GetColIndex("t1");
      int t2Idx=table->GetColIndex("t2");

      for (int i=0; i<table->NRow(); ++i) {
        nova::dbi::Row* row = table->GetRow(i);
        
        std::string t1, t2;
        row->Col(t1Idx).Get(t1);
        row->Col(t2Idx).Get(t2);

        art::TimeValue_t tv1, tv2;
        tv1 = this->TextToTimeValue(t1);
        tv2 = this->TextToTimeValue(t2);
        
        fBadTime.push_back(TimeValuePair_t(tv1,tv2));
      }
      fBadTimeSz = fBadTime.size();
    }
    
    ///.................................................................
    /// At the start of a new run, connect to the database and pull
    /// down any information about intervals of bad data.
    ///
    virtual bool beginRun(art::Run& r)
    {
      fRun = r.run();
      //
      // Extract the run summary data to discover the detector ID for
      // this data
      //
      std::vector<art::Handle<sumdata::RunData>> rdcol;
      r.getManyByType(rdcol);
      std::string det;
      if (!rdcol.empty()) {
        det = novadaq::cnv::DetInfo::GetName(rdcol[0]->DetId());
      }
      else {

      // abort();
        throw cet::exception("BadDataFilter") << 
          "Cannot find sumdata::RunData" << std::endl;
      }

      //
      // Reset everything for this run to the good state
      //
      fGoodRun = true;
      fBadSubrun.clear();
      fBadTime.  clear();
      
      //
      // Now load bad periods from the database
      //
      this->LoadBadSubruns(fRun, det);
      this->LoadBadTimeRanges(fRun, det);

      return fGoodRun;
    }
    
    ///.................................................................
    /// At the start of a new subrun check the list of bad subrun
    /// ranges and mark the subrun accordingly
    ///
    virtual bool beginSubRun(art::SubRun& s)
    {
      fSubrun = s.subRun();

      fGoodSubrun = fGoodRun;
      if (fGoodSubrun==false) {
        std::cout << "Subrun " << fRun << ":" << fSubrun 
                  << " is in bad run. Skipped."
                  << std::endl;
        return false;
      }
      else {
        //
        // Its a good run. Check if there are any bad periods. If not,
        // return 'good'.
        //
        if (fBadSubrunSz==0) return true;
      }

      //
      // Get here on good runs with bad subruns flagged
      //
      for (unsigned int i=0; i<fBadSubrunSz; ++i) {
        if (fSubrun>=fBadSubrun[i].first && 
            fSubrun<=fBadSubrun[i].second) {
          std::cout << "Subrun " << fRun << ":" << fSubrun 
                    << " is flagged as bad. Skipped."
                    << std::endl;
          fGoodSubrun = false;
          return fGoodSubrun;
        }
      }
      return true;
    }
    
    ///.................................................................
    /// Check if this event should be filtered. Pass good data and
    /// fail bad data
    ///
    virtual bool filter(art::Event& e) 
    {
      //
      // Not strictly necessary, but check if we are in a bad run or
      // subrun
      //
      if (fGoodRun==false||fGoodSubrun==false) return false;

      //
      // If there are no time ranges to check, then the event must be
      // good
      //
      if (fBadTimeSz==0) return true;
      
      //
      // Only thing left to check is the event time. Times in the
      // table are already converted to ART 64-bit time.
      //
      art::TimeValue_t t = e.time().value();
      for (unsigned int i=0; i<fBadTimeSz; ++i) {
        if (t>=fBadTime[i].first && t<=fBadTime[i].second) {
          std::cout << "Event " 
                    << e.run() << ":"
                    << e.subRun() << ":"
                    << e.event()
                    << " is inside bad time range. Skipped." << std::endl;
          return false;
        }
      }
      return true;
    }
  }; // class BadDataFilter...
} // namespace runh
DEFINE_ART_MODULE(runh::BadDataFilter)
////////////////////////////////////////////////////////////////////////