Motion.h

Go to the documentation of this file.

#ifndef SimTK_SIMBODY_MOTION_H_
#define SimTK_SIMBODY_MOTION_H_
/* -------------------------------------------------------------------------- *
 *                      SimTK Core: SimTK Simbody(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) 2009 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 "simbody/internal/common.h"

namespace SimTK {

class SimbodyMatterSubsystem;
class MobilizedBody;
class Motion;
class MotionImpl;

// We only want the template instantiation to occur once. This symbol is defined 
// in the Simbody compilation unit that defines the Motion class but should not 
// be defined any other time.
#ifndef SimTK_SIMBODY_DEFINING_MOTION
    extern template class PIMPLHandle<Motion, MotionImpl, true>;
#endif

class SimTK_SIMBODY_EXPORT Motion : public PIMPLHandle<Motion, MotionImpl, true> {
public:
    enum Level {
        Acceleration = 0, 
        Velocity     = 1, 
        Position     = 2  
    };
    static const char* nameOfLevel(Level);

    enum Method {
        Zero        = 0,
        Discrete    = 1, 
        Prescribed  = 2, 
        Free        = 3, 
        Fast        = 4  
    };
    static const char* nameOfMethod(Method);

    Motion() { }
    explicit Motion(MotionImpl* r) : HandleBase(r) { }

    const MobilizedBody& getMobilizedBody() const;

    Level  getLevel(const State&) const;
    Method getLevelMethod(const State&) const;

    // This implements the above table. Given the (level,method) Motion specification,
    // it reports the actual method to be used for each of the three levels.
    void calcAllMethods(const State& s, Method& qMethod, Method& uMethod, Method& udotMethod) const {
        const Level  level       = getLevel(s);
        const Method levelMethod = getLevelMethod(s);
        Method method[3]; // acc, vel, pos
        method[level] = levelMethod;

        switch (level) {
          case Position:
            method[Velocity]=method[Acceleration]= 
                (levelMethod==Prescribed ? Prescribed : Zero);
            break;
          case Velocity:
            method[Acceleration] = (levelMethod==Prescribed ? Prescribed : Zero);
            method[Position]     = (levelMethod==Zero       ? Discrete   : Free);
            break;
          case Acceleration:
            method[Velocity] = (levelMethod==Zero ? Discrete : Free);
            method[Position] = Free;
            break;
          default:
            assert(!"unrecognized level");
        }

        qMethod    = method[Position];
        uMethod    = method[Velocity];
        udotMethod = method[Acceleration];
    }
    
    class Steady;
    class Linear;
    class Sinusoid;
    class Polynomial;
    class Composite;
    class Custom;
    
    class SteadyImpl;
    class LinearImpl;
    class SinusoidImpl;
    class PolynomialImpl;
    class CompositeImpl;
    class CustomImpl;
};

class SimTK_SIMBODY_EXPORT Motion::Sinusoid : public Motion {
public:
    Sinusoid(MobilizedBody& mobod, Motion::Level level,
             Real amplitude, Real rate, Real phase);

    SimTK_INSERT_DERIVED_HANDLE_DECLARATIONS(Sinusoid, SinusoidImpl, Motion);
};

class SimTK_SIMBODY_EXPORT Motion::Steady : public Motion {
public:
    Steady(MobilizedBody& mobod, Real u);
    template <int N> SimTK_SIMBODY_EXPORT 
    Steady(MobilizedBody& mobod, const Vec<N>& u); // instantiated in library

    Steady& setDefaultRate(Real u);
    Steady& setOneDefaultRate(UIndex, Real u);
    template <int N> SimTK_SIMBODY_EXPORT 
    Steady& setDefaultRates(const Vec<N>& u); // instantiated in library

    Real getDefaultRate(UIndex=UIndex(0)) const;

    void setRate(State&, Real u) const; // all axes set to u
    void setOneRate(State&, UIndex, Real u) const;

    SimTK_INSERT_DERIVED_HANDLE_DECLARATIONS(Steady, SteadyImpl, Motion);
};


class SimTK_SIMBODY_EXPORT Motion::Custom : public Motion {
public:
    class Implementation;
    Custom(MobilizedBody& mobod, Implementation* implementation);
    SimTK_INSERT_DERIVED_HANDLE_DECLARATIONS(Custom, CustomImpl, Motion);
protected:
    const Implementation& getImplementation() const;
    Implementation& updImplementation();
};

class SimTK_SIMBODY_EXPORT Motion::Custom::Implementation {
public:
    virtual ~Implementation() { }

    virtual Implementation* clone() const {
        SimTK_ERRCHK_ALWAYS(!"unimplemented",
            "Motion::Custom::Implementation::clone()",
            "Concrete Implementation did not supply a clone() method, "
            "but a copy operation was attempted.");
        /*NOTREACHED*/
        return 0;
    }

    virtual Motion::Level getLevel(const State&) const = 0;

    virtual Motion::Method getLevelMethod(const State&) const {
        return Motion::Prescribed;
    }






    virtual void calcPrescribedPosition(const State& s, int nq, Real* q) const;

    virtual void calcPrescribedPositionDot(const State& s, int nq, Real* qdot) const;

    virtual void calcPrescribedPositionDotDot(const State& s, int nq, Real* qdotdot) const;








    virtual void calcPrescribedVelocity(const State& s, int nu, Real* u) const;

    virtual void calcPrescribedVelocityDot(const State& s, int nu, Real* udot) const;







    virtual void calcPrescribedAcceleration(const State& s, int nu, Real* udot) const;

    virtual void realizeTopology    (State&       state) const {}
    virtual void realizeModel       (State&       state) const {}
    virtual void realizeInstance    (const State& state) const {}
    virtual void realizeTime        (const State& state) const {}
    virtual void realizePosition    (const State& state) const {}
    virtual void realizeVelocity    (const State& state) const {}
    virtual void realizeDynamics    (const State& state) const {}
    virtual void realizeAcceleration(const State& state) const {}
    virtual void realizeReport      (const State& state) const {}
};

} // namespace SimTK

#endif // SimTK_SIMBODY_MOTION_H_