/home/hauberg/Dokumenter/Capture/humim-tracker-0.1/src/OpenTissue/OpenTissue/dynamics/mbd/mbd_material.h

Go to the documentation of this file.

#ifndef OPENTISSUE_DYNAMICS_MBD_MBD_MATERIAL_H
#define OPENTISSUE_DYNAMICS_MBD_MBD_MATERIAL_H
//
// OpenTissue Template Library
// - A generic toolbox for physics-based modeling and simulation.
// Copyright (C) 2008 Department of Computer Science, University of Copenhagen.
//
// OTTL is licensed under zlib: http://opensource.org/licenses/zlib-license.php
//
#include <OpenTissue/configuration.h>

#include <boost/cast.hpp>  // needed for boost::numeric_cast

namespace OpenTissue
{

  namespace mbd
  {

    template<typename mbd_types>
    class Material
    {
    public:

      typedef typename mbd_types::math_policy    math_policy;
      typedef typename math_policy::real_type      real_type;
      typedef typename math_policy::value_traits   value_traits;
      typedef typename math_policy::index_type     index_type;
      typedef typename math_policy::index_type     size_type;
      typedef typename math_policy::vector_type    vector_type;
      typedef typename math_policy::vector_range   vector_range;
      typedef typename math_policy::vector3_type   vector3_type;

    protected:

      index_type   m_material_idx_A;          
      index_type   m_material_idx_B;          

      vector_type  m_mu;                      
      real_type    m_e_n;                     
      real_type    m_e_t;                     
      real_type    m_erp;                     
      real_type    m_gamma;                   
      
      bool         m_use_sliding_direction;   
      bool         m_use_prefixed_direction;  

      vector3_type m_prefixed_direction;      
      index_type   m_prefixed_material_idx;   
    public:

      Material(){        clear();      }



      virtual ~Material(){  }

      bool operator==(Material const & m) const
      {
        if(m_material_idx_A == m.m_material_idx_A && m_material_idx_B==m.m_material_idx_B)
          return true;
        return false;
      }

    public:

      void clear()
      {
        m_material_idx_A = 0;
        m_material_idx_B = 0;
        m_e_n = value_traits::half();
        m_e_t = value_traits::zero();
        m_erp = boost::numeric_cast<real_type>(0.8);
        m_gamma = value_traits::zero();
        m_use_sliding_direction = true;
        m_use_prefixed_direction = false;
        m_prefixed_direction = vector3_type( value_traits::zero(), value_traits::zero(), value_traits::zero() );
        m_prefixed_material_idx  = 0;
        math_policy::resize(m_mu, 2);
        std::fill( m_mu.begin(), m_mu.end(), value_traits::half() );
      }

      void set_material_indices(index_type A, index_type B)
      {
        if(A<B)
        {
          this->m_material_idx_A = A;
          this->m_material_idx_B = B;
        }
        else
        {
          this->m_material_idx_A = B;
          this->m_material_idx_B = A;
        }
      }

      index_type hash_key() const {  return Material::hash_key(m_material_idx_A,m_material_idx_B); }

      static index_type hash_key(index_type A, index_type B){ return (A < B) ? ((A<<16)|(B&0x0000FFFF)) : ((B<<16)|(A&0x0000FFFF)) ; }

    public:

      void set_friction_coefficient(real_type const & mu)
      {
        assert(mu>value_traits::zero() || !"Material::set_friction_coefficient(): value must be positive");
        assert(m_mu.size()>0           || !"Material::set_friction_coefficient(): No friction directions exist");
        std::fill( m_mu.begin(), m_mu.end(), value_traits::half() );
      }

      void set_friction_coefficient(size_t const & idx, real_type const & mu)
      {
        assert(mu>value_traits::zero() || !"Material::set_friction_coefficient(): value must be positive");
        assert(m_mu.size()>0           || !"Material::set_friction_coefficient(): No friction directions exist");
        assert(idx < m_mu.size()       || !"Material::set_friction_coefficient(): No such friction direction exist");
        this->m_mu(idx) = mu;
      }

      real_type const & get_friction_coefficient(size_t const & idx) const
      {
        assert(m_mu.size()>0           || !"Material::get_friction_coefficient(): No friction directions exist");
        assert(idx < m_mu.size()       || !"Material::get_friction_coefficient(): No such friction direction exist");
        return this->m_mu(idx);
      }

      real_type get_isotropic_friction_coefficient() const
      {
        if( m_mu.empty() )
          return value_traits::zero();
        return m_mu(0);
      }

      void set_number_of_friction_directions(size_t const & eta)
      {
        using std::min;

        // Make local copy of old friction coefficient values
        size_t old_eta = m_mu.size();
        vector_type tmp;
        math_policy::resize(tmp, old_eta );
        tmp = m_mu;

        // Resize the friction coefficient value vector to match new number of friction directions.
        math_policy::resize( m_mu, eta );

        size_t N = min(old_eta,eta);
        if(N>0)
        {
          size_t i = 0;
          // Copy the old friction coefficient values into the resized vector
          for(;i<N;++i)
            m_mu(i) = tmp(i);
          // Assign the friction coefficient value of the last old direction to all the newly created directions.
          for(;i<eta;++i)
            m_mu(i) = tmp(N-1);
        }
      }

      size_t get_number_of_friction_directions() const 
      {
        return m_mu.size();
      }

      real_type const & normal_restitution()            const { return this->m_e_n; }
      real_type       & normal_restitution()                  { return this->m_e_n; }

      real_type const & tangential_restitution()        const { return this->m_e_t; }
      real_type       & tangential_restitution()              { return this->m_e_t; }

      real_type const & get_error_reduction_parameter() const { return m_erp;       }
      void set_error_reduction_parameter(real_type const & erp)
      {
        assert(erp>=0 || !"Material::set_error_reduction_parameter(): value must be non-negative");
        assert(erp<=1 || !"Material::set_error_reduction_parameter(): value must be less than or equal 1");
        this->m_erp = erp;
      }

      void set_normal_regularization(real_type const & gamma)
      {
        assert(is_number(gamma)              || !"Material::set_regularization(): not a number was encountered");
        assert(gamma <= value_traits::one()  || !"Material::set_regularization(): gamma must be less than or equal to one");
        assert(gamma >= value_traits::zero() || !"Material::set_regularization(): gamma must be non-negative");
        m_gamma = gamma;
      }

      real_type const & get_normal_regularization() const  {   return m_gamma;  }

      bool get_use_sliding_direction() const { return m_use_sliding_direction; }

      void set_use_sliding_direction(bool const & value) { m_use_sliding_direction = value; }

      bool get_use_prefixed_direction() const { return m_use_prefixed_direction; }

      void set_use_prefixed_direction(bool const & value) { m_use_prefixed_direction = value; }

      vector3_type const & get_prefixed_direction() const {  return m_prefixed_direction; }

      void set_prefixed_direction(vector3_type const & dir)  {  m_prefixed_direction = unit( dir ); }

      void set_prefixed_material_index(index_type const & idx)
      {
        m_prefixed_material_idx = idx;
      }


      index_type get_prefixed_material_index() const
      {
        return m_prefixed_material_idx;
      }
    
    };

  } // namespace mbd
} // namespace OpenTissue
// OPENTISSUE_DYNAMICS_MBD_MBD_MATERIAL_H
#endif