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 27 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 45 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 84 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 64 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