Dof.hpp

Go to the documentation of this file.

// This file is part of GranOO, a workbench for DEM simulation.
//
// Author(s)    : - Damien Andre       IRCER/UNILIM, Limoges France
//                  <damien.andre@unilim.fr>
//                - Jean-luc Charles   Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <jean-luc.charles@ensam.eu>
//                - Jeremie Girardot   Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <jeremie.girardot@ensam.eu>
//                - Cedric Hubert      LAMIH/UPHF, Valenciennes France
//                  <cedric.hubert@uphf.fr>
//                - Ivan Iordanoff     Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <ivan.iordanoff@ensam.eu>
//
// Copyright (C) 2008-2019 D. Andre, JL. Charles, J. Girardot, C. Hubert, I. Iordanoff
//
// 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 3 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
#ifndef _LibPhysic_Dof_H
#define _LibPhysic_Dof_H
 
#include <map>
#include <string>
 
#include "GranOO3/Core/Macro.hpp"
#include "GranOO3/3rdParty/Eigen/Dense"
 
namespace GranOO3
{
 
  namespace DOF
  {
    enum State{FREE=0, FIXED=1, PRESCRIBED=2};
    enum Mecha{X=0, Y=1, Z=2, RX=3, RY=4, RZ=5};
  }
 
  
  namespace Physic
  {
 
    template <int NUM>
    class Dof
    {
    public:
      static const int N = NUM;  
 
    public:
      Dof(const double*&);
 
      typedef std::array<int       , NUM> DofArrayT;
      typedef std::array<DOF::State, NUM> DofStateArrayT;
 
      GRANOO_ACCESS    (global_index    , int           , _global_index         ); // get, set for _global_index
      GRANOO_ACCESS_GET(global_index_dof, DofArrayT     , _global_index_for_dof ); // -> global_dof_id()
      GRANOO_ACCESS_GET(bc_state        , DofStateArrayT, _bc_state             ); // -> bc()
 
      Eigen::Map<Eigen::Matrix<double, NUM, 1>> array() const;
 
      int get_global_index_for_dof(unsigned int) const;                // -> global_dof_id(unsigned int dof)
      void set_global_index_for_dof(unsigned int, unsigned int index); // -> set_global_dof_id(dof,value)
 
      unsigned int get_bc_state(unsigned int) const; // -> bc(unsigned int dof)
      void set_bc_state(unsigned int, DOF::State);   // -> set_bc(unsigned int dof, unsigned int value)
      void set_bc_state(DOF::State);                 // -> set_bc(unsigned int value)
      void clear_bc();                               // -> reset_bc() (in granoo we use clear instead of reset)
      
    private:
      const double*&                _ptr;                  // to point to data
      int                           _global_index;         // -> _global_id
      std::array<int, NUM>          _global_index_for_dof; // -> _global_dofs_id
      std::array<DOF::State   ,NUM> _bc_state;             // -> _bc
 
    };
 
    template <int NUM>
    Dof<NUM>::Dof(const double*& p) :
      _ptr(p),
      _global_index(-1),
      _global_index_for_dof(),
      _bc_state() {
      std::fill(_global_index_for_dof.begin(), _global_index_for_dof.end(), -1        );
      std::fill(_bc_state.begin()            , _bc_state.end()            , DOF::FREE );
    }
 
    template <int NUM> Eigen::Map<Eigen::Matrix<double, NUM, 1>>
    Dof<NUM>::array() const {
      return Eigen::Map<Eigen::Matrix<double, NUM, 1>>(_ptr, NUM);
    }
 
    template <int NUM> int
    Dof<NUM>::get_global_index_for_dof(unsigned int d) const {
      return _global_index_for_dof[d];
    }
 
    template <int NUM> void
    Dof<NUM>::set_global_index_for_dof(unsigned int d, unsigned int index) {
      _global_index_for_dof[d] = index;
    }
 
    template <int NUM> unsigned int
    Dof<NUM>::get_bc_state(unsigned int d) const {
      return _bc_state[d];
    }
 
    template <int NUM> void
    Dof<NUM>::set_bc_state(unsigned int d, DOF::State s) {
      _bc_state[d] = s;
    }
 
    template <int NUM> void
    Dof<NUM>::set_bc_state(DOF::State s) {
      std::fill(_bc_state.begin(), _bc_state.end(), s);
    }
 
    template <int NUM> void
    Dof<NUM>::clear_bc() {
      std::fill(_bc_state.begin(), _bc_state.end(), DOF::FREE);
    }
    
  }
}
 
 
#endif