An Object Finite Element Library

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

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


#ifndef __EDGE_H
#define __EDGE_H

#include <stdlib.h>
#include <string>

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

using std::string;

namespace OFELI {

class Element;
class Edge;

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

class Edge
{

 public:

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

    Edge();

    Edge(size_t label);

    Edge(const Edge &ed);

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

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

    void Add(size_t n, 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 setDOF(size_t i, size_t dof) { _dof[i-1] = dof; }

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

    void AddNeighbor(Side *sd) { _sd[_neig_sd++] = sd; }

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

    size_t getLabel() const { return _label; }

    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(); }

    Side *getNeighborSide(size_t i) const { if (_sd[i-1]) return _sd[i-1]; else return NULL; }

    int isOnBoundary() const
    {
       _on_boundary = -1;
       if ((_sd[0] && !_sd[1]) || (!_sd[0] && _sd[1]))
          _on_boundary = 1;
       if (_sd[0] && _sd[1])
          _on_boundary = 0;
       return _on_boundary;
    }

    void setOnBoundary();

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

private:

   valarray<int>    _code;
   valarray<size_t> _dof;
   mutable int      _on_boundary;
   size_t           _nb_dof, _label, _nb_eq, _first_dof, _neig_sd;
   Node             *_node[2];
   Side             *_sd[2];
   ErrorInEdge      _e;
};


    ostream& operator<<(ostream& s, const Edge &ed);

} /* namespace OFELI */


#endif

Copyright © 1998-2007 Rachid Touzani