FunctionProjector.cxx

Go to the documentation of this file.

// for HAVE_MINUIT
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

// For truncation warning
#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif

#include "FunctionProjector.h"

#include "ProjectorHelper.h"

#include "axes/AxisModelBase.h"
#include "binners/BinsFunction.h"
#include "datasrcs/DataPointTuple.h"
#include "datasrcs/NTuple.h"
#include "functions/FunctionBase.h"
#include "functions/FunctionFactory.h"
#include "minimizers/Fitter.h"

#include <cassert>
#include <cmath>

using namespace hippodraw;

using std::copy;
using std::list;
using std::string;
using std::vector;

string FunctionProjector::s_x_label ("X");

FunctionProjector::FunctionProjector ( const std::string & name,
                                       ProjectorBase * targetProjector )
  : ProjectorBase (),
    m_target ( targetProjector ),
    m_fitter ( 0 )
{
  assert ( targetProjector );

  FunctionFactory * factory = FunctionFactory::instance();
  m_function = factory->create ( name );
  assert ( m_function != 0 );

  m_binner = new BinsFunction ();
  setNumberOfBins ( 50 );

  addPointReps();
}

FunctionProjector::FunctionProjector ( FunctionBase * function,
                                       ProjectorBase * targetProjector )
   :  ProjectorBase (),
      m_target ( targetProjector ),
      m_fitter ( 0 )
{
  assert ( targetProjector );
  m_function = function;
  assert ( m_function != 0 );

  m_binner = new BinsFunction ();
  setNumberOfBins ( 50 );

  addPointReps();
}

FunctionProjector::FunctionProjector ( const FunctionProjector & plotter )
{
}

FunctionProjector::~FunctionProjector ()
{
  delete m_function;
  delete m_fitter;
  delete m_binner;
}

ProjectorBase * FunctionProjector::clone ()
{
  return 0;
}

FunctionBase * FunctionProjector::function () const
{
  return m_function;
}

void FunctionProjector::setNumberOfBins ( int nb )
{
  m_binner->setNumberOfBins ( Axes::X, nb );
}

bool FunctionProjector:: hasSavedParameters () const
{
  return m_save_parms.empty() == false;
}

void FunctionProjector::saveParameters ()
{
  assert ( m_function != 0 );

  m_save_parms = m_function->getParameters ();
}

void FunctionProjector::restoreParameters ()
{
  assert ( m_function != 0 );
  assert ( ! m_save_parms.empty () );

  m_function->setParameters ( m_save_parms );

  setDirty ( true );
}

void
FunctionProjector::
setFitter ( Fitter * fitter )
{
  m_fitter = fitter;
}

Fitter *
FunctionProjector::
getFitter ( ) const
{
  return m_fitter;
}

void FunctionProjector::initializeFunction ( ProjectorBase * projector )
{
  assert ( m_function != 0 );

  m_target = projector;
  projector->prepareValues();
  ProjectorHelper helper ( projector -> getProjectedValues () );
  m_function->initialParameters ( & helper );
  
  saveParameters ();
}

bool
FunctionProjector::
fitFunction ( )
{
  
  assert ( m_function != 0 && m_target != 0 );
  assert ( m_fitter != 0 );
  m_target -> prepareValues ();

  if ( hasSavedParameters() == false ) {
    saveParameters ();
  }
  // Calculate the best fit
  bool ok = m_fitter->calcBestFit ();
  
  setDirty ( true );
  
  return ok;
}


void FunctionProjector::prepareValues ()
{
  m_binner->setFunction ( m_function );

  if ( isDirty () ) {
    m_binner->createValuesArray ( m_values );
    if ( m_proj_values == 0 ) {
      m_proj_values = createNTuple ();
    }
    else {
      fillProjectedValues ( m_proj_values );
    }
    setDirty ( false );
  }

}

const string & FunctionProjector::getTitle() const
{
  return m_function->name ();
} 

void
FunctionProjector::
setRange ( hippodraw::Axes::Type axis, bool )
{
  AxisModelBase * model = 0;

  if ( axis == Axes::X ) model = m_x_axis;
  else model = m_y_axis;

  const Range & range = model->getRange( false );
  m_binner->setRange ( axis, range );

  setDirty ( true );
}

const std::string & FunctionProjector::getXLabel () const
{
  return s_x_label;
}

const string & FunctionProjector::getYLabel ( bool ) const
{
  return m_function->name ();
}

void FunctionProjector::prepareAxis ( const Range & x_view, 
                                      const Range & y_view )
{
  const Range & rangex = m_x_axis->getRange (false);
  m_binner->setRangeOn ( Axes::X, rangex, x_view );

  const Range & rangey = m_y_axis->getRange (false);
  m_binner->setRangeOn ( Axes::Y, rangey, y_view );

  setDirty ( true );
}

Range FunctionProjector::valueRange() const
{
  return Range ( 0, 0 );
}

int
FunctionProjector::
getNumberOfEntries () const
{
  // A call to this function for a FunctionProjector is meaningless.
  // Thus it returns meaningless negative number
  return -1;
}

Range
FunctionProjector::
dataRangeOn ( hippodraw::Axes::Type axis ) const
{
  if ( axis == Axes::X ) return m_x_axis->getRange ( false );

  return m_y_axis->getRange ( false );
}

double FunctionProjector::objectiveValue () const
{
  return m_fitter->objectiveValue ();
}

const vector < double > & 
FunctionProjector::
principleErrors() const
{
    int num_parms = m_save_parms.size ();
    m_principleErrors.clear();
    m_principleErrors.resize( num_parms, 0.0 );
    if ( m_fitter != 0 ) {
      m_fitter -> calcCovariance ( m_covariance );
      int n = m_covariance.size();
      if ( n != 0 ) {
        const vector < int > & fixed = m_fitter -> getFixedFlags ();
        int ic = 0;
        for( int i = 0; i < num_parms; i++ ) {
          if ( fixed [ i ] == 0 ) {
            m_principleErrors[i] = sqrt( m_covariance[ic][ic] );
            ic++;
          }
          else {
            m_principleErrors[i] = 0.0;
          }
        }
      }
    }

  return m_principleErrors;
}

void
FunctionProjector::
setPrincipleErrors ( std::vector < double > :: const_iterator begin,
                     std::vector < double > :: const_iterator end )
{
  unsigned int size = std::distance ( begin, end );
  assert ( size == m_principleErrors.size () );

  copy ( begin, end, m_principleErrors.begin() );
}

int FunctionProjector::degreesOfFreedom () const
{
  return m_fitter->calcDegreesOfFreedom ();
}

double
FunctionProjector::
getPosOn ( hippodraw::Axes::Type ) const
{
  return 0.0;
}

void
FunctionProjector::
setAxisModel ( hippodraw::Axes::Type axis,
               AxisModelBase * axis_model )
{
  assert ( axis == Axes::X || axis == Axes::Y );
  

  if ( axis == Axes::X ) {
    m_x_axis = axis_model;
  }
  if ( axis == Axes::Y ) {
    m_y_axis = axis_model;
  }

  const Range & range = axis_model->getRange (false);
  m_binner->setRange ( axis, range );
}

const string & FunctionProjector::getZLabel() const
{
  assert ( false );

  return m_z_label;
}

void FunctionProjector::addPointReps()
{
}

bool
FunctionProjector::
isEmpty () const
{
  return m_binner == 0;
}

void FunctionProjector::setParameters ( const std::vector<double> &params )
{
  assert ( m_function != 0 );

  std::vector<double> myParams = m_function->getParameters();

  if ( myParams.size() == params.size() ) {
     m_function->setParameters ( params );
     setDirty ( true );
  }
}

const vector < vector < double > > &
FunctionProjector::
covariance ( ) const
{
  if ( m_covariance.empty () ) {
    m_fitter -> calcCovariance ( m_covariance );
  }

  return m_covariance;
}

namespace dp = hippodraw::DataPoint2DTuple;

DataSource *
FunctionProjector::
createNTuple () const
{
  unsigned int columns = dp::SIZE;
  NTuple * ntuple = new NTuple ( columns );
  vector < string > labels;

  labels.push_back ( "X" );
  labels.push_back ( "Y" );
  labels.push_back ( "nil" );
  labels.push_back ( "nil" );

  ntuple -> setLabels ( labels );

  unsigned int size = m_values.size();
  ntuple -> reserve ( size );

  fillProjectedValues ( ntuple );

  return ntuple;
}

void
FunctionProjector::
fillProjectedValues ( DataSource * ntuple, bool ) const
{
  ntuple -> clear ();

  vector < double > row ( dp::SIZE );

  list < vector < double > >::const_iterator first = m_values.begin();
  while ( first != m_values.end () ) {
    const vector < double > & value = *first++;
    row = value;
    ntuple -> addRow ( row );
  }
}

void
FunctionProjector::
fillDataSource ( DataSource * ntuple, bool ) const
{
  ntuple -> clear ();

  vector < double > row ( dp::SIZE );

  list < vector < double > >::const_iterator first = m_values.begin();
  while ( first != m_values.end () ) {
    const vector < double > & value = *first++;
    row = value;
    ntuple -> addRow ( row );
  }
}

void
FunctionProjector::
setFitCut ( TupleCut * cut )
{
  m_fitter -> setFitCut ( cut );
}

void
FunctionProjector::
setFitRange ( bool yes )
{
  m_fitter -> setFitRange ( yes );
}

---