AnimaL

Tutorial

Documentation

---

Documentation

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

---

simplesolver.inl

Go to the documentation of this file.

/***************************************************************************
                          simplesolver.cpp  -  description
                             -------------------
    begin                : Sat Nov 8 2003
    copyright            : (C) 2003 by François Faure
    email                : 
 ***************************************************************************/

#include "simplesolver.h"
#include <animal/value.h>
#include <animal/linear.h>
#include <animal/odeSolver.inl>

namespace animal
{
//template<>
//struct Value< animal::Array<3,float> >
//{
//  static inline animal::Array<3,float> zero(){ return animal::Array<3,float>(  (float)0. ); }
//};




  template < class P, class V, class I, class R >
    SimpleSolver < P, V, I, R >::SimpleSolver ():OdeSolver < P, V,
    R > (), _gravity (Value < Vec >::zero ()), _useGravity (false),
    _exponentialDamping (0), _invMasses (0),
    _useExponentialDamping (false), _useMass (false), _useSingleMass (false)
  {
  }
  template < class P, class V, class I, class R > SimpleSolver < P,
    V, I, R >::~SimpleSolver ()
  {
  }

  template < class P, class V, class I, class R >
    const typename SimpleSolver < P,
    V, I, R >::Vec & SimpleSolver < P, V, I, R >::get_gravity ()
  {
    return _gravity;
  }

  template < class P, class V, class I, class R > void SimpleSolver < P,
    V, I, R >::set_gravity (const Vec & _newVal)
  {
    _gravity = _newVal;
    set_useGravity (true);
  }
  template < class P, class V, class I, class R >
    const bool & SimpleSolver < P, V, I, R >::get_useGravity ()
  {
    return _useGravity;
  }
  template < class P, class V, class I, class R > void SimpleSolver < P,
    V, I, R >::set_useGravity (const bool & _newVal)
  {
    _useGravity = _newVal;
  }
  template < class P, class V, class I, class R >
    const bool & SimpleSolver < P, V, I, R >::get_useExponentialDamping ()
  {
    return _useExponentialDamping;
  }
  template < class P, class V, class I, class R > void SimpleSolver < P,
    V, I, R >::set_useExponentialDamping (const bool & _newVal)
  {
    cerr<<"SimpleSolver::set_useExponentialDamping "<< _newVal << endl;
    _useExponentialDamping = _newVal;
  }
  template < class P, class V, class I, class R >
    const typename SimpleSolver < P,
    V, I, R >::Real & SimpleSolver < P, V, I, R >::get_exponentialDamping ()
  {
    return _exponentialDamping;
  }
  template < class P, class V, class I, class R > void SimpleSolver < P,
    V, I, R >::set_exponentialDamping (const Real & _newVal)
  {
    _exponentialDamping = _newVal;
    set_useExponentialDamping (true);
  }
  template < class P, class V, class I, class R > void SimpleSolver < P,
    V,
    I,
    R >::applyGravity (Vector & acc)
  {
    if (_useGravity)
      {
        // cerr<<"apply gravity"<<endl;
        if (_useMass && !_useSingleMass)
          {
//            cerr<<"apply gravity "<<_gravity<<" with masses "<<(*_invMasses)<<endl;
            for (unsigned int i = 0; i < size (acc); ++i)
              if ((*_invMasses)[i] == 0)
                acc[i] = zero ();
              else v_peq(acc[i],_gravity);
          }
        else
          v_addall (acc, _gravity);
      }
//      else cerr<<"SimpleSolver no gravity"<< endl;
}

  template < class P, class V, class I, class R > void SimpleSolver < P,
    V,
    I,
    R >::computeAccelerations (Vector & acc, const
                              Positions & pos, const Vector & vel)
  {

    computeForces (acc, pos, vel);
    // a==f

    applyForces( acc, acc );
    // a== f/m

    // add gravity
    applyGravity( acc );
    // a == g + f/m
  }

  template < class P, class V, class I, class R > void SimpleSolver < P,
    V,
    I,
    R >::applyForces (V & acc, const V & f)
  {
    assert( size(acc)==size(f) );

    //cerr<<"SimpleSolver applyForces, f= "<<f<<endl;
    // mass
    if (_useMass)
      {
        if (_useSingleMass)
          v_eq_ab (acc, _singleInvMass, f );
        else                    // each particle has its own mass
          for (unsigned int i = 0; i < size (acc); ++i)
            {
              v_eq_ab(acc[i], (*_invMasses)[i], f[i] );
            }
      }
      else
      {
                v_eq (acc, f);
      }
    // a==f/m

    //cerr<<"SimpleSolver applyForces, acc= "<<acc<<endl;


  }
  template < class P, class V, class I, class R > void SimpleSolver < P,
    V, I, R >::solveODE (Positions & p, Vector & v, Real dt)
  {
    Parent::solveODE (p, v, dt);
    cerr<<"SimpleSolver::SolveODE" << endl;
    // damping
    if (_useExponentialDamping)
      {
        cerr<<"SimpleSolver::SolveODE, exponentialDamping= " << _exponentialDamping << endl;
        Real factor = exp (-_exponentialDamping * dt);
        v_teq (v, factor);
      }
  }
  template < class P, class V, class I, class R > void SimpleSolver < P,
    V, I, R >::computeForces (Vector & f, const Positions &, const Vector &)
  {
    v_assign (f, zero ());
  }
  template < class P, class V, class I, class R >
    const bool & SimpleSolver < P, V, I, R >::get_useMass ()
  {
    return _useMass;
  }
  template < class P, class V, class I, class R > void SimpleSolver < P,
    V, I, R >::set_useMass (const bool & _newVal)
  {
    _useMass = _newVal;
  }
  template < class P, class V, class I, class R >
    const bool & SimpleSolver < P, V, I, R >::get_useSingleMass ()
  {
    return _useSingleMass;
  }
  template < class P, class V, class I, class R > void SimpleSolver < P,
    V, I, R >::set_useSingleMass (const bool & _newVal)
  {
    _useSingleMass = _newVal;
  }
  template < class P, class V, class I, class R >
    const typename SimpleSolver < P,
    V, I, R >::InvMass & SimpleSolver < P, V, I, R >::get_singleInvMass ()
  {
    return _singleInvMass;
  }
  template < class P, class V, class I, class R > void SimpleSolver < P,
    V, I, R >::set_singleInvMass (const InvMass & _newVal)
  {
    _singleInvMass = _newVal;
    _useSingleMass = true;
  }
  template < class P, class V, class I, class R >
    const typename SimpleSolver < P,
    V, I, R >::InvMasses * SimpleSolver < P, V, I, R >::get_invMasses ()
  {
    return _invMasses;
  }
  template < class P, class V, class I, class R > void SimpleSolver < P,
    V, I, R >::set_invMasses (InvMasses * _newVal)
  {
    _invMasses = _newVal;
    set_useMass(true);
    set_useSingleMass(false);
  }


}                               // animal

---