node/Vertex3d.hpp

#ifndef __VERTEX3D_HPP__
#define __VERTEX3D_HPP__

#include <algorithm>
#include <functional>

#include <boost/array.hpp>

namespace DAPTA { // Define namespace DAPTA


class Vertex3d {
   public:
      typedef double                    CoordType;      
      typedef boost::array<CoordType,3> CoordArrayType; 
      
      static const int dimension = 3;
      
      Vertex3d(Vertex3d *copy) {
         coords.at(0) = copy->coords.at(0);
         coords.at(1) = copy->coords.at(1);
         coords.at(2) = copy->coords.at(2);
         globalID     = 0;
         
         for(int i=0; i<3; i++) {
            u0[i] = copy->u0[i];
            u1[i] = copy->u1[i];
            f[i] = copy->f[i];
            cons[i] = copy->cons[i];
            f_add[i] = copy->f_add[i];
            u1_add[i] = copy->u1_add[i];
            m = copy->m;
         }
      }
      Vertex3d(boost::array<CoordType,3> new_coords, int i=0) {
         coords.at(0) = new_coords.at(0);
         coords.at(1) = new_coords.at(1);
         coords.at(2) = new_coords.at(2);
         globalID     = i;
         
         for(int i=0; i<3; i++) {
            u0[i] = 0.0;
            u1[i] = 0.0;
            f[i] = 0.0;
            cons[i] = false;
            f_add[i] = 0.0;
            u1_add[i] = 0.0;
            m = 0.0;
         }
      }
      Vertex3d(double x, double y, double z, int i=0) {
         coords.at(0) = x;
         coords.at(1) = y;
         coords.at(2) = z;
         globalID     = i;
         
         for(int i=0; i<3; i++) {
            u0[i] = 0.0;
            u1[i] = 0.0;
            f[i] = 0.0;
            cons[i] = false;
            f_add[i] = 0.0;
            u1_add[i] = 0.0;
            m = 0.0;
         }
      }
      Vertex3d() {
         coords.at(0) = 0.0;
         coords.at(1) = 0.0;
         coords.at(2) = 0.0;
         globalID     = 0;
         
         for(int i=0; i<3; i++) {
            u0[i] = 0.0;
            u1[i] = 0.0;
            f[i] = 0.0;
            cons[i] = false;
            f_add[i] = 0.0;
            u1_add[i] = 0.0;
            m = 0.0;
         }
      }
      ~Vertex3d() {;}
      
      static const std::string deck_keyword; 
      
      boost::array<CoordType,3> coords;
      
      int globalID;
      
      void resetForces() {
         for(int i=0; i<3; i++)
            f[i] = f_add[i];
      }
      void resetDisplacements() {
         for(int i=0; i<3; i++) {
            u0[i] = 0.0;
            u1[i] = 0.0;
         }
      }
      double u0[3];
      double u1[3];
      double f[3];
      double m;
      
      bool cons[3];
      double f_add[3];
      double u1_add[3];
   private:
};
const std::string Vertex3d::deck_keyword = "NODE";

} // namespace DAPTA

#include "Vertex3d.cpp"

#endif

---