FunctionController.h

Go to the documentation of this file.

/* -*- mode: c++ -*- */

#ifndef _FunctionController_H_
#define _FunctionController_H_

#include "axes/AxesType.h"

// for incomplete type warning
#ifdef _MSC_VER
#include "functions/FunctionBase.h"
#endif

#include <list>
#include <vector>

namespace hippodraw {

class DataRep;
class Fitter;
class FunctionBase;
class FunctionParameter;
class FunctionRep;
class NTuple;
class PlotterBase;
class ProjectorBase;
class Range;
class TupleCut;
class ViewBase;
class ViewFactory;

class MDL_HIPPOPLOT_API FunctionController
{

private:
  
  mutable std::vector < FunctionRep * > m_func_reps;

  std::vector < std::string > m_f_names;

  std::vector < double > m_deltaXSq;
  
  static FunctionController * s_instance;

  PlotterBase * m_plotter;

  mutable int m_x;
  
  mutable int m_y;
  
  unsigned int m_confid_count;

  FunctionController ();

  FunctionController ( const FunctionController & );

  void findFunctions ( const PlotterBase * plotter ) const;

  void setErrorsFromComposite ( const PlotterBase * plotter, 
                                const FunctionRep * composite );

  void fillFunctionReps ( std::vector < FunctionRep * > & freps,
                          const PlotterBase * plotter,
                          const DataRep * data_rep ) const;

public:

  static FunctionController * instance ();

  ~FunctionController();

  const std::vector < std::string > & getFitterNames () const;

  const std::string & getDefaultFitter () const;

  FunctionRep * createFunctionRep ( const std::string & name,
                                    DataRep * rep  );
    
   FunctionRep * createFunctionRep ( FunctionBase * function,
                                     DataRep * rep  );
    
  FunctionRep * getFunctionRep ( const PlotterBase * plotter ) const;

  FunctionRep * getFunctionRep ( const PlotterBase * plotter,
                                 const DataRep * data ) const;
  

  void fillTopLevelFunctionReps ( std::vector < FunctionRep * > & reps,
                                  const PlotterBase * plotter,
                                  const DataRep * data_rep ) const;

  FunctionRep * getComposite ( const PlotterBase * plotter,
                               FunctionRep * rep );

  FunctionBase *  addFunction ( PlotterBase * plotter, 
                                const std::string & name );

  FunctionRep * addFunction ( PlotterBase * plotter,
                              const std::string & name,
                              FunctionRep * frep,
                              DataRep * data_rep );

  void addFunction ( PlotterBase * plotter, FunctionRep * func_rep );

  void addDataRep ( PlotterBase * plotter, DataRep * rep );

  FunctionRep * addFunctionRep ( PlotterBase * plotter,
                                 DataRep *,
                                 FunctionRep * frep,
                                 FunctionRep * func_rep );

  void removeFunction ( PlotterBase * plotter, FunctionRep * function );

  bool hasFunction ( const PlotterBase * plotter,
                     const DataRep * rep );

  int getUniqueNonFunctionIndex ( const PlotterBase * plotter ) const;

  const std::vector < std::string > & 
  functionNames ( PlotterBase *, DataRep * rep );

  const std::vector < std::string > &
  getFunctionNames () const;

  Fitter * getFitter ( const PlotterBase * plotter );

  const std::string & getFitterName ( const PlotterBase * plotter );

  bool setFitter ( const PlotterBase * plotter, const std::string & name );

  bool changeFitter ( const PlotterBase * plotter,
                      const DataRep * datarep,
                      const std::string & name );

  bool setFitter ( FunctionRep * frep, const std::string & name );

  void setDefaultFitter ( const std::string & name );

  bool fitFunction ( PlotterBase * plotter, FunctionRep * rep );

  bool tryFitFunction ( PlotterBase * plotter, FunctionRep * );

  bool fitFunction ( PlotterBase * plotter, unsigned int );

  void saveParameters ( PlotterBase * plotter );

  void restoreParameters ( PlotterBase * plotter );


  double getObjectiveValue ( const PlotterBase *, const DataRep * );

  const std::vector < std::vector < double > > &
  getCovarianceMatrix ( const PlotterBase * );

  double getChiSquared ( const PlotterBase * );

  int getDegreesOfFreedom ( const PlotterBase * );

  ViewBase * createFuncView ( const ViewFactory * factory,
                              PlotterBase * plotter,
                              const std::string & type );

  NTuple * createNTuple ( const PlotterBase * plotter,
                          const FunctionRep * rep );

  PlotterBase * createResidualsDisplay ( PlotterBase * plotter,
                                         const FunctionRep * );

  void ellipsoidNTuple ( PlotterBase * plotter, FunctionRep * ,
                         NTuple* nt, int n,
                         double & xmin, double & xmax,
                         double & ymin, double & ymax );
  
  PlotterBase * createNewEllipsoidDisplay ( PlotterBase * plotter,
                                            FunctionRep * rep );

  PlotterBase * refreshEllipsoidDisplay ( PlotterBase * plotter,
                                          FunctionRep * );
    
  NTuple * ellipse( const std::vector< double > & xbar,
                    std::vector< std::vector < double > > & SigmaInv,
                    double Csq );
  
  int setEllpsoidParamIndex ( Axes::Type axes, int index );

  bool isCompatible ( const std::string & function,
                      const std::string & fitter );

  bool functionExists ( const std::string & name );

  void setFitRange ( PlotterBase * plotter, const Range & range );

  void setFitRange ( PlotterBase * plotter, double low, double high );

  void setTupleCut ( FunctionRep * rep );

  void setTupleCut ( const PlotterBase * plotter,
                     DataRep * data_rep );

  void removeTupleCut ( const PlotterBase * plotter,
                        DataRep * data_rep );

};

} // namespace hippodraw

#endif // _FunctionController_H_