solver.h

Go to the documentation of this file.

/* This file is part of StepCore library.
   Copyright (C) 2007 Vladimir Kuznetsov <ks.vladimir@gmail.com>

   StepCore library is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   StepCore library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with StepCore; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef STEPCORE_SOLVER_H
#define STEPCORE_SOLVER_H

#include "object.h"
#include "vector.h"

namespace StepCore
{

class Solver: public Object
{
    //Q_OBJECT
    STEPCORE_OBJECT(Solver)

public:
    typedef int (*Function)(double t, const double* y, const double* yvar,
                             double* f, double* fvar, void* params);

    explicit Solver(int dimension = 0, Function function = NULL,
                void* params = NULL, double stepSize = 0.001);
    Solver(double stepSize);

    virtual ~Solver() {}

    QString solverType() const { return metaObject()->className(); }

    int dimension() const { return _dimension; }
    virtual void setDimension(int dimension) { _dimension = dimension; }

    Function function() const { return _function; }
    virtual void setFunction(Function function) { _function = function; }

    void* params() const { return _params; }
    virtual void setParams(void* params) { _params = params; }

    double stepSize() const { return _stepSize; }
    virtual void setStepSize(double stepSize) { _stepSize = stepSize; }

    double toleranceAbs() const { return _toleranceAbs; }
    virtual void setToleranceAbs(double toleranceAbs) { _toleranceAbs = toleranceAbs; }

    double toleranceRel() const { return _toleranceRel; }
    virtual void setToleranceRel(double toleranceRel) { _toleranceRel = toleranceRel; }

    double localError() const { return _localError; }
    double localErrorRatio() const { return _localErrorRatio; }

    virtual int doCalcFn(double* t, const VectorXd* y, const VectorXd* yvar = 0,
                            VectorXd* f = 0, VectorXd* fvar = 0) = 0;

    virtual int doEvolve(double* t, double t1, VectorXd* y, VectorXd* yvar) = 0;

public:
    enum { OK = 0,
           ToleranceError = 2048,
           InternalError = 2049,
           CollisionDetected = 4096,
           IntersectionDetected = 4097,
           Aborted = 8192,
           CollisionError = 16384,
           ConstraintError = 32768
    };

protected:
    int      _dimension;
    Function _function;
    void*    _params;

    double   _stepSize;
    double   _toleranceAbs;
    double   _toleranceRel;
    double   _localError;
    double   _localErrorRatio;
};

inline Solver::Solver(int dimension, Function function, void* params, double stepSize)
     : _dimension(dimension), _function(function), _params(params), _stepSize(stepSize),
       _toleranceAbs(0.001), _toleranceRel(0.001), _localError(0), _localErrorRatio(0)
{
}

inline Solver::Solver(double stepSize)
     : _dimension(0), _function(0), _params(0), _stepSize(stepSize),
       _toleranceAbs(0.001), _toleranceRel(0.001), _localError(0), _localErrorRatio(0)
{
}

} // namespace StepCore

#endif