An Object Finite Element Library

Side.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 'Side'

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


#ifndef __SIDE_H
#define __SIDE_H

#include <stdlib.h>

#include <valarray>
using std::valarray;

#include <string>
using std::string;

#include "OFELI_Config.h"
#include "Node.h"
#include "output.h"

namespace OFELI {

enum BCType {
  PERIODIC_A     =  9999,     
  PERIODIC_B     = -9999,     
  CONTACT        =  9998,     
  CONTACT_M      =  9997,
  CONTACT_S      = -9997,
  SLIP           =  9996      
};

class Element;

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


class Side
{

 public:

enum SideType {
  INTERNAL_SIDE     =  0,  
  EXTERNAL_BOUNDARY =  1,  
  INTERNAL_BOUNDARY =  2   
};

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

    Side();

    Side(size_t label, const string &shape);

    Side(size_t label, int shape);

    Side(const Side &sd);

    ~Side() {
#ifdef _OFELI_DEBUG
       std::clog << "An instance of class Side is destructed.\n";
       std::clog << "File : " << __FILE__ << ", Line : " << __LINE__ << endl;
#endif
    }

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

    void Add(Node *node);

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

    void setFirstDOF(size_t n) { _first_dof = n; }

    void setNbDOF(size_t nb_dof) { _nb_dof = nb_dof; }

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

    void setDOF(size_t &first_dof, size_t nb_dof);

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

    void Replace(size_t label, Node *node);

    void AddNeighbor(Element *el) { if (el) _el[_neig_el++] = el; }

    void setNode(size_t i, Node *node);

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

    int getShape() const { return _shape; }

    size_t getLabel() const { return _label; }

    size_t getNbNodes() const { return _nb_nodes; }

            size_t getNbVertices() const;

    size_t getNbEq() const { return _nb_eq; }

    size_t getNbDOF() const { return _nb_dof; }

    int getCode(size_t dof) const { return _code[dof-1]; }

    size_t getDOF(size_t i) const { return _dof[i-1]; }

    size_t getFirstDOF() const { return _first_dof; }

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

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

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

    int isOnBoundary() const;

    void setOnBoundary();

    double getMeasure() const;

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

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

private:

    valarray<int>    _code;
    valarray<size_t> _dof;
    mutable int      _on_boundary;
    size_t           _nb_dof, _label, _nb_nodes, _nb_eq, _first_dof, _neig_el;
    int              _shape;
    Node             *_node[MAX_NB_SIDE_NODES];
    Element          *_el[2];
    bool             _alive;
    ErrorInSide      _e;
    void shape_index(const string &shape);
};


//-----------------------------------------------------------------------------
// Associated functions
//-----------------------------------------------------------------------------

    ostream& operator<<(ostream& s, const Side &sd);

} /* namespace OFELI */

#endif

Copyright © 1998-2007 Rachid Touzani