Reconstruction/TrackUtil/include/TrackUtil/Lpav.h

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:     <package>
// Module:      Lpav
//
// Description: <one line class summary>
//
// Usage:
//    <usage>
//
// Author:      KATAYAMA Nobuhiko
// Created:     Fri Feb  6 10:21:38 JST 1998
// $Id: Lpav.h,v 1.1.1.1 2008/06/16 02:10:31 max Exp $
 
#if !defined( PACKAGE_LPAV_H_INCLUDED )
#  define PACKAGE_LPAV_H_INCLUDED
 
// system include files
#  include <iosfwd>
 
// user include files
#  include "CLHEP/Matrix/SymMatrix.h"
#  include "TrackUtil/Lpar.h"
using namespace CLHEP;
 
// forward declarations
 
class Lpav : public Lpar {
  // friend classes and functions
 
public:
  // constants, enums and typedefs
 
  // Constructors and destructor
  Lpav();
  virtual ~Lpav();
 
  // member functions
  void        calculate_average( void );
  void        calculate_average3( void );
  void        calculate_average( double x, double y, double w = 1 );
  void        calculate_average3( double x, double y, double w = 1 );
  double      calculate_lpar( void );
  double      calculate_lpar3( void );
  double      fit();
  double      fit( double x, double y, double w = 1 );
  inline void clear();
  void        add_point( double x, double y, double w = 1 );
  void        add_point_frac( double x, double y, double w, double f );
 
  // const member functions
  double       nc() const { return m_nc; }
  HepSymMatrix cov( int = 0 ) const;
  HepSymMatrix cov_c( int = 0 ) const;
  int          extrapolate( double, double&, double& ) const;
  double       similarity( double, double ) const;
  double       delta_chisq( double x, double y, double w = 1 ) const;
  double       chisq() const { return m_chisq; }
  double       prob() const;
  double       chi_deg() const;
 
  // static member functions
 
  // assignment operator(s)
  inline const Lpav& operator=( const Lpav& );
  const Lpav&        operator=( const Lpar& );
  const Lpav&        operator+=( const Lpav& );
 
  friend std::ostream& operator<<( std::ostream& o, const Lpav& s );
  friend Lpav          operator+( const Lpav&, const Lpav& );
  class Singular {};   // exception class, no covarience matrix.
  class Singular_c {}; // exception class, no covarience matrix_c
 
protected:
  // protected member functions
 
  // protected const member functions
 
private:
  // Constructors and destructor
  inline Lpav( const Lpav& );
 
  // comparison operators
  bool operator==( const Lpav& ) const;
  bool operator!=( const Lpav& ) const;
 
  // private member functions
  void add( double x, double y, double w = 1, double a = 0, double b = 0 );
  void sub( double x, double y, double w = 1, double a = 0, double b = 0 );
  void calculate_average_n( double xxav, double yyav, double xyav, double xrrav, double yrrav,
                            double rrrrav );
  double chisq( double chisq ) {
    m_chisq = chisq;
    return m_chisq;
  }
  double nc( double nc ) {
    m_nc = nc;
    return m_nc;
  }
  double solve_lambda( void );
  double solve_lambda3( void );
 
  // private const member functions
 
  // data members
  double m_wsum;
  double m_xsum;
  double m_ysum;
  double m_xxsum;
  double m_yysum;
  double m_xysum;
  double m_xrrsum;
  double m_yrrsum;
  double m_rrrrsum;
 
  double m_wsum_temp;
  double m_xav;
  double m_yav;
  double m_xyavp;
 
  double m_rscale;
  double m_xxavp;
  double m_yyavp;
  double m_xrravp;
  double m_yrravp;
  double m_rrrravp;
  double m_sinrot;
  double m_cosrot;
 
  double m_nc;
  double m_chisq;
 
  // static data members
};
 
// inline function definitions
inline const Lpav& Lpav::operator=( const Lpav& lp ) {
  Lpar::operator=( lp );
  m_wsum    = lp.m_wsum;
  m_xsum    = lp.m_xsum;
  m_ysum    = lp.m_ysum;
  m_xxsum   = lp.m_xxsum;
  m_yysum   = lp.m_yysum;
  m_xysum   = lp.m_xysum;
  m_xrrsum  = lp.m_xrrsum;
  m_yrrsum  = lp.m_yrrsum;
  m_rrrrsum = lp.m_rrrrsum;
 
  m_wsum_temp = lp.m_wsum_temp;
  m_xav       = lp.m_xav;
  m_yav       = lp.m_yav;
  m_xyavp     = lp.m_xyavp;
 
  m_rscale  = lp.m_rscale;
  m_xxavp   = lp.m_xxavp;
  m_yyavp   = lp.m_yyavp;
  m_xrravp  = lp.m_xrravp;
  m_yrravp  = lp.m_yrravp;
  m_rrrravp = lp.m_rrrravp;
  m_sinrot  = lp.m_sinrot;
  m_cosrot  = lp.m_cosrot;
 
  m_nc    = lp.m_nc;
  m_chisq = lp.m_chisq;
  return *this;
}
 
inline Lpav::Lpav( const Lpav& lp ) : Lpar( lp ) {
  m_wsum    = lp.m_wsum;
  m_xsum    = lp.m_xsum;
  m_ysum    = lp.m_ysum;
  m_xxsum   = lp.m_xxsum;
  m_yysum   = lp.m_yysum;
  m_xysum   = lp.m_xysum;
  m_xrrsum  = lp.m_xrrsum;
  m_yrrsum  = lp.m_yrrsum;
  m_rrrrsum = lp.m_rrrrsum;
 
  m_wsum_temp = lp.m_wsum_temp;
  m_xav       = lp.m_xav;
  m_yav       = lp.m_yav;
  m_xyavp     = lp.m_xyavp;
 
  m_rscale  = lp.m_rscale;
  m_xxavp   = lp.m_xxavp;
  m_yyavp   = lp.m_yyavp;
  m_xrravp  = lp.m_xrravp;
  m_yrravp  = lp.m_yrravp;
  m_rrrravp = lp.m_rrrravp;
  m_sinrot  = lp.m_sinrot;
  m_cosrot  = lp.m_cosrot;
 
  m_nc    = lp.m_nc;
  m_chisq = lp.m_chisq;
  return;
}
 
inline void Lpav::clear() {
  m_wsum = m_xsum = m_ysum = m_xxsum = m_yysum = m_xysum = m_xrrsum = m_yrrsum = m_rrrrsum =
      m_rscale = m_nc = 0;
  m_chisq             = -1;
}
 
#endif /* PACKAGE_LPAV_H_INCLUDED */