Consistency.h

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//  $Id: Consistency.h,v 1.1.1.1 2005/04/21 01:17:17 zhangy Exp $
//
// Description:
//  The Consistency class is a top level parent for various
//      statistical classes
//
//      This class also defines an enum ConsistentStatus for representing
//      various error conditions
//
//      Return an object of this class from a chisquared calculation, for
//      example, so that probability and chisquared can be treated
//      directly.  Future subclasses might implement other statistics
//      (Poisson, etc), and this class could use operations to combine, 
//      print, etc. (Or other statistics could be added to this class, 
//      allowing it to convert between different measures; the uses
//      will dictate the structure)
//
//      Note: implementation of this class is minimal at present; please
//      read the comments!
//
// Environment:
//  Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      Bob Jacobsen 
//
// History :
//      April 98 - Gautier Hamel de Monchenault
//                 o  introduce genealogy methods
//                 o  add significanceLevel() accessor which returns _value
//                 o  comment out the automatic translation to double
//                 o  add 'const' to operators == and <
//
//
// Copyright Information:
//  Copyright (C) 1995, 1996
//
//------------------------------------------------------------------------
#ifndef CONSISTENCY_HH
#define CONSISTENCY_HH
 
//#include "BaBar/BaBar.hh"
 
#include <iosfwd>
class ConsistencySet;
 
//-----------------
// BaBar Headers --
//-----------------
 
class Consistency {
 
  public:
 
  // default constructor; sets internal state to noMeasure and value to zero
  Consistency();
 
  // default value for likelihood is for backward compatibility
  Consistency( double consistency, double likelihood=0.);
 
  // copy constructor
  Consistency(const Consistency& rhs);
 
  virtual ~Consistency() {}
 
  // assignment
  Consistency& operator= (const Consistency& rhs);
 
  // equality -- this will never work right since one has to compare 
  // two doubles. But RW sometimes requires this. 
  bool operator==(const Consistency& rhs) const;
  // less operator is better in that regard, but it's not unique
  bool operator < (const Consistency& rhs) const; 
  // greater than operator 
  bool operator > (const Consistency& rhs) const; 
 
  // members for returning 
  // the statistical significance level
  // and the likelihood 
  // of the represented observation; 
  // subclasses are responsible
  // for keeping the data member up to date
  double significanceLevel() const { return _value; }
  double likelihood() const { return  _likelihood;}
 
  // Old function kept in the interface for back compatibility.
  // Avoid to use it - use significanceLevel() instead.
  // Will disappear eventually
  double consistency() const { return _value; }
 
  // represent the various ways that a statistical measure could be bad
  enum ConsistentStatus { OK=0, noMeasure, underFlow, unPhysical };
 
  // OK          just that; usable statistical data
  // noMeasure   no statistical statement possible; DOF == 0, for example.
  //             may or may not be consistent
  // underFlow   probability too small to calculate with; may or may not want
  //             to treat as zero, but value may have been treated by machine
  //             underflow handling
  // unPhysical  because of a "can't happen" condition, probability is
  //             identically equal to zero;
 
  // return the status
  ConsistentStatus status() const {return _stat;}
  void setStatus(ConsistentStatus s ) { _stat = s; }
 
  // represent whether the measured value was "left" or "right" of
  // the expected.  This is generally only useful if there is more
  // than one provider of consistencies in a given situation (e.g.
  // multiple systems doing PID), and they have a convention for 
  // what these mean
  enum ConsistentSign { left=-1, unknown=0, right=1 };
 
  // return the sign
  ConsistentSign sign() const {return _sign; }
  void setSign(ConsistentSign s ) { _sign = s; }
 
  // use as a double returns the consistency value; this member is
  // intended as just a convenience, and may be removed if it makes
  // trouble.
 
  // genealogy 
  virtual const ConsistencySet* genealogy() const;
 
  // print
  virtual void print(std::ostream& ) const;
 
protected:
 
  ConsistentStatus _stat;
  ConsistentSign _sign;
  double _value;        // value of the consistency
  double _likelihood;   // value of the likelihood 
 
  //------------------
  // Static methods --
  //------------------
 
public:
  static const Consistency& badMeasurement();
 
};
 
#endif