ShapeFunction.h

// -*-c++-*-
//----------------------------------------------------------------------------
//  xc utils library; general purpose classes and functions.
//
//  Copyright (C)  Luis C. Pérez Tato
//
//  XC utils 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, either version 3 of the License, or 
//  (at your option) any later version.
//
//  This software 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, see <http://www.gnu.org/licenses/>.
//----------------------------------------------------------------------------
//ShapeFunction.h
// ORIGINAL: shape.h Copyright (c) 1999, A.H. van den Boogaard
//FeaTure is put on the internet as free software. I would very 
//much like to hear your feedback and if possible improvements. See 
//also the 'Future plans' part in the manual.
//Modified by LCPT to integrate it in XC.

#ifndef SHAPEFUNCTION_H
#define SHAPEFUNCTION_H

#include <cstddef>
#include "utility/matrices/m_double.h"



class IntegrationPoints;

class ShapeFunction
  {
  protected:
    ShapeFunction(){}

  public:
    virtual ~ShapeFunction(){}
    virtual m_double get_N_vec(const m_double &natcor) const=0;
    virtual m_double getPartialDerivatives(const m_double &natcor) const=0;
    virtual IntegrationPoints get_integ_points(void) const=0;
    virtual size_t get_nr_integ_points() const=0;

    virtual IntegrationPoints get_face_integ_points(size_t face_nr) const=0;
    virtual m_double dVdA(size_t face_nr) const=0;
  };

class Segmento: public ShapeFunction
  {
  private:
    size_t int_scheme;

  protected:
    Segmento(size_t intscheme)
      :int_scheme(intscheme){}
  public:
    ~Segmento(){}
    IntegrationPoints get_integ_points(void) const;
    size_t get_nr_integ_points(void) const { return int_scheme; }

    m_double dVdA(size_t face_nr) const;
    IntegrationPoints get_face_integ_points(size_t face_nr) const;
  };

class Seg_lin:public Segmento
  {
  public:
    Seg_lin(size_t nxi)
      : Segmento(nxi){}
    ~Seg_lin(){}
    m_double get_N_vec(const m_double &natcor) const;
    m_double getPartialDerivatives(const m_double &natcor) const;
  };

class Triangular: public ShapeFunction
  {
  private:
    size_t int_scheme;

  protected:
    Triangular(size_t intscheme)
      :int_scheme(intscheme){}
  public:
    ~Triangular(){}
    IntegrationPoints get_integ_points(void) const;
    size_t get_nr_integ_points(void) const { return int_scheme; }

    m_double dVdA(size_t face_nr) const;
    IntegrationPoints get_face_integ_points(size_t face_nr) const;
  };

class Tri_lin:public Triangular
  {
  public:
    Tri_lin(size_t intscheme)
      : Triangular(intscheme){}
    ~Tri_lin(){}
    m_double get_N_vec(const m_double &natcor) const;
    m_double getPartialDerivatives(const m_double &natcor) const;
  };

class Tri_quad:public Triangular
  {
  public:
    Tri_quad(size_t intscheme)
      : Triangular(intscheme){}
    ~Tri_quad(){}
    m_double get_N_vec(const m_double &natcor) const;
    m_double getPartialDerivatives(const m_double &natcor) const;
  };

class Tri_quad_alt:public Triangular
  {
  public:
    Tri_quad_alt(size_t intscheme):Triangular(intscheme){}
    ~Tri_quad_alt(){}
    m_double get_N_vec(const m_double &natcor) const;
    m_double getPartialDerivatives(const m_double &natcor) const;
  };

class Quadrilateral:public ShapeFunction
  {
  private:
    size_t int_scheme[2];

  protected:
    Quadrilateral(size_t nxi, size_t neta)
      { int_scheme[0]=nxi; int_scheme[1]=neta; }

  public:
    ~Quadrilateral(){}
    IntegrationPoints get_integ_points() const;
    size_t get_nr_integ_points() const
      { return int_scheme[0]*int_scheme[1]; }

    m_double dVdA(size_t face_nr) const;
    IntegrationPoints get_face_integ_points(size_t face_nr) const;
  };

class Quad_lin:public Quadrilateral
  {
  public:
    Quad_lin(size_t nxi, size_t neta)
      : Quadrilateral(nxi, neta){}
    ~Quad_lin(){}
    m_double get_N_vec(const m_double &natcor) const;
    m_double getPartialDerivatives(const m_double &natcor) const;
  };

class Quad_quad:public Quadrilateral
  {
  public:
    Quad_quad(size_t nxi, size_t neta)
      : Quadrilateral(nxi, neta){}
    ~Quad_quad(){}
    m_double get_N_vec(const m_double &natcor) const;
    m_double getPartialDerivatives(const m_double &natcor) const;
  };

class Quad_quad_alt:public Quadrilateral
  {
  public:
    Quad_quad_alt(size_t nxi, size_t neta)
      : Quadrilateral(nxi, neta){}
    ~Quad_quad_alt(){}
    m_double get_N_vec(const m_double &natcor) const;
    m_double getPartialDerivatives(const m_double &natcor) const;
  };

class Hexaedrico:public ShapeFunction
  {
  private:
    size_t int_scheme[3];

  protected:
    Hexaedrico(size_t nxi, size_t neta, size_t nzeta)
      { int_scheme[0]=nxi; int_scheme[1]=neta; int_scheme[2]=nzeta; }

  public:
    ~Hexaedrico(){}
    IntegrationPoints get_integ_points() const;
    size_t get_nr_integ_points() const
      { return int_scheme[0]*int_scheme[1]*int_scheme[2]; }

    m_double dVdA(size_t face_nr) const;
    IntegrationPoints get_face_integ_points(size_t face_nr) const;
  };

class Hex_lin:public Hexaedrico
  {
  public:
    Hex_lin(size_t nxi, size_t neta, size_t nzeta)
      : Hexaedrico(nxi, neta, nzeta){}
    ~Hex_lin(){}
    m_double get_N_vec(const m_double &natcor) const;
    m_double getPartialDerivatives(const m_double &natcor) const;
  };

#endif // SHAPEFUNCTION_H