nonlocalmaterialext.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 nonlocalmaterialext_h
#define nonlocalmaterialext_h
 
#include "matstatus.h"
#include "interface.h"
#include "intarray.h"
#include "grid.h"
#include "mathfem.h"
#include "dynamicinputrecord.h"
 
#include <list>
#include <memory>
#ifdef _OPENMP
#include <omp.h>
#endif

#define _IFT_NonlocalMaterialExtensionInterface_regionmap "regionmap"
#define _IFT_NonlocalMaterialExtensionInterface_permanentNonlocTableFlag "permanentnonloctableflag"
#define _IFT_NonlocalMaterialExtensionInterface_r "r"
#define _IFT_NonlocalMaterialExtensionInterface_wft "wft"
#define _IFT_NonlocalMaterialExtensionInterface_averagingtype "averagingtype"
#define _IFT_NonlocalMaterialExtensionInterface_m "m"
#define _IFT_NonlocalMaterialExtensionInterface_scalingtype "scaling"
#define _IFT_NonlocalMaterialExtensionInterface_averagedquantity "averagedvar"
#define _IFT_NonlocalMaterialExtensionInterface_nonlocalvariation "nlvariation"
#define _IFT_NonlocalMaterialExtensionInterface_beta "beta"
#define _IFT_NonlocalMaterialExtensionInterface_zeta "zeta"
#define _IFT_NonlocalMaterialExtensionInterface_px "px"
#define _IFT_NonlocalMaterialExtensionInterface_averagingtype "averagingtype"
#define _IFT_NonlocalMaterialExtensionInterface_exp "exp"
#define _IFT_NonlocalMaterialExtensionInterface_rf "rf"
#define _IFT_NonlocalMaterialExtensionInterface_gridsize "gridsize"
#define _IFT_NonlocalMaterialExtensionInterface_initdiag "initdiag"
#define _IFT_NonlocalMaterialExtensionInterface_order "order"
#define _IFT_NonlocalMaterialExtensionInterface_centdiff "centdiff"
 
namespace oofem {
struct localIntegrationRecord {
    GaussPoint *nearGp;
    double weight;
};
 
  enum WeightFunctionType {
                           WFT_Unknown,
                           WFT_Bell,
                           WFT_Gauss,
                           WFT_Green,
                           WFT_Uniform,
                           WFT_UniformOverElement,
                           WFT_Green_21 }; 

class OOFEM_EXPORT NonlocalMaterialStatusExtensionInterface : public Interface
{
protected:
    std :: vector< localIntegrationRecord >integrationDomainList;
    double integrationScale;
    double volumeAround;
 
public:
    NonlocalMaterialStatusExtensionInterface();

    virtual ~NonlocalMaterialStatusExtensionInterface();

    std :: vector< localIntegrationRecord > *giveIntegrationDomainList() { return & integrationDomainList; }
    double giveIntegrationScale() { return integrationScale; }
    void setIntegrationScale(double val) { integrationScale = val; }
    double giveVolumeAround() { return volumeAround; }
    void setVolumeAround(double val) { volumeAround = val; }
    void clear() { integrationDomainList.clear(); }
};
 

class OOFEM_EXPORT NonlocalMaterialExtensionInterface : public Interface
{
protected:
    /*
     * It is necessary, mainly due to resulting efficiency, to compute variable(s)
     * which are nonlocally averaged in advance, before average process begins.
     * The loop over all  integration points is typically made to compute these variables.
     * To prevent doing this multiple times at the same solution state,
     * the modification time mark is kept.
     * In the present implementation, there is one common stateCounter for the whole domain.
     * This implies, that all variables (which undergo averaging) for all material models of the domain
     * should be prepared at the same time in updateDomainBeforeNonlocAverage method.
     * It is believed that this is general enough and can somehow handle even the case of multiple models
     * with different parameters being averaged (but is this realistic?).
     * If this scheme will not be enough general, then the state counter
     * can be kept as attribute of NonlocalMaterialExtensionInterface, so independently for
     * each material model. Each model will be then updated in separate call. But in the case of
     * several material models of the same type (with different parameters) this will lead to
     * multiple update, which can not be avoided, although it is redundant.
     *
     * StateCounterType lastUpdatedStateCounter;
     */
    Domain *domain = nullptr;
    IntArray regionMap;
    bool permanentNonlocTableFlag = false;
    WeightFunctionType weightFun;
    int gridSize = 0;
    double initDiag = 0.;
    int order = 0;
    int centDiff = 0;

    mutable double cl = 0.;

    mutable double suprad = 0.;

    double mm = 0.;

    enum ScalingType { ST_Unknown, ST_Standard, ST_Noscaling, ST_Borino };
    ScalingType scaling;

    enum AveragedVarType { AVT_Unknown, AVT_EqStrain, AVT_Compliance, AVT_Damage };
    AveragedVarType averagedVar;

    double cl0 = 0.;
    enum NlVariationType { NLVT_Standard, NLVT_DistanceBasedLinear, NLVT_StressBased, NLVT_DistanceBasedExponential };
    NlVariationType nlvar;
    double beta = 0.;
    double zeta = 0.;

    double px = 0.;
 
    // Parameters used by models with evolving characteristic length.

    double Rf = 0.;
    double exponent = 0.;
    int averType = 0;
 
#ifdef _OPENMP
 public:
    static omp_lock_t updateDomainBeforeNonlocAverageLock;
#endif
public:
    NonlocalMaterialExtensionInterface(Domain *d);
    virtual ~NonlocalMaterialExtensionInterface() { }
 

    void updateDomainBeforeNonlocAverage(TimeStep *tStep) const;

    void buildNonlocalPointTable(GaussPoint *gp) const;

    void rebuildNonlocalPointTable(GaussPoint *gp, IntArray *contributingElems) const;

    void modifyNonlocalWeightFunctionAround(GaussPoint *gp) const;
    void modifyNonlocalWeightFunction_1D_Around(GaussPoint *gp) const;

    virtual double giveNonlocalMetricModifierAt(GaussPoint *gp) const { return 1.; }

    double computeDistanceModifier(double cl, double damage) const;

    double computeModifiedLength(double length, double dam1, double dam2) const;

    std :: vector< localIntegrationRecord > *giveIPIntegrationList(GaussPoint *gp) const;

    virtual double computeWeightFunction(const double cl, const double distance) const;

    virtual double computeWeightFunction(const double cl, const FloatArray &src, const FloatArray &coord) const;

    double giveIntegralOfWeightFunction(double cl, const int spatial_dimension) const;
 

    virtual double maxValueOfWeightFunction();

    int giveNumberOfRegions() const;
    /*
     * Returns the region id of given element
     * @param element pointer to element which region id is requested.
     * @return Region id (number) for this element.
     */
    //int giveElementRegion (Element* element);
    virtual int hasBoundedSupport() const { return 1; }
    virtual double evaluateSupportRadius(double cl) const;

    Domain *giveDomain() { return this->domain; }
 
    void initializeFrom(InputRecord &ir);
    void giveInputRecord(DynamicInputRecord &input);
    /*
     * Creates new copy of associated status and inserts it into given integration point.
     * @param gp Integration point where newly created status will be stored.
     * @return reference to new status.
     */
    //MaterialStatus* CreateStatus (GaussPoint* gp)
    // {return  new NonlocalMaterialStatus (1,this->giveDomain(), gp);;}
    void endIPNonlocalAverage(GaussPoint *gp) const;
 
protected:
    /*
     * Returns true if the barrier is activated
     * by interaction of two given points. In this case the nonlocal influence
     * is not considered.
     * @param gpCoords Coordinates of first point.
     * @param jGpCoords Coordinates of second point.
     * @param weight Set to zero if the GP are across the barrier.
     */
    //bool isBarrierActivated (const FloatArray& c1, const FloatArray& c2) const;
 
    void applyBarrierConstraints(const FloatArray &gpCoords, const FloatArray &jGpCoords, double &weight) const;

    void manipulateWeight(double &weight, GaussPoint *gp, GaussPoint *jGp) const;

    double giveDistanceBasedInteractionRadius(const FloatArray &gpCoords) const;
 
    int mapToGridPoint(double x, double x0) const { return 1 + gridSize + ( int ) ceil(gridSize * ( x - x0 ) / suprad - 0.5); }
    double mapToGridCoord(double x, double x0) const { return 1. + gridSize + gridSize * ( x - x0 ) / suprad; }
    double dist2FromGridNode(double x, double y, int j, int i) const { return ( ( x - j ) * ( x - j ) + ( y - i ) * ( y - i ) ); }
};
} // end namespace oofem
#endif // nonlocalmaterialext_h