feinterpol.h

Go to the documentation of this file.

/*
 *
 *                 #####    #####   ######  ######  ###   ###
 *               ##   ##  ##   ##  ##      ##      ## ### ##
 *              ##   ##  ##   ##  ####    ####    ##  #  ##
 *             ##   ##  ##   ##  ##      ##      ##     ##
 *            ##   ##  ##   ##  ##      ##      ##     ##
 *            #####    #####   ##      ######  ##     ##
 *
 *
 *             OOFEM : Object Oriented Finite Element Code
 *
 *               Copyright (C) 1993 - 2013   Borek Patzak
 *
 *
 *
 *       Czech Technical University, Faculty of Civil Engineering,
 *   Department of Structural Mechanics, 166 29 Prague, Czech Republic
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  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
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef feinterpol_h
#define feinterpol_h

#include "oofemcfg.h"
#include "error.h"
#include "inputrecord.h"
#include "intarray.h"
#include "integrationdomain.h"
#include "elementgeometrytype.h"
#include "materialmode.h"
#include "node.h"
#include "element.h"

namespace oofem {
class Element;
class FloatArray;
class FloatMatrix;
class IntArray;
class IntegrationRule;

class OOFEM_EXPORT FEICellGeometry
{
public:
    FEICellGeometry() { }
    virtual ~FEICellGeometry() { }
    virtual int giveNumberOfVertices() const = 0;
    virtual const FloatArray *giveVertexCoordinates(int i) const = 0;
};


class OOFEM_EXPORT FEIVoidCellGeometry : public FEICellGeometry
{
public:
    FEIVoidCellGeometry() : FEICellGeometry() { }
    virtual ~FEIVoidCellGeometry() { }
    int giveNumberOfVertices() const {
        OOFEM_ERROR("no reference geometry");
        return 0;
    }
    const FloatArray *giveVertexCoordinates(int i) const {
        OOFEM_ERROR("no reference geometry");
        return NULL;
    }
    std :: string errorInfo(const char *func) const { return func; } 
};

class OOFEM_EXPORT FEIElementGeometryWrapper : public FEICellGeometry
{
protected:
    const Element *elem;
public:
    FEIElementGeometryWrapper(const Element * elem) : FEICellGeometry() {
        this->elem = elem;
    }
    virtual ~FEIElementGeometryWrapper() { }
    int giveNumberOfVertices() const;
    inline const FloatArray *giveVertexCoordinates(int i) const
    {
        return &(elem->giveNode(i)->giveNodeCoordinates());
    }
};


class OOFEM_EXPORT FEIVertexListGeometryWrapper : public FEICellGeometry
{
protected:
    const std::vector< FloatArray > &coords;

public:
    FEIVertexListGeometryWrapper(const std::vector< FloatArray > &coords) : 
        FEICellGeometry(), coords(coords) { }
    virtual ~FEIVertexListGeometryWrapper() { }
    int giveNumberOfVertices() const { return (int)this->coords.size(); }
    const FloatArray *giveVertexCoordinates(int i) const { return &this->coords [ i - 1 ]; }
};

class OOFEM_EXPORT FEInterpolation
{
protected:
    int order;

public:
    FEInterpolation(int o) {
        order = o;
    }
    virtual ~FEInterpolation() { }
    virtual IRResultType initializeFrom(InputRecord *ir) { return IRRT_OK; }


    /* @name basic interpolation services */

    virtual integrationDomain giveIntegrationDomain() const = 0;
    virtual Element_Geometry_Type giveGeometryType() const = 0;
    int giveInterpolationOrder() { return order; }
    virtual void evalN(FloatArray &answer, const FloatArray &lcoords, const FEICellGeometry &cellgeo) = 0;
    virtual double evaldNdx(FloatMatrix &answer, const FloatArray &lcoords, const FEICellGeometry &cellgeo) = 0;
    virtual void evald2Ndx2(FloatMatrix &answer, const FloatArray &lcoords, const FEICellGeometry &cellgeo) {
        OOFEM_ERROR("not implemented");
    }
    virtual void evaldNdxi(FloatMatrix &answer, const FloatArray &lcoords, const FEICellGeometry &cellgeo) {
        OOFEM_ERROR("not implemented");
    }
    virtual void giveLocalNodeCoords(FloatMatrix &answer) {
        OOFEM_ERROR("FEInterpolation::giveLocalNodeCoords: not implemented");
    }
    virtual void local2global(FloatArray &answer, const FloatArray &lcoords, const FEICellGeometry &cellgeo) = 0;
    virtual int global2local(FloatArray &answer, const FloatArray &gcoords, const FEICellGeometry &cellgeo) = 0;
    virtual double giveTransformationJacobian(const FloatArray &lcoords, const FEICellGeometry &cellgeo);
    virtual void giveJacobianMatrixAt(FloatMatrix &jacobianMatrix, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
    { OOFEM_ERROR("Not overloaded."); }

    virtual IntegrationRule *giveIntegrationRule(int order);

    
    virtual void boundaryEdgeEvalN(FloatArray &answer, int boundary, const FloatArray &lcoords, const FEICellGeometry &cellgeo)=0;
    virtual double boundaryEdgeGiveTransformationJacobian(int boundary, const FloatArray &lcoords, const FEICellGeometry &cellgeo)=0;
    virtual void boundaryEdgeLocal2Global(FloatArray &answer, int boundary, const FloatArray &lcoords, const FEICellGeometry &cellgeo)=0;
    virtual integrationDomain giveBoundaryEdgeIntegrationDomain(int boundary) const = 0;
    virtual IntegrationRule *giveBoundaryEdgeIntegrationRule(int order, int boundary);
    virtual void boundaryEdgeGiveNodes(IntArray &answer, int boundary)=0;

    virtual void boundarySurfaceEvalN(FloatArray &answer, int isurf, const FloatArray &lcoords, const FEICellGeometry &cellgeo) = 0;
    virtual void boundarySurfaceEvaldNdx(FloatMatrix &answer, int isurf,
           const FloatArray &lcoords, const FEICellGeometry &cellgeo)=0;
    virtual double boundarySurfaceEvalNormal(FloatArray &answer, int isurf, const FloatArray &lcoords,
               const FEICellGeometry &cellgeo)=0;

    virtual void boundarySurfaceLocal2global(FloatArray &answer, int isurf,
               const FloatArray &lcoords, const FEICellGeometry &cellgeo)=0;
    virtual double boundarySurfaceGiveTransformationJacobian(int isurf, const FloatArray &lcoords,
                   const FEICellGeometry &cellgeo)=0;
    virtual integrationDomain giveBoundarySurfaceIntegrationDomain(int boundary) const = 0;
    virtual IntegrationRule *giveBoundarySurfaceIntegrationRule(int order, int boundary);
    virtual void boundarySurfaceGiveNodes(IntArray &answer, int boundary)=0;


    virtual void boundaryGiveNodes(IntArray &answer, int boundary) = 0;
    virtual void boundaryEvalN(FloatArray &answer, int boundary, const FloatArray &lcoords, const FEICellGeometry &cellgeo) = 0;
    virtual double boundaryEvalNormal(FloatArray &answer, int boundary, const FloatArray &lcoords, const FEICellGeometry &cellgeo) = 0;
    virtual double boundaryGiveTransformationJacobian(int boundary, const FloatArray &lcoords, const FEICellGeometry &cellgeo) = 0;
    virtual void boundaryLocal2Global(FloatArray &answer, int boundary, const FloatArray &lcoords, const FEICellGeometry &cellgeo) = 0;
    virtual double evalNXIntegral(int boundary, const FEICellGeometry &cellgeo) {
        OOFEM_ERROR("Not implemented");
        return 0.;
    }
    virtual integrationDomain giveBoundaryIntegrationDomain(int boundary) const = 0;
    virtual IntegrationRule *giveBoundaryIntegrationRule(int order, int boundary) ;


    virtual int giveKnotSpanBasisFuncMask(const IntArray &knotSpan, IntArray &mask) { return 0; }
    virtual int giveNumberOfKnotSpanBasisFunctions(const IntArray &knotSpan) { return 0; }
    virtual bool hasSubPatchFormulation() { return false; }
    virtual const double *const *giveKnotVector() {
        return NULL;
    }
    virtual int giveNumberOfKnotSpans(int dim) { return 0; }
    virtual const FloatArray *giveKnotValues(int dim) { return NULL; }
    virtual const IntArray *giveKnotMultiplicity(int dim) { return NULL; }
    virtual int giveNsd() = 0;
    virtual int giveNumberOfEdges() const 
    { OOFEM_ERROR("FEInterpolation :: giveNumberOfEdges : Not overloaded."); return -1;}

    virtual int giveNumberOfNodes() const
    { OOFEM_ERROR("giveNumberOfNodes: Not overloaded."); return -1;}
    
    std :: string errorInfo(const char *func) const { return func; } 
};
} // end namespace oofem
#endif // feinterpol_h