An Object Finite Element Library

Element.h

Go to the documentation of this file.

/*==============================================================================

                                    O  F  E  L  I

                           Object  Finite  Element  Library

  ==============================================================================

   Copyright (C) 1998 - 2008 Rachid Touzani

   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; Version 2 of the License.

   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, write to the :

   Free Software Foundation
   Inc., 59 Temple Place - Suite 330
   Boston, MA  02111-1307, USA

  ==============================================================================

                           Definition of class 'Element'

  ==============================================================================*/

#ifndef __ELEMENT_H
#define __ELEMENT_H

#include <stdlib.h>
#include <math.h>

#include <valarray>
using std::valarray;

#include <string>
using std::string;

#include "OFELI_Config.h"
#include "Side.h"
#include "Node.h"
#include "Material.h"

namespace OFELI {

//class Side;
//class Node;

#ifndef DOXYGEN_SHOULD_SKIP_THIS
struct ErrorInElement {
   void Message(const char *file, size_t line, int code, int p1=0, const char *p2=" ") const;
};
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

class Element
{

 public:

//----------------------------   BASIC OPERATIONS   ----------------------------

    Element();

    Element(size_t label, const string &shape);

    Element(size_t label, int shape);

    Element(size_t label, const string &shape, int c);

    Element(size_t label, int shape, int c);

    Element(const Element &el);

    ~Element();

//-------------------------------   MODIFIERS  ---------------------------------

    void setLabel(size_t i) { _label = i; }

    void setCode(int c) { _code = c; }

    void setMaterial(Material &m) { _material = &m; }

    void Add(Node *node);

    void Add(Node *node, int n);

    void Replace(size_t label, Node *node);

    void Replace(size_t label, Side *side);

    void Add(Side *sd);

    void Add(Element *el) { _neig_el[_nb_neig_el++] = el; }

    void setDOF(size_t i, size_t dof) { _dof[i-1] = dof; }

    void setCode(size_t dof, int code) { _dof_code[dof-1] = code; }

    void setNode(size_t i, Node *node);

//-----------------------------   INSPECTORS  ----------------------------------

    int getShape() const { return _shape; }

    size_t getLabel() const { return _label; }

    int getCode() const { return _code; }

    size_t getNbNodes() const { return _nb_nodes; }

            size_t getNbVertices() const;

    size_t getNbSides() const;

    size_t getNbEq() const { return _nb_eq; }

    size_t getNbDOF() const { return 1; }

    size_t getDOF() const { return _label; }

    Material *getMaterial() const { return _material; }

    size_t getNodeLabel(size_t n) const { return _node[n-1]->getLabel(); }

    size_t getSideLabel(size_t n) const { return _side[n-1]->getLabel(); }

    Node *getPtrNode(size_t i) const { return _node[i-1]; }

    Side *getPtrSide(size_t i) const { return _side[i-1]; }

    int Contains(const Node *n) const;

    int Contains(const Side *s) const;

    Element *getNeighborElement(size_t i) const { return _neig_el[i-1]; }

    size_t getNbNeigElements() const { return _nb_neig_el; }

    double getMeasure() const;

    Point<double> getUnitNormal(size_t i) const;

    bool isOnBoundary() const
    {
       for (size_t i=0; i<_nb_sides; i++)
          if (_side[i]->isOnBoundary())
             return true;
       return false;
    }

    Node *operator()(size_t i) { return getPtrNode(i); }

    int setSide(size_t n, size_t *nd, int shape);

    friend class Mesh;
    friend void Refine(Mesh &in_mesh, Mesh &out_mesh);
    friend ostream& operator<<(ostream& s, const Mesh &ms);

 private :

   size_t _nb_nodes, _nb_eq, _nb_sides, _label, _nbs, _nb_neig_el;
   int _code, _shape;
   int _dof_code[MAX_NBDOF_SIDE];
   size_t _dof[MAX_NBDOF_SIDE];
   Node* _node[MAX_NB_ELEMENT_NODES];
   Side* _side[MAX_NB_ELEMENT_SIDES];
   Element* _neig_el[MAX_NB_ELEMENT_SIDES];
   Element* _sub_el[4], *_in_el;
   ErrorInElement _e;
   Material *_material;
   bool _alive;

   void calculate_nb_sides();
   void shape_index(const string &shape);
   void InElement(Element *e) { _in_el = e; }
   Element *InElement() const { return _in_el; }
   void SubDivide(size_t i, Element *e) { _sub_el[i-1] = e; }
   Element *SubElement(size_t i) const { return _sub_el[i-1]; }

};

//                             Associated Functions                          //

    ostream& operator<<(ostream& s, const Element & el);

} /* namespace OFELI */

#endif

Copyright © 1998-2007 Rachid Touzani