/home/hauberg/Dokumenter/Capture/humim-tracker-0.1/src/OpenTissue/OpenTissue/dynamics/sph/sph_particle.h

Go to the documentation of this file.

#ifndef OPENTISSUE_DYNAMICS_SPH_SPH_PARTICLE_H
#define OPENTISSUE_DYNAMICS_SPH_SPH_PARTICLE_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 <OpenTissue/utility/utility_runtime_type.h>

namespace OpenTissue
{
  namespace sph
  {

    template<
      typename real_
      , template<typename> class Vector
      , struct OpenTissue::utility::RuntimeType<real_> * Radius
    >
    class Particle
    {
    public:
      typedef real_  real_type;
      typedef Vector<real_type>  vector;
      typedef vector  point_type;

    public:
      Particle()
        : m_radius(*Radius)
        , m_radiusSqr(*Radius**Radius)
        , m_m(1)
        , m_r(1)
        , m_p(0)
        , m_fixed(false)
      {}

      virtual ~Particle()
      {}

    public:

      point_type min() const
      {
        return point_type(m_x - point_type(m_radius));
        //      return m_x-m_radius;
      }

      point_type max() const
      {
        return point_type(m_x+point_type(m_radius));
        //      return m_x+m_radius;
      }

      bool check(const point_type& candidate) const
      {
        return m_radiusSqr >= sqr_length(point_type(m_x-candidate));
        //      point_type diff(m_x-candidate);
        //      return m_radiusSqr >= diff*diff;
        //      return m_radiusSqr >= (m_x[0]-candidate[0])*(m_x[0]-candidate[0])+(m_x[1]-candidate[1])*(m_x[1]-candidate[1])+(m_x[2]-candidate[2])*(m_x[2]-candidate[2]);
      }

      const point_type& position() const
      {
        return m_x;
      }

      point_type& position()
      {
        return m_x;
      }

      const point_type& position_old() const
      {
        return m_o;
      }

      point_type& position_old()
      {
        return m_o;
      }

      const vector &velocity() const
      {
        return m_v;
      }

      vector &velocity()
      {
        return m_v;
      }

      const vector &acceleration() const
      {
        return m_a;
      }

      vector &acceleration()
      {
        return m_a;
      }

      const vector &force() const
      {
        return m_f;
      }

      vector &force()
      {
        return m_f;
      }

      const real_type &mass() const
      {
        return m_m;
      }

      real_type &mass()
      {
        return m_m;
      }

      const real_type &density() const
      {
        return m_r;
      }

      real_type &density()
      {
        return m_r;
      }

      const real_type &pressure() const
      {
        return m_p;
      }

      real_type &pressure()
      {
        return m_p;
      }

      const vector &normal() const
      {
        return m_n;
      }

      vector &normal()
      {
        return m_n;
      }

      const bool &fixed() const
      {
        return m_fixed;
      }

      bool &fixed()
      {
        return m_fixed;
      }

      const real_type &radius() const
      {
        return m_radius;
      }

    protected:
      //point_type  m_radius;  ///< Radius point
      real_type  m_radius;  
      real_type  m_radiusSqr;  
      point_type  m_x;   
      point_type  m_o;   
      vector  m_v;   
      vector  m_a;   
      vector  m_f;   
      vector  m_n;   
      real_type  m_m;   
      real_type  m_r;   
      real_type  m_p;   
      bool  m_fixed;   

    }; // End class Particle

  } // namespace sph
} // namespace OpenTissue

// OPENTISSUE_DYNAMICS_SPH_SPH_PARTICLE_H
#endif