An Object Finite Element Library

Triang3.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 'Triang3'
                        (Shape functions for 3-node triangle)

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


#ifndef __TRIANG3_H
#define __TRIANG3_H

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

#include "OFELI_Config.h"
#include "FEShape.h"

namespace OFELI {

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

class Triang3 : public FEShape
{

public :

    Triang3();

    Triang3(const Element *element);

    Triang3(const Side *side);

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

    double Sh(size_t i, Point<double> s) const
    {
#ifdef _BOUNDS_DEBUG
       assert(i>0);
       assert(i<=3);
#endif
       switch (i) {
          case 1 : return (1.-s.x-s.y);
          case 2 : return s.x;
          case 3 : return s.y;
       }
       return 0;
    }

    Point<double> DSh(size_t i) const
    {
#ifdef _BOUNDS_DEBUG
       assert(i>0);
       assert(i<=3);
#endif
       return _dsh[i-1];
    }

    double getArea() { return _area=0.5*_det; }

    Point<double> getCenter() const { return _c; }

    Point<double> getCircumcenter() const;

    Point<double> getRefCoord(const Point<double> &x);

    double getMaxEdgeLength() const;

    double getMinEdgeLength() const;

    bool isIn(const Point<double> &x);

    bool isStrictlyIn(const Point<double> &x);

    double getInterpolate(const Point<double> &x, const LocalVect<double,3> &v);

    double check() const;

private :

   double         _area;
   Point<double>  _c;
   const Element  *_el;
   const Side     *_sd;
   ErrorInTriang3 _e;
};


template<class T_> struct Point;
template<class T_,size_t N_> class LocalVect;

template<class T_>
inline Point<T_> gradient(const Triang3 &fe, const class LocalVect<T_,3> &u)
{
   return (u[0]*fe.DSh(1) + u[1]*fe.DSh(2) + u[2]*fe.DSh(3));
}


template<class T_>
inline T_ interpolate(const Triang3 &fe, const LocalVect<T_,3> &u, const T_ &s)
{
   return (u[0]*Sh(1,s) + u[1]*Sh(2,s) + u[2]*fe.Sh(3,s));
}

} /* namespace OFELI */

#endif

Copyright © 1998-2007 Rachid Touzani