isodamagemodel.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 isodamagemodel_h
#define isodamagemodel_h

// this turns on or off a bunch of internal variables
// that allow tracing the distribution of dissipated energy
// (can be turned off if such information is not needed)
#define keep_track_of_dissipated_energy

#include "material.h"
#include "Materials/linearelasticmaterial.h"
#include "../sm/Materials/structuralmaterial.h"
#include "../sm/Materials/structuralms.h"


#define _IFT_IsotropicDamageMaterial_talpha "talpha"
#define _IFT_IsotropicDamageMaterial_maxOmega "maxomega"
#define _IFT_IsotropicDamageMaterial_permstrain "ps"


namespace oofem {
class GaussPoint;

class IsotropicDamageMaterialStatus : public StructuralMaterialStatus
{
protected:
    double kappa;
    double tempKappa;
    double damage;
    double tempDamage;
    double le;
    double crack_angle;
    FloatArray crackVector;

#ifdef keep_track_of_dissipated_energy
    double stressWork;
    double tempStressWork;
    double dissWork;
    double tempDissWork;
#endif

public:
    IsotropicDamageMaterialStatus(int n, Domain *d, GaussPoint *g);
    virtual ~IsotropicDamageMaterialStatus();

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

    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 giveLe() { return le; }
    void setLe(double ls) { le = ls; }
    double giveCrackAngle() { return crack_angle; }
    void setCrackAngle(double ca) { crack_angle = ca; }
    void giveCrackVector(FloatArray &answer);
    void setCrackVector(FloatArray cv) { crackVector = cv; }

#ifdef keep_track_of_dissipated_energy
    double giveStressWork() { return stressWork; }
    double giveTempStressWork() { return tempStressWork; }
    void setTempStressWork(double w) { tempStressWork = w; }
    double giveDissWork() { return dissWork; }
    double giveTempDissWork() { return tempDissWork; }
    void setTempDissWork(double w) { tempDissWork = w; }
    void computeWork(GaussPoint *gp);
#endif

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

    virtual void initTempStatus();
    virtual void updateYourself(TimeStep *tStep);

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


class IsotropicDamageMaterial : public StructuralMaterial
{
protected:
    double tempDillatCoeff;

    double maxOmega;

    int permStrain;

    LinearElasticMaterial *linearElasticMaterial;
    enum loaUnloCriterium { idm_strainLevelCR, idm_damageLevelCR } llcriteria;

public:
    IsotropicDamageMaterial(int n, Domain *d);
    virtual ~IsotropicDamageMaterial();

    virtual int hasNonLinearBehaviour() { return 1; }

    virtual int hasMaterialModeCapability(MaterialMode mode);
    virtual const char *giveClassName() const { return "IsotropicDamageMaterial"; }

    LinearElasticMaterial *giveLinearElasticMaterial() { return linearElasticMaterial; }

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

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

    virtual void giveRealStressVector_3d(FloatArray &answer, GaussPoint *gp, const FloatArray &reducedE, TimeStep *tStep)
    { this->giveRealStressVector(answer, gp, reducedE, tStep); }
    virtual void giveRealStressVector_PlaneStrain(FloatArray &answer, GaussPoint *gp, const FloatArray &reducedE, TimeStep *tStep)
    { this->giveRealStressVector(answer, gp, reducedE, tStep); }
    virtual void giveRealStressVector_StressControl(FloatArray &answer, GaussPoint *gp, const FloatArray &reducedE, const IntArray &strainControl, TimeStep *tStep)
    { this->giveRealStressVector(answer, gp, reducedE, tStep); }
    virtual void giveRealStressVector_PlaneStress(FloatArray &answer, GaussPoint *gp, const FloatArray &reducedE, TimeStep *tStep)
    { this->giveRealStressVector(answer, gp, reducedE, tStep); }
    virtual void giveRealStressVector_1d(FloatArray &answer, GaussPoint *gp, const FloatArray &reducedE, TimeStep *tStep)
    { this->giveRealStressVector(answer, gp, reducedE, tStep); }

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

    virtual void giveThermalDilatationVector(FloatArray &answer, GaussPoint *, TimeStep *);
    virtual double evaluatePermanentStrain(double kappa, double omega) { return 0.; }

    virtual double give(int aProperty, GaussPoint *gp);
    virtual void computeEquivalentStrain(double &kappa, const FloatArray &strain, GaussPoint *gp, TimeStep *tStep) = 0;
    virtual void computeEta(FloatArray &answer, const FloatArray &strain, GaussPoint *gp, TimeStep *tStep) { OOFEM_ERROR("not implemented"); }
    virtual void computeDamageParam(double &omega, double kappa, const FloatArray &strain, GaussPoint *gp) = 0;

    virtual IRResultType initializeFrom(InputRecord *ir);
    virtual void giveInputRecord(DynamicInputRecord &input);

    MaterialStatus *CreateStatus(GaussPoint *gp) const { return new IsotropicDamageMaterialStatus(1, domain, gp); }

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

    virtual double damageFunctionPrime(double kappa, GaussPoint *gp) {
        OOFEM_ERROR("not implemented");
        return 0;
    }

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

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

    virtual void give1dStressStiffMtrx(FloatMatrix &answer, MatResponseMode mmode,
                                       GaussPoint *gp,
                                       TimeStep *tStep);
};
} // end namespace oofem
#endif // isodamagemodel_h