/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Reconstruction/MdcPatRec/MdcRecoUtil/MdcRecoUtil-00-01-08/MdcRecoUtil/BesError.h

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//      $Id: BesError.h,v 1.5 2010/03/25 09:55:57 zhangy Exp $
//
// Description:
//      A wrapper for a covariance matrix.  A covariance matrix is
//      a symmetric n X n matrix.  Change in chisq from point
//      covariance matrix was determined is just
//
//      diff * covariance^-1 * diff_transpose
//
//      which is implemented in a similarity transform in HepSymMatrix
//      the method determineChisq carries this calculation out and requires
//      the result to be a scalar.
//      
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      Forest Rouse                Jan 1996
//      Victoria Novotny            Aug 1996
//
// Copyright Information:
//      Copyright (C) 1996
// 
// History:
//      Migration for BESIII MDC
//
//------------------------------------------------------------------------
#ifndef BESERROR_HH
#define BESERROR_HH

#include <iostream>
#include <math.h>

#include "CLHEP/Matrix/Vector.h"
#include "CLHEP/Matrix/Matrix.h"
#include "CLHEP/Matrix/SymMatrix.h"
#include "CLHEP/Vector/Rotation.h"
#include "CLHEP/Vector/LorentzRotation.h"


using namespace CLHEP;

class BesError : public HepSymMatrix {

public:

  static const double chisqUndef;
  BesError() : HepSymMatrix() {}

  BesError(int n) : HepSymMatrix(n, 0)                          {}

  // autocast copy constructor.  HepSymMatrix's promoted back
  // into BesError matrices.

  BesError( const HepSymMatrix &p ) : HepSymMatrix(p)           {}

  // new constructors for this class
  BesError(const BesError& v) : HepSymMatrix() {*this = v;}

  BesError& operator=(const BesError& v)
    {
          if (this != &v) {
            HepSymMatrix::operator=(v);
      }
      return *this;
    }

  BesError& operator=(const HepSymMatrix& v)
    {
          if (this != &v) {
            HepSymMatrix::operator=(v);
      }
      return *this;
    }

  // destructor MAY be needed later
  // virtual ~BesError() {};

  //----------------------------------------------------------------------
  // determineChisq
  //    Compute v^T * V^(-1)*v - ie the chisq for this covariance
  //    matrix and the difference vector v.
  //----------------------------------------------------------------------

  double determineChisq(const HepVector& diff) const; 

  // Get right signature for all operations performed on BesError matrices
  // that should (and will) result in BesError matrices.  These include
  // similarity transforms, transpose, inverse, matrix multiplication,
  // addition, and subtraction.  HepSymMatrix's as a result of operations
  // are promoted back into BesError matrices if we start out
  // with BesError matrices in the first place. (See copy constructors)

  BesError& operator *= (double t)
    { return (BesError&) HepSymMatrix::operator*=(t); }

  BesError& operator /= (double t)
    {return (BesError&) HepSymMatrix::operator/=(t); }

  BesError& operator += (const BesError& m2)
    {
      HepSymMatrix::operator+=(m2);
      return *this;
    }

  BesError& operator -= (const BesError& m2)
    {
      HepSymMatrix::operator-=(m2);
      return *this;
    }

  BesError operator - ()
    { BesError temp(*this); 
      return temp; }
  // does nothing -- covariance Matrices have never negative entries on the 
  // main diagonal

  // Implement the signature for operators I also inherit
  BesError& operator += (const HepSymMatrix& m2)
    {
      HepSymMatrix::operator+=(m2);
      return *this;
    }

  BesError& operator -= (const HepSymMatrix& m2)
    {
      HepSymMatrix::operator-=(m2);
      return *this;
    }

  BesError operator - () const
    { BesError temp(*this); 
    return temp;}

  BesError& operator += (const HepDiagMatrix& m2)
    {
      HepSymMatrix::operator+=(m2);
      return *this;
    }

  BesError& operator -= (const HepDiagMatrix& m2)
    {
      HepSymMatrix::operator-=(m2);
      return *this;
    }

  BesError similarity(const HepRotation& rot) const;
  BesError similarity(const HepLorentzRotation& rot) const;
  // When feasible implement R * covMatrix * R_transpose (= R^-1)

  BesError similarity(const BesError& E);
  // implement E * covMatrix * E

  BesError similarity(const HepMatrix& m1) const
    {
      BesError mret(m1.num_row());
      mret.similarityWith(*this, m1);
      return mret;
    }

  BesError& similarityWith(const BesError& m, const HepMatrix& m1);

  // provide call ups to base classes similarity methods not implemented
  // here
  double similarity(const HepVector &v) const
       { return this->HepSymMatrix::similarity( v ); }
  HepSymMatrix similarity(const HepSymMatrix &m1) const
       { return this->HepSymMatrix::similarity( m1 ); }

private:
    
  friend BesError operator*(double t, const BesError& m1);

  friend BesError operator*(const BesError& m1, double t);

  friend BesError operator/(double t, const BesError& m1);

  friend BesError operator/(const BesError& m1, double t);

  friend BesError operator+(const BesError& m1, const BesError& m2);
 
  friend BesError operator-(const BesError& m1, const BesError& m2);
  
  friend std::ostream& operator<<(std::ostream& out, const BesError& mat);
  friend std::istream& operator>>(std::istream& in, BesError& mat);
  
};

#endif

---