mpsdammat.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
 */

//   ***********************************************************************************
//   ***   CLASS Damage extension of MPS model for creep and shrinakge of concrete   ***
//   ***********************************************************************************

#ifndef mpsdammat_h
#define mpsdammat_h

#include "mps.h"

#define supplementary_info


#define _IFT_MPSDamMaterial_Name "mpsdammat"
//prediction of tensile strength and fracture energy accroding to fib MC2010
#define _IFT_MPSDamMaterial_timedepfracturing "timedepfracturing"
#define _IFT_MPSDamMaterial_fib_s "fib_s"

#define _IFT_MPSDamMaterial_isotropic "isotropic"

#define _IFT_MPSDamMaterial_maxOmega "maxomega"

#define _IFT_MPSDamMaterial_damageLaw "damlaw"
#define _IFT_MPSDamMaterial_checkSnapBack "checksnapback"
#define _IFT_MPSDamMaterial_ft "ft"
#define _IFT_MPSDamMaterial_gf "gf"

#define _IFT_MPSDamMaterial_ft28 "ft28"
#define _IFT_MPSDamMaterial_gf28 "gf28"


namespace oofem {
#define MPSDAMMAT_ITERATION_LIMIT 1.e-9

class MPSDamMaterialStatus : public MPSMaterialStatus
{
protected:
    FloatArray effectiveStressVector;
    FloatArray tempEffectiveStressVector;
    double kappa;
    double tempKappa;
    double damage;
    double tempDamage;

    double charLength;
    FloatArray crackVector;

    double var_e0;
    double var_gf;

#ifdef supplementary_info
    double crackWidth;
    double residTensileStrength;
#endif

public:
    MPSDamMaterialStatus(int n, Domain *d, GaussPoint *g, int nunits);
    virtual ~MPSDamMaterialStatus() { }

    virtual const FloatArray &giveViscoelasticStressVector() const { return effectiveStressVector; }
    void letTempViscoelasticStressVectorBe(FloatArray v) { tempEffectiveStressVector = std :: move(v); }
    virtual const FloatArray &giveTempViscoelasticStressVector() const { return tempEffectiveStressVector; }

    double giveKappa() { return kappa; }
    double giveTempKappa() { return tempKappa; }
    void setTempKappa(double newKappa) { tempKappa = newKappa; }
    double giveDamage() { return damage; }
    double giveTempDamage() { return tempDamage; }
    void setTempDamage(double newDamage) { tempDamage = newDamage; }

    double giveCharLength() { return charLength; }
    void setCharLength(double length) { charLength = length; }
    void giveCrackVector(FloatArray &answer);
    void setCrackVector(FloatArray cv) { crackVector = cv; }

    void sete0(double e0) { var_e0 = e0; }
    void setgf(double gf) { var_gf = gf; }
    double givee0() { return var_e0; }
    double givegf() { return var_gf; }

    virtual void printOutputAt(FILE *file, TimeStep *tStep);
    virtual void initTempStatus();
    virtual void updateYourself(TimeStep *tStep);

#ifdef supplementary_info
    void setCrackWidth(double src) { crackWidth = src; }
    double giveCrackWidth(void) { return crackWidth; }
    void setResidualTensileStrength(double src) { residTensileStrength = src; }
    double giveResidualTensileStrength(void) { return residTensileStrength; }
#endif


    virtual contextIOResultType saveContext(DataStream &stream, ContextMode mode, void *obj = NULL);
    virtual contextIOResultType restoreContext(DataStream &stream, ContextMode mode, void *obj = NULL);

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

protected:
    virtual void initDamaged(double kappa, FloatArray &totalStrainVector, GaussPoint *gp) { }
};


class MPSDamMaterial : public MPSMaterial
{
protected:

    bool timeDepFracturing;
    double fib_s;
    double fib_fcm28;
    bool isotropic;

    double E;

    double maxOmega;

    //double const_e0;

    double ft;

    double const_gf;

    enum SofteningType { ST_Exponential_Cohesive_Crack, ST_Linear_Cohesive_Crack, ST_Disable_Damage };

    int checkSnapBack;

    SofteningType softType;

    ElementCharSizeMethod ecsMethod;

    double ft28;
    double gf28;

public:
    MPSDamMaterial(int n, Domain *d);
    virtual ~MPSDamMaterial() { }

    virtual int hasNonLinearBehaviour() { return 1; }

    virtual int hasMaterialModeCapability(MaterialMode mode);

    virtual const char *giveInputRecordName() const { return _IFT_MPSDamMaterial_Name; }
    virtual const char *giveClassName() const { return "MPSDamMaterial"; }

    virtual IRResultType initializeFrom(InputRecord *ir);

    virtual int giveIPValue(FloatArray &answer, GaussPoint *gp, InternalStateType type, TimeStep *tStep);

    virtual void giveRealStressVector(FloatArray &answer, GaussPoint *gp, const FloatArray &reducedStrain, TimeStep *tStep);

    double givee0(GaussPoint *gp);
    double givegf(GaussPoint *gp);

    void initDamaged(double kappa, FloatArray &totalStrainVector, GaussPoint *gp, TimeStep *tStep);

    void initDamagedFib(GaussPoint *gp, TimeStep *tStep);

    //void computeEquivalentStrain(double &kappa, const FloatArray &strain, GaussPoint *gp, TimeStep *tStep);

    void computeDamage(double &omega, double kappa, GaussPoint *gp);

    void computeDamageForCohesiveCrack(double &omega, double kappa, GaussPoint *gp);

    virtual MaterialStatus *CreateStatus(GaussPoint *gp) const;


    virtual double computeTensileStrength(double equivalentTime);
    virtual double computeFractureEnergy(double equivalentTime);

    virtual void give3dMaterialStiffnessMatrix(FloatMatrix &answer,
                                               MatResponseMode mode,
                                               GaussPoint *gp,
                                               TimeStep *tStep);

    virtual void givePlaneStressStiffMtrx(FloatMatrix &answer,
                                          MatResponseMode mode,
                                          GaussPoint *gp,
                                          TimeStep *tStep);

    virtual void givePlaneStrainStiffMtrx(FloatMatrix &answer,
                                          MatResponseMode mode,
                                          GaussPoint *gp,
                                          TimeStep *tStep);

    virtual void give1dStressStiffMtrx(FloatMatrix &answer,
                                       MatResponseMode mode,
                                       GaussPoint *gp,
                                       TimeStep *tStep);


protected:

    //virtual double giveEModulus(GaussPoint *gp, TimeStep *tStep);
};
} // end namespace oofem
#endif // mpsdammat_h