FunctionRep.cxx

Go to the documentation of this file.

// for truncation warning in debug mode
#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif

#include "FunctionRep.h"

#include "datasrcs/DataSource.h"
#include "datasrcs/TupleCut.h"

#include "functions/FunctionBase.h"

#include "minimizers/Fitter.h"
#include "minimizers/NTupleFCN.h"
#include "projectors/FunctionProjector.h"
#include "reps/LinePointRep.h"

using std::string;
using std::vector;

FunctionRep::FunctionRep ( const std::string & name, DataRep * rep )
{
  m_target = rep;
  m_target -> addObserver ( this );

  const DataSource * ntuple = rep -> getProjectedValues ();
  DataSource * nt = const_cast < DataSource * > ( ntuple );
  nt -> addObserver ( this );

  m_name = "Function";

  ProjectorBase * target = rep -> getProjector ();    
  m_projector = new FunctionProjector ( name, target );
  m_rep = new LinePointRep(); 
  // The above deleted in ~DataRep()

  m_rep->setColor ( Color::red );
  
  if ( name == "Linear Sum" ){
    m_rep->setSize ( 2 );
    m_rep->setColor ( Color::blue );
  }
}

FunctionRep::FunctionRep ( FunctionBase * function, DataRep * rep )
{
  m_target = rep;
  m_target -> addObserver ( this );

  const DataSource * ntuple = rep -> getProjectedValues ();
  DataSource * nt = const_cast < DataSource * > ( ntuple );
  nt -> addObserver ( this );

  m_name = "Function";

  ProjectorBase * target = rep -> getProjector ();    
  m_projector = new FunctionProjector ( function, target );

  // The following is needed to ensure FunctionProjector::principleErrors()
  // knows the correct number of parameters for this function.
  dynamic_cast<FunctionProjector *>(m_projector)->saveParameters();

  m_rep = new LinePointRep(); 
  // The above deleted in ~DataRep()

  m_rep->setColor ( Color::red );
}

FunctionRep::
FunctionRep ( const FunctionRep & rep )
  : DataRep ( rep )
{
  CutList_t::const_iterator first = rep.m_cut_list.begin ();
  while ( first != m_cut_list.end () ) {
    m_cut_list.push_back ( *first++ );
  }
}

FunctionRep::
~FunctionRep ()
{
  if ( m_target != 0 ) {
    m_target -> removeObserver ( this );

    const DataSource * target = m_target -> getProjectedValues ();
    DataSource * nt = const_cast < DataSource * > ( target );
    nt -> removeObserver ( this );
  }
}

DataRep * FunctionRep::clone ()
{
  return new FunctionRep ( *this );
}

bool FunctionRep::hasNTupleBindings () const
{
  return false;
}

void FunctionRep::initializeWith ( DataRep * rep )
{
  m_target = rep;
  ProjectorBase * projector = rep -> getProjector ();

  FunctionProjector * fp = dynamic_cast < FunctionProjector * > ( m_projector);

  fp->initializeFunction ( projector );
}

FunctionBase * FunctionRep::getFunction () const
{
  FunctionProjector * fp = dynamic_cast < FunctionProjector * > ( m_projector);

  return fp->function ();
}

DataRep * FunctionRep::getTarget () const
{
  return m_target;
}

void FunctionRep::setTarget ( DataRep * target )
{
  m_target = target;
}

bool FunctionRep::isComposite () const
{
  FunctionBase * function = getFunction();
  return function->isComposite ();
}

void
FunctionRep::
setFitter ( Fitter * fitter )
{
  FunctionProjector * fp = dynamic_cast < FunctionProjector * > ( m_projector);
  assert ( fp );

  fp -> setFitter ( fitter );
}

Fitter *
FunctionRep::
getFitter ( ) const
{
  FunctionProjector * fp = dynamic_cast < FunctionProjector * > ( m_projector);
  assert ( fp );

  return fp -> getFitter ();
}

const string &
FunctionRep::
getFitterName () const
{
  Fitter * fitter = getFitter ();

  return fitter -> name ();
}

bool FunctionRep::fitFunction ( )
{

  FunctionProjector * fp = dynamic_cast < FunctionProjector * > ( m_projector);
  assert ( fp );

  bool ok = fp->fitFunction ( );
  
  notifyObservers ();

  return ok;
}

const vector< double > & FunctionRep::principleErrors() const
{
  FunctionProjector * fp = dynamic_cast < FunctionProjector * > ( m_projector);
  assert ( fp );
  
  return fp->principleErrors();
}

void FunctionRep::saveParameters ( )
{
  FunctionProjector * fp = dynamic_cast < FunctionProjector * > ( m_projector);
  fp->saveParameters ();
}

void FunctionRep::restoreParameters ()
{
  FunctionProjector * fp = dynamic_cast < FunctionProjector * > ( m_projector);
  fp->restoreParameters ();
  notifyObservers ();
}

void FunctionRep::setParameters ( const std::vector<double> & params )
{
  FunctionProjector * fp = dynamic_cast < FunctionProjector * > ( m_projector);
  fp->setParameters (params);
  notifyObservers ();
}

void
FunctionRep::
setFixedFlags ( const std::vector < int > & flags )
{
  Fitter * fitter = getFitter ();
  fitter -> setFixedFlags ( flags );
}

const vector < string > & FunctionRep::parmNames () const
{
  FunctionBase * function = getFunction ();

  return function->parmNames ();
}

const vector < double > & FunctionRep::parameters () const
{
  FunctionBase * function = getFunction ();

  return function->getParameters ();
}

const vector < int > &
FunctionRep::
getFixedFlags ( ) const
{
  const Fitter * fitter = getFitter ();

  return fitter -> getFixedFlags ();
}

void
FunctionRep::
update ( const Observable * observed )
{
  const DataSource * ntuple = dynamic_cast < const DataSource * > ( observed );
  if ( ntuple == 0 ) return;

  Fitter * fitter = getFitter ();
  if ( fitter != 0 ) {
    StatedFCN * fcn = fitter -> getFCN ();
    NTupleFCN * ntfcn = dynamic_cast < NTupleFCN * > ( fcn );
    ntfcn -> setUseErrors ();
  }

  DataRep::update ( observed );
}

void
FunctionRep::
willDelete ( const Observable * observed )
{
  const DataRep * rep = dynamic_cast < const DataRep * > ( observed );
  if ( rep != 0 ) {
    m_target = 0;
    const DataSource * projvalues = rep -> getProjectedValues ();
    DataSource * source = const_cast < DataSource * > ( projvalues );
    source -> removeObserver ( this );
  }
}

bool
FunctionRep::
isTargetable () const
{
  return false;
}

using namespace hippodraw;

bool
FunctionRep::
hasAxis ( hippodraw::Axes::Type axis ) const
{
  return axis == Axes::X || axis == Axes::Y;
}

void
FunctionRep::
setCutRange ( const Range & range )
{
  if ( m_cut_list.empty () ) {
    TupleCut cut;
    m_cut_list.push_back ( cut );
  }

  TupleCut & cut = m_cut_list.front(); // to be index later
  const ProjectorBase * target = m_target -> getProjector ();
  const string & label = target -> getXLabel ();
  cut.setLabel ( label );
  cut.setRange ( range );

  FunctionProjector * projector 
    = dynamic_cast < FunctionProjector * > ( m_projector );
  assert ( projector != 0 );

  projector -> setFitCut ( & cut );
  projector -> setFitRange ( true );
}

void
FunctionRep::
setCutRange ( bool yes )
{
  FunctionProjector * projector 
    = dynamic_cast < FunctionProjector * > ( m_projector );
  assert ( projector != 0 );

  projector -> setFitRange ( yes );
}

---