AnimaL

Tutorial

Documentation

---

Documentation

• Overview
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Compound List
• File List
• Namespace Members
• Compound Members
• File Members
• Examples

---

massspringsolver.h

Go to the documentation of this file.

/***************************************************************************
                          massspringsolver.h  -  description
                             -------------------
    begin                : Thu Nov 27 2003
    copyright            : (C) 2003 by François Faure, GRAVIR
    email                : Francois.Faure@imag.fr
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef MASSSPRINGSOLVER_H
#define MASSSPRINGSOLVER_H

#include <utility>
#include <animal/vector.h>
#include <animal/physicalSolver.h>
#include <animal/odeImplicitSolver.h>
#include<iostream>
using std::cerr; using std::endl;

namespace animal
{
template<class t_Positions,
  class t_Vector,
  class t_InvMasses,
  class t_VecReal,
  class t_VecIndex
  >
class MassSpringSolver
: public OdeImplicitSolver<t_Positions,t_Vector,typename value_type<t_VecReal>::type>
, public PhysicalSolver<t_Positions,t_Vector,t_InvMasses,typename value_type<t_VecReal>::type>
{
public:

  typedef t_Positions Positions;        
  typedef typename container_traits<Positions>::value_type Position;    
  typedef t_Vector Vector;  
  typedef typename container_traits<Vector>::value_type Vec;    
  typedef t_VecReal VecReal;                              
  typedef typename value_type<VecReal>::type Real;                  
  typedef t_VecIndex VecIndex;                            
  typedef typename value_type<VecIndex>::type Index;              
  //typedef std::pair<Index,Index> Link; ///< A pair of indices describing a connection between two particles.
  //typedef animal::vector<Index> Links;  ///< a set of connections
  //typedef animal::vector<Real> VecReal;  ///< a set of real values
  typedef PhysicalSolver<t_Positions,t_Vector,t_InvMasses,typename value_type<t_VecReal>::type> _PhysicalSolver; 
  typedef OdeImplicitSolver<t_Positions,t_Vector,typename value_type<t_VecReal>::type>  _OdeImplicitSolver;  
      
    MassSpringSolver();
    ~MassSpringSolver();
  virtual void setMethod( int );
  virtual int getMethod() const;
  void setIsotropy( Real iso );
  Real getIsotropy() const;

  virtual void set_common_damping_ratio( const Real& _newVal);
  virtual const Real& get_common_damping_ratio();

  virtual void set_spring_indices( VecIndex* _newVal);
  virtual void set_stiffnesses( VecReal* _newVal);

  inline void create_rest_lengths( const Positions& p )
{
  assert( size(*_links)%2==0 );
    if(!_restLengths) _restLengths = new VecReal;
    _own_restLengths = true;
    for( unsigned int i=0; i<_links->size(); i+=2 )
    {
    Position x =  p[(*_links)[i]];
    cerr<<"p0 = " << x <<", p1 = "<< p[(*_links)[i+1]]
    << endl;
    v_meq( x, p[(*_links)[i+1]] );   // x==p[a]-p[b]
      _restLengths->push_back( v_norm( x ) );
    }
    cerr<<"MassSpringSolver<P,V,Im,R,I>::create_rest_lengths: "
    << *_restLengths
    << endl;
}

  inline void set_rest_lengths( VecReal* r )
{
  assert( r );
  assert(_links);
  cerr<<"size(*_links)== "<<size(*_links)<<endl;
  cerr<<"size(*r)== "<<size(*r)<<endl;
  assert( size(*_links)/2==size(*r) );
  this->_restLengths = r;
    _own_restLengths = false;
}
  VecReal* get_rest_lengths(){ return _restLengths;}
  
    static Real get_thresholdDistance(){
        return _thresholdDistance;
    }
    static void set_thresholdDistance(Real threshold){
        _thresholdDistance=threshold;
    }
    
    bool get_debugInfo() const{return _debug;}
    
    void set_debugInfo(bool b) {_debug=b;}
  

//protected: 
    VecIndex* _links; 
    VecReal* _stiffnesses;  
    VecReal* _restLengths; 
    bool _own_restLengths; 
//  Real _common_damping_ratio; ///< Value of the damping ratio applied to all springs
  animal::vector<Vec> _directions;  
  Real _isotropy; 

  virtual void solveODE( Positions& pos, Vector& vel, Real dt);

  static void accumulateSpringForce(
    Vec& fa, Vec& fb,
        const Vec& pa, const Vec& pb,
        const Vec& va, const Vec& vb,
        const Real& stiffness, const Real& dampingRatio, const Real& restLength
    );
  static void accumulateSpringForceAndGradientMatrix(
    Vec& fa, Vec& fb, Vec& grad,
        const Vec& pa, const Vec& pb,
        const Vec& va, const Vec& vb,
        const Real& stiffness, const Real& dampingRatio, const Real& restLength
    );
  static bool computeDistanceAndDirection(Real& d, Vec& u, const Vec& pa, const Vec& pb);
  virtual void computeForces( Vector& f, const Positions& p, const Vector& v);

  virtual void computeAccelerations (Vector & acc, const Positions & pos, const Vector & vel);

  virtual void computeAccelerationsAndStiffness (Vector & acc, const Positions & pos, const Vector & vel);

//  /** Compute the force applied to the particles and update the gradient matrix.
//  \param f force vector
//  \param p current positions
//  \param v current velocities
//  */
//  virtual void computeForce( Vector& f, const Positions& p, const Vector& v );

    virtual void applyForces( Vector& a, const Vector& f);

    virtual void v_eq_h_dfdx_x( Vector& v, Real h, const Vector& x );

    virtual void v_peq_h_dfdx_x( Vector& v, Real h, const Vector& x );
    
    
//private:
   static Real _thresholdDistance; 
    static bool _debug; 

};

}//animal
#endif

---