Coverage Class Reference

#include <Coverage.h>

Public Member Functions
	Coverage (calibUtil::Metadata *meta, const std::string &instr, const std::string &flavor, const std::string &level, const facilities::Timestamp &ts)
bool	expandTypes (std::string &nickname, std::vector< std::string > &types)
	~Coverage ()
unsigned	checkType (std::string calibtype)
void	setOverlap (unsigned seconds)

Detailed Description

Check whether calibrations for a particular calibration type (or each in a predefined collection) exist covering full time interval, and whether they overlap.

Definition at line 26 of file Coverage.h.

Constructor & Destructor Documentation

Coverage()

Coverage::Coverage	(	calibUtil::Metadata *	meta,
		const std::string &	instr,
		const std::string &	flavor,
		const std::string &	level,
		const facilities::Timestamp &	ts )

Definition at line 46 of file Coverage.cxx.

  : m_instr(instr), m_flavor(flavor), m_level(level), m_overlap(300) {
  m_ts = facilities::Timestamp(ts.getClibTime());
  m_selects.reserve(3);
  m_selects.push_back("ser_no");
  m_selects.push_back("vstart");
  m_selects.push_back("vend");
 
  m_orderBy.reserve(1);
  m_orderBy.push_back("vstart asc");
 
  m_rdb = meta->getRdb();
  m_conn = meta->getReadConnection();
  m_table = meta->getTable();
}

~Coverage()

Coverage::~Coverage ( )

inline

Definition at line 37 of file Coverage.h.

{};

Member Function Documentation

checkType()

unsigned Coverage::checkType

(

std::string

calibtype

)

Definition at line 88 of file Coverage.cxx.

                                                 {
   using namespace rdbModel;
   using facilities::Timestamp;
   // Make a query to find all rows matching criteria, ordered ascending
   // by vstart
   //    match calib_type, flavor, instrument, proc_level
   //    completion = "OK"
   //    vstart >= ts
   // Ask for return of ser_no, vstart, vend
 
   std::vector<Assertion::Operator *> conditions;
   conditions.reserve(6);
 
   Assertion::Operator completeOp(OPTYPEequal, "completion", "OK",
                                  FIELDTYPEold, FIELDTYPElit);
   //                                  false, true);
   Assertion::Operator instOp(OPTYPEequal, "instrument", m_instr, 
                              FIELDTYPEold, FIELDTYPElit);
                              // false, true);
   Assertion::Operator calibTypeOp(OPTYPEequal, "calib_type", calibtype,
                                  FIELDTYPEold, FIELDTYPElit);
                                   //                  false, true);
   Assertion::Operator flavorOp(OPTYPEequal, "flavor", m_flavor, 
                                  FIELDTYPEold, FIELDTYPElit);
   //    false, true);
   Assertion::Operator levelOp(OPTYPEequal, "proc_level", m_level, 
                                  FIELDTYPEold, FIELDTYPElit);
   //                        false, true);
   Assertion::Operator vstartOp(OPTYPElessThan, m_ts.getString(), 
                                "vstart", 
                                FIELDTYPElit, FIELDTYPEold);
                                //  true, false);
   conditions.push_back(&calibTypeOp);
   conditions.push_back(&instOp);
   conditions.push_back(&flavorOp);
   conditions.push_back(&levelOp);
   conditions.push_back(&vstartOp);
   conditions.push_back(&completeOp);
   Assertion::Operator* andOp = new Assertion::Operator(OPTYPEand, conditions);
   Assertion* whereClause = new Assertion(andOp);
 
   ResultHandle* results = 0;
 
   try {               // make the query
     results = m_conn->select(m_table, m_selects, m_orderBy, whereClause);
   }
   catch (RdbException ex) {
     std::cerr << ex.getMsg() << std::endl;
     std::cerr.flush();            // exit(1);
     return false;
   }
 
   if (!results) {   // Error. Should have ResultHandle even if 0 rows.
     std::cerr << "Error making query " << std::endl;
     std::cerr.flush();
     exit(1);
   }
 
   // Save returned values
   std::vector<SelectInfo> info;
   unsigned nFound = results->getNRows();
   
   if (!nFound) {
     std::cout << "No calibrations found for calib_type '" << calibtype
               << "'" << std::endl;
     return true;
   }
 
   info.reserve(results->getNRows() );
   
   unsigned iRow = 0;
   std::vector<std::string> fields;
   fields.reserve(3);
 
   bool ok = true;
   unsigned retCode = 0;
 
   // 1. For each row store columnes; check if vstart <  vend
   std::cout << std::endl 
             << "Checking for valid timestamps, vstart < vend .. " 
             << std::endl;
   for (iRow = 0; iRow < nFound; iRow++) {
     results->getRow(fields, iRow);
     int ser = facilities::Util::stringToInt(fields[0]);
     try {
       Timestamp vstart = Timestamp(fields[1]);
       Timestamp vend = Timestamp(fields[2]);
       info.push_back(SelectInfo(ser, vstart, vend));
 
       if (vend.getClibTime() < vstart.getClibTime() ) {
         std::cerr << "vend < vstart for " << info.back();
         ok = false;  // or could discard the row and try to continue
         retCode = 1;
       }
     }
     catch (facilities::BadTimeInput    ex) {
       std::cerr << "Bad vstart or vend in row " << ser << std::endl;
       ok = false;
       retCode = 1;
     }
     
   }
   if (!ok) return retCode;
 
   // 2. Check if vend's also increase monotonically
   std::cout << std::endl << "Checking for vends monotonic.. " << std::endl;
   for (iRow = 0; iRow < nFound - 1; iRow++) {
     if (info[iRow].m_vend.getClibTime() > info[iRow+1].m_vend.getClibTime()) {
       std::cerr << "Validity interval for row with serial #" 
                 << info[iRow+1].m_ser 
                 << " completely contained in interval for row with serial #" 
                 << info[iRow].m_ser << std::endl;
       std::cerr << info[iRow];
       std::cerr << info[iRow+1] << std::endl;
       ok = false;
       retCode = 2;
     }
   }
   if (!ok) return retCode;
 
   // 3. Look for gaps
   std::cout << std::endl << "Checking for gaps.. " << std::endl;
   for (iRow = 0; iRow < nFound - 1; iRow++) {
     if (info[iRow].m_vend < info[iRow+1].m_vstart) {
       std::cerr << "Validity interval gap between calibrations with serial #" 
                 << info[iRow].m_ser << " and #" << info[iRow+1].m_ser 
                 << std::endl;
       std::cerr << info[iRow];
       std::cerr << info[iRow+1] << std::endl;
       ok = false;
       retCode = 3;
     }
   }
   // 4. Look for overlaps
   std::cout << std::endl << "Checking for overlaps.. " << std::endl;
   for (iRow = 0; iRow < nFound - 1; iRow++) {
     if ((info[iRow].m_vend).getClibTime() > 
         (info[iRow+1].m_vstart).getClibTime() + m_overlap) {
       std::cerr << "Unacceptable overlap between serial #" << info[iRow].m_ser
                 << " and #" << info[iRow+1].m_ser << std::endl;
       std::cerr << info[iRow];
       std::cerr << info[iRow+1] << std::endl;
       ok = false;
       if (!retCode) retCode = 4;
     }
   }
   return retCode;
 
 }

Referenced by main().

expandTypes()

bool Coverage::expandTypes	(	std::string &	nickname,
		std::vector< std::string > &	types )

The @nickname argument may be a single legal calib_type or may be one of the special wildcard values "CAL" "TKR" "*", in which case it is expanded to a suitable list of calib types (if we have a schema)

Definition at line 67 of file Coverage.cxx.

                                                        {
  if ((nickname == "CAL") ||
      (nickname == "TKR") ||
      (nickname == "*")  ) {
    if (!m_rdb) {
    std::cerr << "Unable to expand wildcard argument " << nickname 
              << " without schema for metadata dbs " << std::endl;
    }
    else {
      std::cerr << 
        "Wildcard expansion of calib_type argument not yet supported";
      std::cerr << std::endl << "Have a nice day" << std::endl;
    }
    std::cerr.flush();
    exit(1);
  }
  types.push_back(nickname);
  return true;
}

Referenced by main().

setOverlap()

void Coverage::setOverlap ( unsigned seconds )

inline

Definition at line 44 of file Coverage.h.

{m_overlap = seconds;}

---

The documentation for this class was generated from the following files:

• Coverage.h
• Coverage.cxx