CablePath.h

Go to the documentation of this file.

#ifndef SimTK_SIMBODY_CABLE_PATH_H_
#define SimTK_SIMBODY_CABLE_PATH_H_

/* -------------------------------------------------------------------------- *
 *                               Simbody(tm)                                  *
 * -------------------------------------------------------------------------- *
 * 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) 2012 Stanford University and the Authors.           *
 * Authors: Michael Sherman, Ian Stavness                                     *
 * Contributors: Andreas Scholz                                               *
 *                                                                            *
 * 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 "SimTKmath.h"
#include "simbody/internal/common.h"

namespace SimTK {

SimTK_DEFINE_UNIQUE_INDEX_TYPE(CableObstacleIndex);

class CableTrackerSubsystem;
class MobilizedBody;
class CableObstacle;

//==============================================================================
//                                CABLE PATH
//==============================================================================
class SimTK_SIMBODY_EXPORT CablePath {
public:

CablePath(CableTrackerSubsystem&    cables,
          const MobilizedBody&      originBody,
          const Vec3&               defaultOriginPoint,
          const MobilizedBody&      terminationBody,
          const Vec3&               defaultTerminationPoint);

CablePath(CableTrackerSubsystem&    cables,
          const MobilizedBody&      originBody,
          const MobilizedBody&      terminationBody);

CablePath(const CablePath& source);

CablePath& operator=(const CablePath& source);

~CablePath() {clear();}

void solveForInitialCablePath(State& state) const;

int getNumObstacles() const;
const CableObstacle& getObstacle(CableObstacleIndex obstacleIx) const;

Real getCableLength(const State& state) const;

Real getCableLengthDot(const State& state) const;

void applyBodyForces(const State& state, Real tension, 
                     Vector_<SpatialVec>& bodyForcesInG) const;

Real calcCablePower(const State& state, Real tension) const;

Real getIntegratedCableLengthDot(const State& state) const;

void setIntegratedCableLengthDot(State& state, Real value) const;


CablePath() : impl(0) {}
class Impl;
const Impl& getImpl() const {assert(impl); return *impl;}
Impl& updImpl() {assert(impl); return *impl;}
//--------------------------------------------------------------------------
private:
void clear();
Impl*   impl;
};


//==============================================================================
//                                CABLE OBSTACLE
//==============================================================================
class SimTK_SIMBODY_EXPORT CableObstacle {
public:
class ViaPoint; // also used for end points
class Surface;

CableObstacle() : impl(0) {}

explicit CableObstacle(CablePath& path);
CableObstacle(const CableObstacle& source);
CableObstacle& operator=(const CableObstacle& source);
~CableObstacle() {clear();}

const Transform& getDefaultTransform() const;
const MobilizedBody& getMobilizedBody() const;
const CablePath& getCablePath() const;
CableObstacleIndex getObstacleIndex() const;
const DecorativeGeometry& getDecorativeGeometry() const;
DecorativeGeometry& updDecorativeGeometry();

bool isDisabledByDefault() const;

CableObstacle& setDisabledByDefault(bool shouldBeDisabled);

CableObstacle& setDefaultTransform(const Transform& X_BS);

CableObstacle& setDecorativeGeometry(const DecorativeGeometry& viz);

void clear();
bool isEmpty() const {return impl==0;}

//--------------------------------------------------------------------------
class Impl;
const Impl& getImpl() const {assert(impl); return *impl;}
Impl&       updImpl()       {assert(impl); return *impl;}

protected:
explicit CableObstacle(Impl* impl);

private:
Impl*   impl; // opaque pointer to reference-counted implementation object
};


//==============================================================================
//                      CABLE OBSTACLE :: VIA POINT
//==============================================================================
class SimTK_SIMBODY_EXPORT CableObstacle::ViaPoint : public CableObstacle {
public:
ViaPoint() : CableObstacle() {}
ViaPoint(CablePath& path, const MobilizedBody& viaMobod, 
         const Vec3& defaultStation);

static bool isInstance(const CableObstacle&);
static const ViaPoint& downcast(const CableObstacle&);
static ViaPoint& updDowncast(CableObstacle&);

class Impl;
};

//==============================================================================
//                      CABLE OBSTACLE :: SURFACE
//==============================================================================
class SimTK_SIMBODY_EXPORT CableObstacle::Surface : public CableObstacle {
public:
Surface() : CableObstacle() {}

Surface(CablePath& path, const MobilizedBody& mobod,
        const Transform& X_BS, const ContactGeometry& surface);

Surface& setDecorativeGeometry(const DecorativeGeometry& viz)
{   CableObstacle::setDecorativeGeometry(viz); return *this; }

Surface& setNearPoint(const Vec3& point);
    
Surface& setContactPointHints(const Vec3& startHint, 
                              const Vec3& endHint);

static bool isInstance(const CableObstacle&);
static const Surface& downcast(const CableObstacle&);
static Surface& updDowncast(CableObstacle&);
class Impl;
};


} // namespace SimTK

#endif // SimTK_SIMBODY_CABLE_PATH_H_