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_