BaseMechanicalState.h

Go to the documentation of this file.

/******************************************************************************
*       SOFA, Simulation Open-Framework Architecture, version 1.0 beta 3      *
*                (c) 2006-2008 MGH, INRIA, USTL, UJF, CNRS                    *
*                                                                             *
* This library is free software; you can redistribute it and/or modify it     *
* under the terms of the GNU Lesser General Public License as published by    *
* the Free Software Foundation; either version 2.1 of the License, or (at     *
* your option) any later version.                                             *
*                                                                             *
* This library is distributed in the hope that it will be useful, but WITHOUT *
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       *
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License *
* for more details.                                                           *
*                                                                             *
* You should have received a copy of the GNU Lesser General Public License    *
* along with this library; if not, write to the Free Software Foundation,     *
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.          *
*******************************************************************************
*                              SOFA :: Framework                              *
*                                                                             *
* Authors: M. Adam, J. Allard, B. Andre, P-J. Bensoussan, S. Cotin, C. Duriez,*
* H. Delingette, F. Falipou, F. Faure, S. Fonteneau, L. Heigeas, C. Mendoza,  *
* M. Nesme, P. Neumann, J-P. de la Plata Alcade, F. Poyer and F. Roy          *
*                                                                             *
* Contact information: contact@sofa-framework.org                             *
******************************************************************************/
#ifndef SOFA_CORE_COMPONENTMODEL_BEHAVIOR_BASEMECHANICALSTATE_H
#define SOFA_CORE_COMPONENTMODEL_BEHAVIOR_BASEMECHANICALSTATE_H

#include <sofa/defaulttype/Quat.h>
#include <sofa/core/objectmodel/BaseObject.h>
#include <sofa/defaulttype/BaseVector.h>
#include <sofa/defaulttype/Vec.h>  
#include <sstream>
#include <iostream>


namespace sofa
{

namespace core
{

namespace componentmodel
{

namespace behavior
{

class BaseMechanicalMapping;

class BaseMechanicalState : public virtual objectmodel::BaseObject
{
public:
    BaseMechanicalState()
    {}
    virtual ~BaseMechanicalState()
    { }

    virtual void resize(int vsize) = 0;

    virtual int getSize() const { return 0; }
    virtual double getPX(int /*i*/) const { return 0.0; }
    virtual double getPY(int /*i*/) const { return 0.0; }
    virtual double getPZ(int /*i*/) const { return 0.0; }


    virtual void beginIntegration(double /*dt*/) { }

    virtual void endIntegration(double /*dt*/) { }

    virtual void resetForce() =0;//{ vOp( VecId::force() ); }

    virtual void resetConstraint() =0;

    virtual void accumulateForce() { }

    virtual void accumulateDf() { }

    virtual void applyTranslation(const double dx, const double dy, const double dz)=0;
    
    
    virtual void applyRotation (const double /*rx*/, const double /*ry*/, const double /*rz*/){};
    
    virtual void applyRotation(const defaulttype::Quat q)=0;

    virtual void applyScale(const double s)=0;
    
    virtual void writeX(std::ostream &out)=0;
    virtual void readX(std::istream &in)=0;
    virtual double compareX(std::istream &in)=0;
    
    virtual void writeV(std::ostream &out)=0;
    virtual void readV(std::istream &in)=0;
    virtual double compareV(std::istream &in)=0;
    
    
    virtual bool addBBox(double* /*minBBox*/, double* /*maxBBox*/)
    {
      return false;
    }

    class VecId
    {
    public:
        enum { V_FIRST_DYNAMIC_INDEX = 8 }; 
        enum Type
        {
            V_NULL=0,
            V_COORD,
            V_DERIV,
            V_CONST
        };
        Type type;
        unsigned int index;
        VecId(Type t, unsigned int i) : type(t), index(i) { }
        VecId() : type(V_NULL), index(0) { }
        bool isNull() const { return type==V_NULL; }
        static VecId null()     { return VecId(V_NULL,0); }
        static VecId position() { return VecId(V_COORD,0); }
        static VecId restPosition() { return VecId(V_COORD,1); }
        static VecId velocity() { return VecId(V_DERIV,0); }
        static VecId restVelocity() { return VecId(V_DERIV,1); }
        static VecId force() { return VecId(V_DERIV,3); }
        static VecId dx() { return VecId(V_DERIV,4); }
        static VecId freePosition() { return VecId(V_COORD,2); }
        static VecId freeVelocity() { return VecId(V_DERIV,2); }
        static VecId holonomicC() {return VecId(V_CONST,0);}
        static VecId nonHolonomicC() {return VecId(V_CONST,1);}

        bool operator==(const VecId& v) const
        {
            return type == v.type && index == v.index;
        }
    };

    virtual void vAvail(VecId& v) = 0;

    virtual void vAlloc(VecId v) = 0;

    virtual void vFree(VecId v) = 0;

    virtual void vOp(VecId v, VecId a = VecId::null(), VecId b = VecId::null(), double f=1.0) = 0; // {}

    typedef helper::vector< std::pair< VecId, helper::vector< std::pair< VecId, double > > > > VMultiOp;

    virtual void vMultiOp(const VMultiOp& ops)
    {
    for(VMultiOp::const_iterator it = ops.begin(), itend = ops.end(); it != itend; ++it)
    {
        VecId r = it->first;
        const helper::vector< std::pair< VecId, double > >& operands = it->second;
        int nop = operands.size();
        if (nop==0)
        {
        vOp(r);
        }
        else if (nop==1)
        {
        if (operands[0].second == 1.0)
            vOp(r, operands[0].first);
        else
            vOp(r, VecId::null(), operands[0].first, operands[0].second);
        }
        else
        {
        int i;
        if (operands[0].second == 1.0)
        {
            vOp(r, operands[0].first, operands[1].first, operands[1].second);
            i = 2;
        }
        else
        {
            vOp(r, VecId::null(), operands[0].first, operands[0].second);
            i = 1;
        }
        for (;i<nop;++i)
            vOp(r, r, operands[i].first, operands[i].second);
        }
    }
    }

    virtual double vDot(VecId a, VecId b) = 0; //{ return 0; }
    
    virtual void vThreshold( VecId a, double threshold )=0;

    virtual void setX(VecId v) = 0; //{}

    virtual void setXfree(VecId v) = 0; //{}

    virtual void setVfree(VecId v) = 0; //{}

    virtual void setV(VecId v) = 0; //{}

    virtual void setF(VecId v) = 0; //{}

    virtual void setDx(VecId v) = 0; //{}

    virtual void setC(VecId v) = 0;



    virtual void getCompliance(double ** /*w*/){ }
    virtual void applyContactForce(double * /*f*/){ }

    virtual void resetContactForce(void) {}

    virtual void addDxToCollisionModel(void) = 0; //{}

    virtual void contributeToMatrixDimension(unsigned int * const, unsigned int * const) = 0;

    virtual void loadInBaseVector(defaulttype::BaseVector *, VecId , unsigned int &) = 0;

    virtual void addBaseVectorToState(VecId , defaulttype::BaseVector *, unsigned int &) = 0;

    virtual void setOffset(unsigned int &) = 0;


    virtual void printDOF( VecId, std::ostream& =std::cerr ) = 0;
    virtual void initGnuplot(const std::string){}
    virtual void exportGnuplot(double){}
    virtual unsigned printDOFWithElapsedTime(VecId, unsigned =0, unsigned =0, std::ostream& =std::cerr ){return 0;};

};

inline std::ostream& operator<<(std::ostream& o, const BaseMechanicalState::VecId& v)
{
    switch (v.type)
    {
    case BaseMechanicalState::VecId::V_NULL: o << "vNull"; break;
    case BaseMechanicalState::VecId::V_COORD: o << "vCoord"; break;
    case BaseMechanicalState::VecId::V_DERIV: o << "vDeriv"; break;
    case BaseMechanicalState::VecId::V_CONST: o << "vConst"; break;
    default: o << "vUNKNOWN"; break;
    }
    o << '[' << v.index << ']';
    return o;
}

} // namespace behavior

} // namespace componentmodel

} // namespace core

} // namespace sofa

#endif