Consistency.cxx

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//  $Id: Consistency.cxx,v 1.1.1.1 2005/04/21 01:17:17 zhangy Exp $
//
// Description:
//  Class Consistency; encapsulates statistics
//
//      See header for more info.  This implementation
//      is not complete
//
// Environment:
//  Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//  Bob Jacobsen        Original Author
//
// Copyright Information:
//  Copyright (C) 1995  Lawrence Berkeley Laboratory
//
//------------------------------------------------------------------------
// #include "BaBar/BaBar.hh"
 
//------------------
// This C Headers --
//------------------
extern "C" {
#include <assert.h>
#include <math.h>
}
 
//--------------------
// This C++ Headers --
//--------------------
#include <iomanip>
#include <iostream>
 
//-----------------------
// This Class's Header --
//-----------------------
#include "ProbTools/Consistency.h"
using std::endl;
using std::ios;
using std::ostream;
using std::setiosflags;
using std::setprecision;
using std::setw;
 
//              ----------------------------------------
//              -- Public Function Member Definitions --
//              ----------------------------------------
 
Consistency::Consistency()
    : _stat( noMeasure ), _value( 0 ), _likelihood( 1. ), _sign( unknown ) {}
 
Consistency::Consistency( double v, double l )
    : _stat( OK ), _value( v ), _likelihood( l ), _sign( unknown ) {}
 
Consistency::Consistency( const Consistency& rhs )
    : _stat( rhs._stat )
    , _value( rhs._value )
    , _likelihood( rhs._likelihood )
    , _sign( rhs._sign ) {}
 
// operators
Consistency& Consistency::operator=( const Consistency& rhs ) {
  if ( this != &rhs )
  {
    _stat       = rhs._stat;
    _value      = rhs._value;
    _likelihood = rhs._likelihood;
    _sign       = rhs._sign;
  }
  return *this;
}
 
bool Consistency::operator==( const Consistency& rhs ) const {
  bool answer = false;
  if ( _stat == rhs._stat && _value == rhs._value && _likelihood == rhs._likelihood &&
       _sign == rhs._sign )
  { answer = true; }
 
  return answer;
}
 
bool Consistency::operator<( const Consistency& rhs ) const {
  //
  // this is not unique...
  //
 
  bool answer = false;
  if ( _stat == OK && rhs._stat == OK )
  {
    //
    // Dare to use consistency for comparison.
    // Likelihood may give a different answer
    //
    if ( _value < rhs._value ) { answer = true; }
  }
  else
  {
    if ( rhs._stat == OK ) { answer = true; }
  }
 
  return answer;
}
 
bool Consistency::operator>( const Consistency& rhs ) const {
  // ghm
  if ( *this == rhs ) return false;
  return ( !( *this < rhs ) );
}
 
const ConsistencySet* Consistency::genealogy() const { return 0; }
 
void Consistency::print( ostream& os ) const {
  os << "Likelihood = ";
  os << setiosflags( ios::fixed ) << setw( 7 ) << setprecision( 4 );
  os << _likelihood;
  os << "\t SignificanceLevel = ";
  os << setiosflags( ios::fixed ) << setw( 7 ) << setprecision( 4 );
  os << _value;
  os << "\t Status ";
  switch ( status() )
  {
  case Consistency::OK: os << "OK"; break;
  case Consistency::noMeasure: os << "noMeasure"; break;
  case Consistency::underFlow: os << "underFlow"; break;
  case Consistency::unPhysical: os << "unPhysical"; break;
  default: os << "unknown";
  }
  os << endl;
  os << resetiosflags( std::ios::floatfield );
}
 
//------------------
// Static methods --
//------------------
 
const Consistency& Consistency::badMeasurement() {
  static Consistency bad( 1., 1. );
  bad.setStatus( noMeasure );
 
  return bad;
}