Integrator.h

Go to the documentation of this file.

#ifndef SimTK_SIMMATH_INTEGRATOR_H_
#define SimTK_SIMMATH_INTEGRATOR_H_

/* -------------------------------------------------------------------------- *
 *                      SimTK Core: SimTK Simmath(tm)                         *
 * -------------------------------------------------------------------------- *
 * This is part of the SimTK Core biosimulation toolkit originating from      *
 * Simbios, the NIH National Center for Physics-Based Simulation of           *
 * Biological Structures at Stanford, funded under the NIH Roadmap for        *
 * Medical Research, grant U54 GM072970. See https://simtk.org.               *
 *                                                                            *
 * Portions copyright (c) 2006-7 Stanford University and the Authors.         *
 * Authors: Michael Sherman                                                   *
 * Contributors:                                                              *
 *                                                                            *
 * Permission is hereby granted, free of charge, to any person obtaining a    *
 * copy of this software and associated documentation files (the "Software"), *
 * to deal in the Software without restriction, including without limitation  *
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
 * and/or sell copies of the Software, and to permit persons to whom the      *
 * Software is furnished to do so, subject to the following conditions:       *
 *                                                                            *
 * The above copyright notice and this permission notice shall be included in *
 * all copies or substantial portions of the Software.                        *
 *                                                                            *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
 * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
 * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
 * -------------------------------------------------------------------------- */

#include "SimTKcommon.h"
#include "simmath/internal/common.h"

namespace SimTK {

    
class IntegratorRep;

class SimTK_SIMMATH_EXPORT Integrator {
public:
    Integrator() : rep(0) { }

    // These are the exceptions that can be thrown by this class.

    class InitializationFailed;
    class StepSizeTooSmall;
    class StepFailed;
    class TriedToAdvancePastFinalTime;
    class CantAskForEventInfoWhenNoEventTriggered;

    const char* getMethodName();
    int         getMethodMinOrder();
    int         getMethodMaxOrder();
    bool        methodHasErrorControl();

    void initialize(const State& state);

    void reinitialize(Stage stage, bool shouldTerminate);

    const State& getState() const;
    Real         getTime() const {return getState().getTime();}

    bool isStateInterpolated() const;

    const State& getAdvancedState() const;
    Real         getAdvancedTime() const {return getAdvancedState().getTime();}

    State& updAdvancedState();

    Real getAccuracyInUse() const;
    Real getConstraintToleranceInUse() const;
    Real getTimeScaleInUse() const;
    const Vector& getStateWeightsInUse() const;
    const Vector& getConstraintWeightsInUse() const;

    enum SuccessfulStepStatus {
        ReachedReportTime    =1,
        ReachedEventTrigger  =2,
        ReachedScheduledEvent=3,
        TimeHasAdvanced      =4,
        ReachedStepLimit     =5,
        EndOfSimulation      =6,
        StartOfContinuousInterval=7,
        InvalidSuccessfulStepStatus = -1
    };
    static String successfulStepStatusString(SuccessfulStepStatus);

    SuccessfulStepStatus stepTo(Real reportTime, Real scheduledEventTime=Infinity);
    SuccessfulStepStatus stepBy(Real interval, Real scheduledEventTime=Infinity);


    Vec2 getEventWindow() const;
    const Array_<EventId>& getTriggeredEvents() const;
    const Array_<Real>& getEstimatedEventTimes() const;
    const Array_<Event::Trigger>& getEventTransitionsSeen() const;


        // TERMINATION //

    enum TerminationReason {
        ReachedFinalTime                 = 1,
        AnUnrecoverableErrorOccurred     = 2,
        EventHandlerRequestedTermination = 3,
        InvalidTerminationReason         = -1
    };

    bool isSimulationOver() const;

    TerminationReason getTerminationReason() const;

    void resetAllStatistics();

    Real getActualInitialStepSizeTaken() const;

    Real getPreviousStepSizeTaken() const;

    Real getPredictedNextStepSize() const;

    int getNumStepsAttempted() const;
    int getNumStepsTaken() const; 
    int getNumRealizations() const;
    int getNumProjections() const;
    int getNumErrorTestFailures() const;
    int getNumConvergenceTestFailures() const;
    int getNumRealizationFailures() const;
    int getNumProjectionFailures() const;
    int getNumConvergentIterations() const;
    int getNumDivergentIterations() const;
    int getNumIterations() const;

    void setFinalTime(Real tFinal);
    void setInitialStepSize(Real hinit);
    void setMinimumStepSize(Real hmin);
    void setMaximumStepSize(Real hmax);
    
    void setFixedStepSize(Real stepSize);

    void setAccuracy(Real accuracy);
    void setRelativeTolerance(Real relTol);
    void setAbsoluteTolerance(Real absTol);
    void setConstraintTolerance(Real consTol);

    void setInternalStepLimit(int nSteps);

    void setReturnEveryInternalStep(bool shouldReturn);

    void setProjectEveryStep(bool forceProject);    
    void setAllowInterpolation(bool shouldInterpolate);
    void setProjectInterpolatedStates(bool shouldProject);


protected:
    const IntegratorRep& getRep() const {assert(rep); return *rep;}
    IntegratorRep&       updRep()       {assert(rep); return *rep;}

    // opaque implementation for binary compatibility
    IntegratorRep* rep;
    friend class IntegratorRep;

private:
    // OBSOLETE
    int getNStepsAttempted() const {return getNumStepsAttempted();}
    int getNStepsTaken() const {return getNumStepsTaken();} 
    int getNRealizations() const {return getNumRealizations();}
    int getNProjections() const {return getNumProjections();}
    int getNErrorTestFailures() const {return getNumErrorTestFailures();}
    int getNRealizationFailures() const {return getNumRealizationFailures();}
    int getNProjectionFailures() const {return getNumProjectionFailures();}
};

} // namespace SimTK

#endif // SimTK_SIMMATH_INTEGRATOR_H_