FitPoint.cxx

Go to the documentation of this file.

// $Id: FitPoint.cxx,v 1.1 2007/11/30 16:03:57 rustem Exp $

// C++
#include <iostream>

// Local
#include "FitPoint.h"

using namespace std;

//-----------------------------------------------------------------------------------------
Anp::FitPoint::FitPoint()
   :fIndex(-1),
    fX(0.0),
    fY(0.0),
    fA(0.0),
    fB(0.0),
    fC(0.0),
    fPass(false),
    fDegree(0),
    fWeight(-1.0),
    fMap()
{
}

//-----------------------------------------------------------------------------------------
Anp::FitPoint::FitPoint(const int index,
                             const double x,
                             const double y)
   :fIndex(index),
    fX(x),
    fY(y),
    fA(0.0),
    fB(0.0),
    fC(0.0),
    fPass(false),
    fDegree(0),
    fWeight(1.0),
    fMap()
{
}

//-----------------------------------------------------------------------------------------
Anp::FitPoint::~FitPoint()
{
}

//-----------------------------------------------------------------------------------------
void Anp::FitPoint::SetWeight(const double weight)
{
   if(weight < 0.0)
   {
      cerr << "FitPoint::SetWeight - negative global weight" << endl;
      return;
   }

   fWeight = weight;
}

//-----------------------------------------------------------------------------------------
bool Anp::FitPoint::SetWeight(const unsigned int position, const double weight)
{
   //
   // Set initial weight at position (position is index in fit vector)
   //

   if(weight < 0.0)
   {
      cerr << "FitPoint::SetWeight - negative weight at " << position << endl;
      return false;      
   }

   if(!fMap.insert(map<unsigned int, double>::value_type(position, weight)).second)
   {
      cerr << "FitPoint::SetWeight - failed to insert weight at " << position << endl;
      return false;
   }

   return true;
}

//-----------------------------------------------------------------------------------------
void Anp::FitPoint::SetL(const double a, const double b, const bool pass)
{
   fA = a;
   fB = b;
   fPass = pass;
   fDegree = 1;
}

//-----------------------------------------------------------------------------------------
void Anp::FitPoint::SetQ(const double a, const double b, const double c, const bool pass)
{
   fA = a;
   fB = b;
   fC = c;
   fPass = pass;
   fDegree = 2;
}

//-----------------------------------------------------------------------------------------
double Anp::FitPoint::FitY() const
{
   return FitY(fX);
}

//-----------------------------------------------------------------------------------------
double Anp::FitPoint::FitY(const double x) const
{
   if(!fPass)
   {
      return fY;
   }

   if(fDegree == 1)
   {
      return fA*x + fB;
   }
   else if(fDegree == 2)
   {
      return fA*x*x + fB*x + fC;
   }

   cerr << "FitPoint::FitY - unknown degree: " << fDegree << endl;

   return 0.0;
}

//-----------------------------------------------------------------------------------------
double Anp::FitPoint::Residual() const
{
   if(!fPass)
   {
      cerr << "FitPoint::Residual - this point failed local fit" << endl;
      return 0.0;
   }

   if(fDegree == 1)
   {
      return fY - fA * fX - fB;
   }
   else if(fDegree == 2)
   {
      return fY - fA * fX * fX - fB * fX - fC;
   }

   cerr << "FitPoint::Residual - unknown degree: " << fDegree << endl;

   return 0.0;
}

//-----------------------------------------------------------------------------------------
double Anp::FitPoint::Derivative(const double x) const
{
   if(!fPass)
   {
      cerr << "FitPoint::Derivative - this point failed local fit" << endl;
      return 0.0;
   }

   if(fDegree == 1)
   {
      return fA;
   }
   else if(fDegree == 2)
   {
      return 2.0 * fA * x + fB;
   }

   cerr << "FitPoint::Derivative - unknown degree: " << fDegree << endl;

   return 0.0;
}

//-----------------------------------------------------------------------------------------
void Anp::FitPoint::Print(ostream &os) const
{
   os << "FitPoint (i, x, y, best y, weight) = (" 
      << Index() << ", " 
      << X() << ", "    
      << Y() << ", " 
      << FitY() << ", " 
      << Weight() << ")" 
      << endl;
}

//-----------------------------------------------------------------------------------------
bool Anp::operator==(const FitPoint &lhs, const FitPoint &rhs)
{
   return (lhs.Index() == rhs.Index());
}

//-----------------------------------------------------------------------------------------
bool Anp::operator<(const FitPoint &lhs, const FitPoint &rhs)
{
   return (lhs.X() < rhs.X());
}

//-----------------------------------------------------------------------------------------
bool Anp::operator<(const FitPoint &fit, const double value)
{
   return (fit.X() < value);
}

//-----------------------------------------------------------------------------------------
bool Anp::operator<(const double value, const FitPoint &fit)
{
   return (value < fit.X());
}

//-----------------------------------------------------------------------------------------
bool Anp::operator==(const int index, const FitPoint &fit)
{
   return (index == fit.Index());
}

//-----------------------------------------------------------------------------------------
bool Anp::operator==(const FitPoint &fit, const int index)
{
   return (index == fit.Index());
}

---