Integrator.h

Go to the documentation of this file.

#ifndef SimTK_SIMMATH_INTEGRATOR_H_
#define SimTK_SIMMATH_INTEGRATOR_H_

/* -------------------------------------------------------------------------- *
 *                        Simbody(tm): SimTKmath                              *
 * -------------------------------------------------------------------------- *
 * This is part of the SimTK 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/home/simbody.  *
 *                                                                            *
 * Portions copyright (c) 2006-12 Stanford University and the Authors.        *
 * Authors: Michael Sherman                                                   *
 * Contributors:                                                              *
 *                                                                            *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may    *
 * not use this file except in compliance with the License. You may obtain a  *
 * copy of the License at http://www.apache.org/licenses/LICENSE-2.0.         *
 *                                                                            *
 * Unless required by applicable law or agreed to in writing, software        *
 * distributed under the License is distributed on an "AS IS" BASIS,          *
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   *
 * See the License for the specific language governing permissions and        *
 * limitations under the License.                                             *
 * -------------------------------------------------------------------------- */

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

namespace SimTK {

    
class IntegratorRep;

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

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

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

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

    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;

    enum SuccessfulStepStatus {
        ReachedReportTime    =1,
        ReachedEventTrigger  =2,
        ReachedScheduledEvent=3,
        TimeHasAdvanced      =4,
        ReachedStepLimit     =5,
        EndOfSimulation      =6,
        StartOfContinuousInterval=7,
        InvalidSuccessfulStepStatus = -1
    };
    static String getSuccessfulStepStatusString(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;

    static String getTerminationReasonString(TerminationReason);

    void resetAllStatistics();

    Real getActualInitialStepSizeTaken() const;

    Real getPreviousStepSizeTaken() const;

    Real getPredictedNextStepSize() const;

    int getNumStepsAttempted() const;
    int getNumStepsTaken() const; 
    int getNumRealizations() const;
    int getNumQProjections() const;
    int getNumUProjections() const;
    int getNumProjections() const;
    int getNumErrorTestFailures() const;
    int getNumConvergenceTestFailures() const;
    int getNumRealizationFailures() const;
    int getNumQProjectionFailures() const;
    int getNumUProjectionFailures() 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 setConstraintTolerance(Real consTol);
    void setUseInfinityNorm(bool useInfinityNorm);
    bool isInfinityNormInUse() const;


    void setInternalStepLimit(int nSteps);

    void setReturnEveryInternalStep(bool shouldReturn);

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

    static String successfulStepStatusString(SuccessfulStepStatus stat)
    {   return getSuccessfulStepStatusString(stat); }

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;
};

} // namespace SimTK

#endif // SimTK_SIMMATH_INTEGRATOR_H_