idm1.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 idm1_h
#define idm1_h

//#define IDM_USE_MMAClosestIPTransfer
#define IDM_USE_MMAContainingElementProjection
//#define IDM_USE_MMAShapeFunctProjection
//#define IDM_USE_MMALeastSquareProjection

/*
 * Selects the use of mapped strain or projected strain from element.
 */
#define IDM_USE_MAPPEDSTRAIN

#include "material.h"
#include "Materials/linearelasticmaterial.h"
#include "Materials/isodamagemodel.h"
#include "../sm/Materials/structuralms.h"
#include "randommaterialext.h"
#include "materialmapperinterface.h"

#ifdef IDM_USE_MMAClosestIPTransfer
 #include "mmaclosestiptransfer.h"
#endif

#ifdef IDM_USE_MMAContainingElementProjection
 #include "mmacontainingelementprojection.h"
#endif

#ifdef IDM_USE_MMAShapeFunctProjection
 #include "mmashapefunctprojection.h"
#endif

#ifdef IDM_USE_MMALeastSquareProjection
 #include "mmaleastsquareprojection.h"
#endif


#define _IFT_IsotropicDamageMaterial1_Name "idm1"
#define _IFT_IsotropicDamageMaterial1_e0 "e0"
#define _IFT_IsotropicDamageMaterial1_ef "ef"
#define _IFT_IsotropicDamageMaterial1_wf "wf"
#define _IFT_IsotropicDamageMaterial1_equivstraintype "equivstraintype"
#define _IFT_IsotropicDamageMaterial1_damageLaw "damlaw"
#define _IFT_IsotropicDamageMaterial1_k "k"
#define _IFT_IsotropicDamageMaterial1_md "md"
#define _IFT_IsotropicDamageMaterial1_ecsm "ecsm"
#define _IFT_IsotropicDamageMaterial1_At "at"
#define _IFT_IsotropicDamageMaterial1_Bt "bt"
#define _IFT_IsotropicDamageMaterial1_ft "ft"
#define _IFT_IsotropicDamageMaterial1_wkwf "wkwf"
#define _IFT_IsotropicDamageMaterial1_e1ef "e1ef"
#define _IFT_IsotropicDamageMaterial1_skft "skft"
#define _IFT_IsotropicDamageMaterial1_s1 "s1"
#define _IFT_IsotropicDamageMaterial1_sk "sk"
#define _IFT_IsotropicDamageMaterial1_wk "wk"
#define _IFT_IsotropicDamageMaterial1_e1 "e1"
#define _IFT_IsotropicDamageMaterial1_ek "ek"
#define _IFT_IsotropicDamageMaterial1_gf "gf"
#define _IFT_IsotropicDamageMaterial1_gft "gft"
#define _IFT_IsotropicDamageMaterial1_ep "ep"
#define _IFT_IsotropicDamageMaterial1_e2 "e2"
#define _IFT_IsotropicDamageMaterial1_nd "nd"
#define _IFT_IsotropicDamageMaterial1_checkSnapBack "checksnapback"
#define _IFT_IsotropicDamageMaterial1_n "griff_n"
#define _IFT_IsotropicDamageMaterial1_c1 "c1"
#define _IFT_IsotropicDamageMaterial1_c2 "c2"
#define _IFT_IsotropicDamageMaterial1_alphaps "alphaps"
#define _IFT_IsotropicDamageMaterial1_h "h"


namespace oofem {
#define IDM1_ITERATION_LIMIT 1.e-9

class IsotropicDamageMaterial1Status : public IsotropicDamageMaterialStatus, public RandomMaterialStatusExtensionInterface
{
public:
    IsotropicDamageMaterial1Status(int n, Domain *d, GaussPoint *g);
    virtual ~IsotropicDamageMaterial1Status() { }

    // definition
    virtual const char *giveClassName() const { return "IsotropicDamageMaterial1Status"; }

    virtual Interface *giveInterface(InterfaceType it);
};

class IsotropicDamageMaterial1 : public IsotropicDamageMaterial,
    public RandomMaterialExtensionInterface,
    public MaterialModelMapperInterface
{
protected:
    double e0;
    double ef;
    double wf;

    double gf;

    double gft;

    double ek;

    double wk;

    double sk;

    double c1, c2;

    enum EquivStrainType {
        EST_Mazars=0,
        EST_Rankine_Smooth=1,
        EST_ElasticEnergy=2,
        EST_Mises=3,
        EST_Rankine_Standard=4,
        EST_ElasticEnergyPositiveStress=5,
        EST_ElasticEnergyPositiveStrain=6,
        EST_Griffith=7,
        EST_Unknown = 100
    };
    EquivStrainType equivStrainType;

    double k;

    double griff_n;

    int damageLaw;

    enum SofteningType { ST_Unknown, ST_Exponential, ST_Linear, ST_Mazars, ST_Smooth, ST_SmoothExtended, ST_Exponential_Cohesive_Crack, ST_Linear_Cohesive_Crack, ST_BiLinear_Cohesive_Crack, ST_Disable_Damage, ST_PowerExponential, ST_DoubleExponential, ST_Hordijk_Cohesive_Crack, ST_ModPowerExponential };

    SofteningType softType;

    double At, Bt;
    double md;

    double e1, e2, s1, nd;
    int checkSnapBack;

    double ep, ft;

    double ps_alpha, ps_H;

    ElementCharSizeMethod ecsMethod;

    Set *sourceElemSet;

#ifdef IDM_USE_MMAClosestIPTransfer
    static MMAClosestIPTransfer mapper;
#endif
#ifdef IDM_USE_MMAContainingElementProjection
    static MMAContainingElementProjection mapper;
#endif
#ifdef IDM_USE_MMAShapeFunctProjection
    static MMAShapeFunctProjection mapper;
#endif
#ifdef IDM_USE_MMALeastSquareProjection
    static MMALeastSquareProjection mapper;
#endif

public:

    IsotropicDamageMaterial1(int n, Domain *d);
    virtual ~IsotropicDamageMaterial1();

    // identification and auxiliary functions
    virtual const char *giveClassName() const { return "IsotropicDamageMaterial1"; }
    virtual const char *giveInputRecordName() const { return _IFT_IsotropicDamageMaterial1_Name; }
    virtual IRResultType initializeFrom(InputRecord *ir);
    virtual void giveInputRecord(DynamicInputRecord &input);
    static void computeStrainInvariants(const FloatArray &strainVector, double &I1e, double &J2e);

    bool isCrackBandApproachUsed() { return ( this->softType == ST_Exponential_Cohesive_Crack || this->softType == ST_Linear_Cohesive_Crack || this->softType == ST_BiLinear_Cohesive_Crack || this->gf != 0. ); }
    virtual void computeEquivalentStrain(double &kappa, const FloatArray &strain, GaussPoint *gp, TimeStep *tStep);

    virtual void computeEta(FloatArray &answer, const FloatArray &strain, GaussPoint *gp, TimeStep *tStep);
    virtual void computeDamageParam(double &omega, double kappa, const FloatArray &strain, GaussPoint *gp);
    void computeDamageParamForCohesiveCrack(double &omega, double kappa, GaussPoint *gp);
    double damageFunction(double kappa, GaussPoint *gp);
    double damageFunctionPrime(double kappa, GaussPoint *gp);
    double complianceFunction(double kappa, GaussPoint *gp);

    double evaluatePermanentStrain(double kappa, double omega);

    virtual Interface *giveInterface(InterfaceType it);

    virtual int MMI_map(GaussPoint *gp, Domain *oldd, TimeStep *tStep);
    virtual int MMI_update(GaussPoint *gp, TimeStep *tStep, FloatArray *estrain = NULL);
    virtual int MMI_finish(TimeStep *tStep);

    virtual MaterialStatus *CreateStatus(GaussPoint *gp) const;
    virtual MaterialStatus *giveStatus(GaussPoint *gp) const;

    virtual double give(int aProperty, GaussPoint *gp);

    virtual bool isCharacteristicMtrxSymmetric(MatResponseMode rMode) { return false; }

protected:
    virtual void initDamaged(double kappa, FloatArray &totalStrainVector, GaussPoint *gp);
};
} // end namespace oofem
#endif // idm1_h