element.h

Go to the documentation of this file.

/*
 *
 *                 #####    #####   ######  ######  ###   ###
 *               ##   ##  ##   ##  ##      ##      ## ### ##
 *              ##   ##  ##   ##  ####    ####    ##  #  ##
 *             ##   ##  ##   ##  ##      ##      ##     ##
 *            ##   ##  ##   ##  ##      ##      ##     ##
 *            #####    #####   ##      ######  ##     ##
 *
 *
 *             OOFEM : Object Oriented Finite Element Code
 *
 *               Copyright (C) 1993 - 2025   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 element_h
#define element_h
 
#include "femcmpnn.h"
#include "error.h"
#include "chartype.h"
#include "domain.h"
#include "dofmanager.h"
#include "floatmatrix.h"
#include "integrationdomain.h"
#include "materialmode.h"
#include "elementgeometrytype.h"
#include "valuemodetype.h"
#include "internalstatemode.h"
#include "internalstatetype.h"
#include "elementextension.h"
#include "entityrenumberingscheme.h"
#include "matresponsemode.h"
#include "unknowntype.h"
#include "integrationrule.h"
#include "dofiditem.h"
#include "floatarray.h"
 
#include <cstdio>
#include <vector>
#include <memory>
 
namespace oofem {
class TimeStep;
class Node;
class Material;
class IntegrationRule;
class GaussPoint;
class IntArray;
class CrossSection;
class ElementSide;
class FEInterpolation;
class Load;
class BoundaryLoad;
class BodyLoad;
class SurfaceLoad;
class EdgeLoad;
class PrimaryField;
class UnknownNumberingScheme;
class ParamKey;

enum elementParallelMode {
    Element_local, 
    Element_remote, 
};
 

class OOFEM_EXPORT Element : public FEMComponent
{
protected:
    int numberOfDofMans; 
    IntArray dofManArray;
    int material;
    int crossSection;
    IntArray bodyLoadArray, boundaryLoadArray;
    std::vector< std :: unique_ptr< IntegrationRule > > integrationRulesArray;

    FloatMatrix elemLocalCS;
  
    int activityTimeFunction;

    int globalNumber;

    int numberOfGaussPoints;

    elementParallelMode parallel_mode;

    IntArray partitions;

    IntArray globalEdgeIDs;
    IntArray globalSurfaceIDs;
 
public:
    static ParamKey IPK_Element_mat;
    static ParamKey IPK_Element_crosssect;
    static ParamKey IPK_Element_nodes;
    static ParamKey IPK_Element_bodyload;
    static ParamKey IPK_Element_boundaryload;
    static ParamKey IPK_Element_lcs;
    static ParamKey IPK_Element_partitions;
    static ParamKey IPK_Element_remote;
    static ParamKey IPK_Element_activityTimeFunction;
    static ParamKey IPK_Element_nip;
 
 
public:
    Element(int n, Domain * aDomain);
    Element(const Element& src) = delete;
    Element &operator = (const Element &src) = delete;
    virtual ~Element();


    void giveLocationArray(IntArray &locationArray, const UnknownNumberingScheme &s, IntArray *dofIds = NULL) const;
    void giveLocationArray(IntArray &locationArray, const IntArray &dofIDMask, const UnknownNumberingScheme &s, IntArray *dofIds = NULL) const;
    virtual void giveBoundaryLocationArray(IntArray &locationArray, const IntArray &bNodes, const UnknownNumberingScheme &s, IntArray *dofIds = NULL);
    virtual void giveBoundaryLocationArray(IntArray &locationArray, const IntArray &bNodes, const IntArray &dofIDMask, const UnknownNumberingScheme &s, IntArray *dofIds = NULL);
    virtual int giveNumberOfDofs() { return 0; }
    virtual int giveNumberOfInternalDofManagers() const { return 0; }
    virtual DofManager *giveInternalDofManager(int i) const {
        OOFEM_ERROR("No such DOF available on Element %d", number);
    }
    virtual void setInternalDofManager(int num, std::unique_ptr<DofManager> dm) {}



    virtual void giveCharacteristicMatrix(FloatMatrix &answer, CharType type, TimeStep *tStep);
    virtual void giveCharacteristicVector(FloatArray &answer, CharType type, ValueModeType mode, TimeStep *tStep);
    virtual double giveCharacteristicValue(CharType type, TimeStep *tStep);


    virtual void computeLoadVector(FloatArray &answer, BodyLoad *load, CharType type, ValueModeType mode, TimeStep *tStep);
    virtual void computeBoundarySurfaceLoadVector(FloatArray &answer, BoundaryLoad *load, int boundary, CharType type, ValueModeType mode, TimeStep *tStep, bool global=true);
    virtual void computeTangentFromSurfaceLoad(FloatMatrix &answer, BoundaryLoad *load, int boundary, MatResponseMode rmode, TimeStep *tStep);
    virtual void computeTangentFromEdgeLoad(FloatMatrix &answer, BoundaryLoad *load, int boundary, MatResponseMode rmode, TimeStep *tStep);
    virtual void computeBoundaryEdgeLoadVector(FloatArray &answer, BoundaryLoad *load, int edge, CharType type, ValueModeType mode, TimeStep *tStep, bool global=true);

    const IntArray& giveBodyLoadList() const {return this->bodyLoadArray;}
    const IntArray& giveBoundaryLoadList() const {return this->boundaryLoadArray;}



    void computeVectorOf(ValueModeType u, TimeStep *tStep, FloatArray &answer);
    void computeVectorOf(const IntArray &dofIDMask, ValueModeType u, TimeStep *tStep, FloatArray &answer, bool padding = false);
    void computeBoundaryVectorOf(const IntArray &bNodes, const IntArray &dofIDMask, ValueModeType u, TimeStep *tStep, FloatArray &answer, bool padding = false);
    void computeVectorOf(PrimaryField &field, const IntArray &dofIDMask, ValueModeType u, TimeStep *tStep, FloatArray &answer, bool padding = false);
    void computeVectorOfPrescribed(ValueModeType u, TimeStep *tStep, FloatArray &answer);    
    void computeVectorOfPrescribed(const IntArray &dofIDMask, ValueModeType type, TimeStep *tStep, FloatArray &answer);

    virtual int computeNumberOfDofs() { return 0; }
    virtual int computeNumberOfGlobalDofs();
    int computeNumberOfPrimaryMasterDofs();
    virtual bool computeGtoLRotationMatrix(FloatMatrix &answer);
    virtual bool giveRotationMatrix(FloatMatrix &answer);
    virtual bool computeDofTransformationMatrix(FloatMatrix &answer, const IntArray &nodes, bool includeInternal);
    virtual void giveDofManDofIDMask(int inode, IntArray &answer) const { answer.clear(); }
    virtual void giveInternalDofManDofIDMask(int inode, IntArray &answer) const
    { answer.clear(); }

    virtual void giveElementDofIDMask(IntArray &answer) const { this->giveDofManDofIDMask(1, answer); }
    virtual void computeField(ValueModeType mode, TimeStep *tStep, const FloatArray &lcoords, FloatArray &answer)
    { OOFEM_ERROR("Missing support for computing unknown vector at local element coordinates\n"); }

    virtual double computeVolumeAround(GaussPoint *gp) { return 0.; }
    virtual double computeVolumeAreaOrLength();
    double computeMeanSize();
    virtual double computeVolume();
    virtual double computeArea();
    virtual double computeLength();
    // If the need arises;
    /*
     * Computes the length of an edge.
     * @param iedge Edge number.
     * @return Edge length.
     */
    //virtual double computeEdgeLength(int iedge) { return 0.0; }
    /*
     * Computes the area of a surface.
     * @param isurf Surface number.
     * @param Surface area.
     */
    //virtual double computeSurfaceArea(int isurf) { return 0.0; }
    virtual IntArray giveBoundaryEdgeNodes(int boundary, bool includeHierarchical=false) const;
    virtual IntArray giveBoundarySurfaceNodes(int boundary, bool includeHierarchical=false) const;
    virtual IntArray giveBoundaryNodes(int boundary) const;
    virtual std::unique_ptr<IntegrationRule> giveBoundaryEdgeIntegrationRule(int order, int boundary);
    virtual std::unique_ptr<IntegrationRule> giveBoundarySurfaceIntegrationRule(int order, int boundary);
 
 
    // data management
    int giveDofManagerNumber(int i) const { return dofManArray.at(i); }
    const IntArray &giveDofManArray() const { return dofManArray; }
    void addDofManager(DofManager *dMan);
    DofManager *giveDofManager(int i) const;
    inline Node *giveNode(int i) const
    {
#ifdef DEBUG
        if ( ( i <= 0 ) || ( i > dofManArray.giveSize() ) ) {
            OOFEM_ERROR("Node is not defined");
        }
#endif
        return domain->giveNode( dofManArray.at(i) );
    }

    virtual ElementSide *giveSide(int i) const;
    virtual FEInterpolation *giveInterpolation() const { return NULL; }
    virtual FEInterpolation *giveInterpolation(DofIDItem id) const { return giveInterpolation(); }
    virtual const FEInterpolation *getGeometryInterpolation() const { return giveInterpolation(); }

    virtual Material *giveMaterial();
    int giveMaterialNumber() const {return material;}
    CrossSection *giveCrossSection();
 

    int getActivityTimeFunctionNumber(){ return this->activityTimeFunction; }
 

    void setActivityTimeFunctionNumber(int funcIndx){ this->activityTimeFunction = funcIndx; }

    void setMaterial(int matIndx) { this->material = matIndx; }
        
    virtual void setCrossSection(int csIndx) { this->crossSection = csIndx; }

    virtual int giveNumberOfDofManagers() const { return numberOfDofMans; }
    void setNumberOfDofManagers(int i) {this->numberOfDofMans = i;}
    virtual int giveNumberOfNodes() const { return numberOfDofMans; }
    void setDofManagers(const IntArray &dmans);
    void setDofManager(int id, int dm);

    void setBodyLoads(const IntArray &bodyLoads);

    void setIntegrationRules(std :: vector< std :: unique_ptr< IntegrationRule > > irlist);
    virtual integrationDomain giveIntegrationDomain() const;
    virtual MaterialMode giveMaterialMode() { return _Unknown; }
    virtual int giveIntegrationRuleLocalCodeNumbers(IntArray &answer, IntegrationRule &ie)
    { return 0; }
 
    // Returns number of sides (which have unknown dofs) of receiver
    //int giveNumberOfSides () {return numberOfSides;}

    int giveRegionNumber();

    virtual void updateInternalState(TimeStep *tStep) { }
    virtual void updateYourself(TimeStep *tStep);
    // initialization to state given by initial conditions
    virtual void initializeYourself(TimeStep *timeStepWhenICApply) { }

    int checkConsistency() override { return 1; }

    virtual bool isActivated(TimeStep *tStep);

    virtual bool isCast(TimeStep *tStep);
 
    // time step initialization (required for some non-linear solvers)
    virtual void initForNewStep();
    virtual Element_Geometry_Type giveGeometryType() const = 0;
    virtual Element_Geometry_Type giveEdgeGeometryType(int id) const;
    virtual Element_Geometry_Type giveSurfaceGeometryType(int id) const;
    virtual int giveSpatialDimension();
    virtual int giveNumberOfBoundarySides();
    virtual int giveNumberOfEdges() const;
    virtual int giveNumberOfSurfaces() const;

    virtual int giveDefaultIntegrationRule() const { return 0; }
    virtual IntegrationRule *giveDefaultIntegrationRulePtr() {
        if ( this->giveNumberOfIntegrationRules() == 0 ) {
            return NULL;
        } else {
            return this->integrationRulesArray [ giveDefaultIntegrationRule() ].get();
        }
    }

    int giveNumberOfIntegrationRules() { return (int)this->integrationRulesArray.size(); }
    virtual IntegrationRule *giveIntegrationRule(int i) { return integrationRulesArray [ i ].get(); }
 
    std::vector< std :: unique_ptr< IntegrationRule > > &giveIntegrationRulesArray() {return integrationRulesArray;}

    virtual int testElementExtension(ElementExtension ext) { return 0; }


    virtual int giveIPValue(FloatArray &answer, GaussPoint *gp, InternalStateType type, TimeStep *tStep);
    int giveGlobalIPValue(FloatArray &answer, GaussPoint *gp, InternalStateType type, TimeStep *tStep);
 
    // characteristic length in gp (for some material models)
    virtual double giveLengthInDir(const FloatArray &normalToCrackPlane) ;
    virtual double giveCharacteristicLength(const FloatArray &normalToCrackPlane) { OOFEM_ERROR("Function not overloaded, which probably means that the crack band approach should not be used for this element"); }
    double giveCharacteristicLengthForPlaneElements(const FloatArray &normalToCrackPlane) ;
    double giveCharacteristicLengthForAxisymmElements(const FloatArray &normalToCrackPlane) ;
    virtual double giveCharacteristicSize(GaussPoint *gp, FloatArray &normalToCrackPlane, ElementCharSizeMethod method) { return giveCharacteristicLength(normalToCrackPlane); }
    virtual double giveParentElSize() const { return 0.0; }
    virtual void updateBeforeNonlocalAverage(TimeStep *tStep) { }
    virtual int computeGlobalCoordinates(FloatArray &answer, const FloatArray &lcoords);
    virtual bool computeLocalCoordinates(FloatArray &answer, const FloatArray &gcoords);
    virtual int giveLocalCoordinateSystem(FloatMatrix &answer);

    virtual void giveLocalCoordinateSystemVector(InternalStateType isttype, FloatArray &answer);
    
    virtual void computeMidPlaneNormal(FloatArray &answer, const GaussPoint *gp);
    virtual int adaptiveMap(Domain *oldd, TimeStep *tStep);
    virtual int mapStateVariables(Domain &iOldDom, const TimeStep &iTStep);
    virtual int adaptiveUpdate(TimeStep *tStep) { return 1; }
    virtual int adaptiveFinish(TimeStep *tStep);

    void updateLocalNumbering(EntityRenumberingFunctor &f) override;

    template< class T > void ipEvaluator( T *src, void ( T :: *f )( GaussPoint *gp ) );
    template< class T, class S > void ipEvaluator(T *src, void ( T :: *f )( GaussPoint *, S & ), S &_val);

 
 
#ifdef __OOFEG
    //
    // Graphics output
    //
    virtual void drawYourself(oofegGraphicContext &gc, TimeStep *tStep);
    virtual void drawAnnotation(oofegGraphicContext &gc, TimeStep *tStep);
    virtual void drawRawGeometry(oofegGraphicContext &gc, TimeStep *tStep) { }
    virtual void drawDeformedGeometry(oofegGraphicContext &gc, TimeStep *tStep, UnknownType) { }
    virtual void drawScalar(oofegGraphicContext &gc, TimeStep *tStep) { }
    virtual void drawSpecial(oofegGraphicContext &gc, TimeStep *tStep) { }
    // added in order to hide IP element details from oofeg
    // to determine the max and min local values, when recovery does not takes place
    virtual void giveLocalIntVarMaxMin(oofegGraphicContext &gc, TimeStep *tStep, double &emin, double &emax) { emin = emax = 0.0; }

    virtual int giveInternalStateAtNode(FloatArray &answer, InternalStateType type, InternalStateMode mode,
                                        int node, TimeStep *tStep);
    virtual int giveInternalStateAtSide(FloatArray &answer, InternalStateType type, InternalStateMode mode,
                                        int side, TimeStep *tStep)
    {
        answer.clear();
        return 0;
    }

    virtual void showSparseMtrxStructure(CharType mtrx, oofegGraphicContext &gc, TimeStep *tStep) { }
    virtual void showExtendedSparseMtrxStructure(CharType mtrx, oofegGraphicContext &gc, TimeStep *tStep) { }
 
#endif

    int giveLabel() const { return globalNumber; }
    int giveGlobalNumber() const { return globalNumber; }
    void setGlobalNumber(int num) { globalNumber = num; }

    elementParallelMode giveParallelMode() const { return parallel_mode; }
    void setParallelMode(elementParallelMode _mode) { parallel_mode = _mode; }
    virtual elementParallelMode giveKnotSpanParallelMode(int) const { return parallel_mode; }
    int packUnknowns(DataStream &buff, TimeStep *tStep);
    int unpackAndUpdateUnknowns(DataStream &buff, TimeStep *tStep);
    int estimatePackSize(DataStream &buff);
    const IntArray *givePartitionList() const { return & partitions; }
    void setPartitionList(IntArray &pl) { partitions = pl; }
    virtual double predictRelativeComputationalCost();
    virtual double giveRelativeSelfComputationalCost() { return 1.0; }
    virtual double predictRelativeRedistributionCost() { return 1.0; }
 
public:
    IntArray *giveBodyLoadArray();
    IntArray *giveBoundaryLoadArray();
 
    // Overloaded methods:
    void initializeFrom(InputRecord &ir, int priority) override;
    void initializeFinish() override;
    void postInitialize() override;
    void giveInputRecord(DynamicInputRecord &input) override;
    void saveContext(DataStream &stream, ContextMode mode) override;
    void restoreContext(DataStream &stream, ContextMode mode) override;
    const char *giveClassName() const override { return "Element"; }
 
    void printOutputAt(FILE *file, TimeStep *tStep) override;
 
    virtual const IntArray giveLocation() {IntArray answer(0); return answer;}
    virtual void recalculateCoordinates(int nodeNumber, FloatArray &coords){;}
 
 
    // global edge/surface management
    void setSharedEdgeID(int iedge, int globalID) {
        if (this->globalEdgeIDs.isEmpty()) {
            this->globalEdgeIDs.resize(this->giveNumberOfEdges());
        }
        this->globalEdgeIDs.at(iedge)=globalID;
    }
    void setSharedSurfaceID(int isurf, int globalID) {
        if (this->globalSurfaceIDs.isEmpty()) {
            this->globalSurfaceIDs.resize(this->giveNumberOfSurfaces());
        }
        this->globalSurfaceIDs.at(isurf)=globalID;
    }
    const IntArray* giveSharedEdgeIDs() const {return &(this->globalEdgeIDs);} 
    const IntArray* giveSharedSurfaceIDs() const {return &(this->globalSurfaceIDs);} 
 
 protected:
    virtual void computeGaussPoints() { }
};
 
template< class T > void
Element :: ipEvaluator( T *src, void ( T :: *f )( GaussPoint *gp ) )
{
    for ( auto &ir: integrationRulesArray ) {
        for ( GaussPoint *gp: *ir ) {
            ( src->*f )(gp);
        }
    }
}
 
template< class T, class S > void
Element :: ipEvaluator(T *src, void ( T :: *f )( GaussPoint *, S & ), S &_val)
{
    for ( auto &ir: integrationRulesArray ) {
        for ( GaussPoint *gp: *ir ) {
            ( src->*f )(gp, _val);
        }
    }
}
 
} // end namespace oofem
#endif //element_h