Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

ChisqConsistency Class Reference

#include <ChisqConsistency.h>

Inheritance diagram for ChisqConsistency:

Consistency Consistency List of all members.

Public Types

enum  ConsistentSign { left = -1, unknown = 0, right = 1 }
enum  ConsistentSign { left = -1, unknown = 0, right = 1 }
enum  ConsistentStatus { OK = 0, noMeasure, underFlow, unPhysical }
enum  ConsistentStatus { OK = 0, noMeasure, underFlow, unPhysical }

Public Member Functions

 ChisqConsistency (const ChisqConsistency &)
 ChisqConsistency (unsigned nDof, double consistency)
 ChisqConsistency (double chisq, double nDof)
 ChisqConsistency ()
 ChisqConsistency (const ChisqConsistency &)
 ChisqConsistency (unsigned nDof, double consistency)
 ChisqConsistency (double chisq, double nDof)
 ChisqConsistency ()
const double & chisqValue () const
const double & chisqValue () const
double consistency () const
double consistency () const
virtual const ConsistencySet * genealogy () const
virtual const ConsistencySet * genealogy () const
double likelihood () const
double likelihood () const
const double & nDOF () const
const double & nDOF () const
bool operator< (const Consistency &rhs) const
bool operator< (const Consistency &rhs) const
ChisqConsistency & operator= (const ChisqConsistency &)
ChisqConsistency & operator= (const ChisqConsistency &)
bool operator== (const Consistency &rhs) const
bool operator== (const Consistency &rhs) const
bool operator> (const Consistency &rhs) const
bool operator> (const Consistency &rhs) const
virtual void print (std::ostream &) const
virtual void print (std::ostream &) const
void setSign (ConsistentSign s)
void setSign (ConsistentSign s)
void setStatus (ConsistentStatus s)
void setStatus (ConsistentStatus s)
ConsistentSign sign () const
ConsistentSign sign () const
double significanceLevel () const
double significanceLevel () const
ConsistentStatus status () const
ConsistentStatus status () const
virtual ~ChisqConsistency ()
virtual ~ChisqConsistency ()

Static Public Member Functions

const Consistency & badMeasurement ()
const Consistency & badMeasurement ()

Protected Attributes

double _chisq
double _likelihood
double _nDof
ConsistentSign _sign
ConsistentStatus _stat
double _value

Member Enumeration Documentation

enum Consistency::ConsistentSign [inherited]
 

Enumeration values:
left 
unknown 
right  
00114 { left=-1, unknown=0, right=1 };

enum Consistency::ConsistentSign [inherited]
 

Enumeration values:
left 
unknown 
right  
00114 { left=-1, unknown=0, right=1 };

enum Consistency::ConsistentStatus [inherited]
 

Enumeration values:
OK 
noMeasure 
underFlow 
unPhysical  
00094 { OK=0, noMeasure, underFlow, unPhysical };

enum Consistency::ConsistentStatus [inherited]
 

Enumeration values:
OK 
noMeasure 
underFlow 
unPhysical  
00094 { OK=0, noMeasure, underFlow, unPhysical };

Constructor & Destructor Documentation

ChisqConsistency::ChisqConsistency (   ) 
  

00038                                    :
00039   _chisq(-1.0), _nDof(0)
00040 {}

ChisqConsistency::ChisqConsistency (  double  chisq,
double  nDof
) 
  

00042                                                             :
00043    _chisq(chisq), _nDof(nDof)
00044 {
00045   double z2 = 0.5*_chisq;
00046   double n2 = 0.5*_nDof;
00047   
00048   if (n2<=0 || z2<0) { 
00049     std::cout << "ErrMsg(warning)" << " Got unphysical values: chisq = " << chisq 
00050                     << " #dof = " << nDof << std::endl;
00051     _value=0;
00052     _likelihood=0;
00053     setStatus(Consistency::unPhysical);
00054     return;
00055   }
00056   setStatus(Consistency::OK);
00057   
00058 // given that n2>0 && z2>=0, gammq will NOT abort
00059   _value = NumRecipes::gammq(n2,z2);
00060   
00061   if (_chisq==0) { 
00062     _likelihood=1; 
00063   } else {
00064     double loglike=(n2-1)*log(z2)-z2-NumRecipes::gammln(n2);
00065     if ( loglike < DBL_MIN_EXP ) {
00066       _likelihood = 0; 
00067       setStatus(Consistency::underFlow);
00068     } else {
00069       _likelihood = 0.5*exp(loglike);
00070     }
00071   }
00072 }

ChisqConsistency::ChisqConsistency (  unsigned  nDof,
double  consistency
) 
  

00076                                                              :
00077   _nDof(nDof)
00078 {
00079   if(prob >= 0.0|| prob <= 1.0 || nDof < 0)
00080     _value = prob;
00081   else {
00082     std::cout << "ErrMsg(warning)" << " Got unphysical values: prob = " << prob 
00083                     << " #dof = " << nDof << std::endl;
00084     _value=0;
00085     _likelihood=0;
00086     setStatus(Consistency::unPhysical);
00087     return;
00088   }
00089   setStatus(Consistency::OK);
00090   if(prob != 1.0){
00091 // use the cernlib function to get chisq.  Note the funny convention on prob!!
00092     float value = 1.0-float(_value);
00093     int ndof = nDof;
00094     if(value < 1.0)
00095       _chisq = chisin_(value,ndof);
00096     else
00097       _chisq = log(double(FLT_MAX));
00098 // use the same algorithm as above to get loglikelihood
00099     double z2 = 0.5*_chisq;
00100     double n2 = 0.5*_nDof;
00101     if (_chisq==0) { 
00102       _likelihood=1; 
00103     } else {
00104       double loglike=(n2-1)*log(z2)-z2-NumRecipes::gammln(n2);
00105       if ( loglike < DBL_MIN_EXP ) {
00106         _likelihood = 0; 
00107         setStatus(Consistency::underFlow);
00108       } else {
00109         _likelihood = 0.5*exp(loglike);
00110       }
00111     }
00112   }
00113 }

ChisqConsistency::ChisqConsistency (  const ChisqConsistency &   ) 
  

00116                                                                 :
00117   Consistency(other), _chisq(other._chisq), _nDof(other._nDof)
00118 {}

virtual ChisqConsistency::~ChisqConsistency (   )  [inline, virtual]
  

00044 {}

ChisqConsistency::ChisqConsistency (   ) 
 

ChisqConsistency::ChisqConsistency (  double  chisq,
double  nDof
) 
 

ChisqConsistency::ChisqConsistency (  unsigned  nDof,
double  consistency
) 
 

ChisqConsistency::ChisqConsistency (  const ChisqConsistency &   ) 
 

virtual ChisqConsistency::~ChisqConsistency (   )  [inline, virtual]
  

00044 {}

Member Function Documentation

const Consistency& Consistency::badMeasurement (   )  [static, inherited]
 

const Consistency & Consistency::badMeasurement (   )  [static, inherited]
  

00173 {
00174   static Consistency bad(1.,1.);
00175   bad.setStatus(noMeasure);
00176 
00177   return bad;
00178 }

const double& ChisqConsistency::chisqValue (   )  const [inline]
  

00046 { return _chisq; }

const double& ChisqConsistency::chisqValue (   )  const [inline]
  

00046 { return _chisq; }

double Consistency::consistency (   )  const [inline, inherited]
  

00091 { return _value; }

double Consistency::consistency (   )  const [inline, inherited]
  

00091 { return _value; }

virtual const ConsistencySet* Consistency::genealogy (   )  const [virtual, inherited]
 

const ConsistencySet * Consistency::genealogy (   )  const [virtual, inherited]
  

00133 {
00134   return 0;
00135 }

double Consistency::likelihood (   )  const [inline, inherited]
  

00086 { return  _likelihood;}

double Consistency::likelihood (   )  const [inline, inherited]
  

00086 { return  _likelihood;}

const double& ChisqConsistency::nDOF (   )  const [inline]
  

00047 { return _nDof; }

const double& ChisqConsistency::nDOF (   )  const [inline]
  

00047 { return _nDof; }

bool Consistency::operator< (  const Consistency &  rhs  )  const [inherited]
 

bool Consistency::operator< (  const Consistency &  rhs  )  const [inherited]
  

00099 {
00100   //
00101   // this is not unique...
00102   //
00103 
00104   bool answer = false;
00105   if (_stat == OK && rhs._stat == OK ) {
00106     //
00107     // Dare to use consistency for comparison. 
00108     // Likelihood may give a different answer
00109     //
00110     if (_value < rhs._value) {
00111       answer = true;
00112     }
00113   } else {
00114     if (rhs._stat == OK) {
00115       answer = true;
00116     }
00117   }
00118 
00119   return answer;
00120 }

ChisqConsistency& ChisqConsistency::operator= (  const ChisqConsistency &   ) 
 

ChisqConsistency & ChisqConsistency::operator= (  const ChisqConsistency &   ) 
  

00121                                                           {
00122   if(this != &other){
00123     Consistency::operator =(other);
00124     _chisq = other._chisq;
00125     _nDof = other._nDof;
00126   }
00127   return *this;
00128 }

bool Consistency::operator== (  const Consistency &  rhs  )  const [inherited]
 

bool Consistency::operator== (  const Consistency &  rhs  )  const [inherited]
  

00085 {
00086   bool answer = false;
00087   if (_stat       == rhs._stat &&
00088       _value      == rhs._value &&
00089       _likelihood == rhs._likelihood &&
00090       _sign       == rhs._sign) {
00091     answer = true;
00092   }
00093 
00094   return answer;
00095 }

bool Consistency::operator> (  const Consistency &  rhs  )  const [inherited]
 

bool Consistency::operator> (  const Consistency &  rhs  )  const [inherited]
  

00124 {
00125   // ghm
00126   if( *this==rhs ) return false;
00127   return( ! (*this<rhs) );
00128 }

virtual void Consistency::print (  std::ostream &   )  const [virtual, inherited]
 

void Consistency::print (  std::ostream &   )  const [virtual, inherited]
  

00140 {
00141   os << "Likelihood = ";
00142   os << setiosflags(ios::fixed) << setw(7) << setprecision(4);
00143   os << _likelihood;
00144   os << "\t SignificanceLevel = ";
00145   os << setiosflags(ios::fixed) << setw(7) << setprecision(4);
00146   os << _value;
00147   os << "\t Status ";
00148   switch( status() ) {
00149   case Consistency::OK  :
00150     os << "OK"; 
00151     break;
00152   case  Consistency::noMeasure  :
00153     os << "noMeasure"; 
00154     break;
00155   case  Consistency::underFlow  :
00156     os << "underFlow"; 
00157     break;
00158   case  Consistency::unPhysical  :
00159     os << "unPhysical"; 
00160     break;
00161   default:
00162     os << "unknown";
00163   }
00164   os << endl;
00165 }

void Consistency::setSign (  ConsistentSign  s  )  [inline, inherited]
  

00118 { _sign = s; }

void Consistency::setSign (  ConsistentSign  s  )  [inline, inherited]
  

00118 { _sign = s; }

void Consistency::setStatus (  ConsistentStatus  s  )  [inline, inherited]
  

00107 { _stat = s; }

void Consistency::setStatus (  ConsistentStatus  s  )  [inline, inherited]
  

00107 { _stat = s; }

ConsistentSign Consistency::sign (   )  const [inline, inherited]
  

00117 {return _sign; }

ConsistentSign Consistency::sign (   )  const [inline, inherited]
  

00117 {return _sign; }

double Consistency::significanceLevel (   )  const [inline, inherited]
  

00085 { return _value; }

double Consistency::significanceLevel (   )  const [inline, inherited]
  

00085 { return _value; }

ConsistentStatus Consistency::status (  void   )  const [inline, inherited]
  

00106 {return _stat;}

ConsistentStatus Consistency::status (  void   )  const [inline, inherited]
  

00106 {return _stat;}

Member Data Documentation

double ChisqConsistency::_chisq [protected]
 

double Consistency::_likelihood [protected, inherited]
 

double ChisqConsistency::_nDof [protected]
 

ConsistentSign Consistency::_sign [protected, inherited]
 

ConsistentStatus Consistency::_stat [protected, inherited]
 

double Consistency::_value [protected, inherited]
 

The documentation for this class was generated from the following files:
Generated on Wed Feb 2 15:56:23 2011 for BOSS6.5.5 by  doxygen 1.3.9.1