nonlocalmaterialext.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 nonlocalmaterialext_h
#define nonlocalmaterialext_h

#include "matstatus.h"
#include "interface.h"
#include "intarray.h"
#include "grid.h"
#include "mathfem.h"

#include <list>


#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;
};

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;
    IntArray regionMap;
    bool permanentNonlocTableFlag;
    enum WeightFunctionType { WFT_Unknown, WFT_Bell, WFT_Gauss, WFT_Green, WFT_Uniform, WFT_UniformOverElement, WFT_Green_21 };
    WeightFunctionType weightFun;
    int gridSize;
    Grid *grid;
    FloatMatrix *minDist2;
    double initDiag;
    int order;
    int centDiff;

    double cl;

    double suprad;

    double mm;

    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;
    enum NlVariationType { NLVT_Standard, NLVT_DistanceBasedLinear, NLVT_StressBased, NLVT_DistanceBasedExponential };
    NlVariationType nlvar;
    double beta;
    double zeta;

    double px;

    // Parameters used by models with evolving characteristic length.

    double Rf;
    double exponent;
    int averType;

public:
    NonlocalMaterialExtensionInterface(Domain *d);
    virtual ~NonlocalMaterialExtensionInterface() { delete grid; delete minDist2; }


    void updateDomainBeforeNonlocAverage(TimeStep *tStep);

    void buildNonlocalPointTable(GaussPoint *gp);

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

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

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

    double computeDistanceModifier(double damage);

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

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

    virtual double computeWeightFunction(double distance);

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

    double giveIntegralOfWeightFunction(const int spatial_dimension);


    virtual double maxValueOfWeightFunction();

    int giveNumberOfRegions();
    /*
     * 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() { return 1; }
    virtual double evaluateSupportRadius();

    Domain *giveDomain() { return this->domain; }

    IRResultType 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);

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);

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

    double giveDistanceBasedInteractionRadius(const FloatArray &gpCoords);

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