rheoChM.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 rheochm_h
#define rheochm_h

#define keep_track_of_strains

#include "../sm/Materials/structuralmaterial.h"
#include "Materials/linearelasticmaterial.h"
#include "floatarray.h"
#include "floatmatrix.h"

#include "matconst.h"
#include "../sm/Elements/structuralelement.h"
#include "../sm/Materials/structuralms.h"


#define _IFT_RheoChainMaterial_n "n"
#define _IFT_RheoChainMaterial_alphaOne "a1"
#define _IFT_RheoChainMaterial_alphaTwo "a2"
#define _IFT_RheoChainMaterial_lattice "lattice"
#define _IFT_RheoChainMaterial_relmatage "relmatage"
#define _IFT_RheoChainMaterial_begoftimeofinterest "begoftimeofinterest"
#define _IFT_RheoChainMaterial_endoftimeofinterest "endoftimeofinterest"
#define _IFT_RheoChainMaterial_timefactor "timefactor"
#define _IFT_RheoChainMaterial_talpha "talpha"
#define _IFT_RheoChainMaterial_preCastingTimeMat "precastingtimemat"


namespace oofem {
#define MNC_NPOINTS 30
#define TIME_DIFF   1.e-10

class RheoChainMaterialStatus : public StructuralMaterialStatus
{
protected:
    int nUnits;
    std :: vector< FloatArray >hiddenVars;
    std :: vector< FloatArray >tempHiddenVars;

    FloatArray shrinkageStrain;

#ifdef keep_track_of_strains
    double thermalStrain;
    double tempThermalStrain;
#endif

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

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

    virtual const FloatArray &giveViscoelasticStressVector() const { return stressVector; }

    FloatArray &giveHiddenVarsVector(int i) { return hiddenVars [ i - 1 ]; }
    FloatArray &giveTempHiddenVarsVector(int i) { return tempHiddenVars [ i - 1 ]; }
    FloatArray *letHiddenVarsVectorBe(int i, FloatArray *);
    void letTempHiddenVarsVectorBe(int i, FloatArray &valueArray);

    FloatArray *giveShrinkageStrainVector() { return & shrinkageStrain; }
    void setShrinkageStrainVector(FloatArray src) { shrinkageStrain = std :: move(src); }

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


#ifdef keep_track_of_strains
    void setTempThermalStrain(double src) { tempThermalStrain = src; }
    double giveTempThermalStrain(void) { return tempThermalStrain; }
    double giveThermalStrain(void) { return thermalStrain; }
#endif

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


class RheoChainMaterial : public StructuralMaterial
{
protected:
    double talpha;
    int nUnits;
    double relMatAge;

    bool lattice;
    double nu;
    double alphaOne, alphaTwo;
    double EparValTime;

    double begOfTimeOfInterest; // local one or taken from e-model
    double endOfTimeOfInterest; // local one or taken from e-model
    LinearElasticMaterial *linearElasticMaterial;
    FloatArray EparVal;
    //FloatArray relaxationTimes;
    FloatArray charTimes;
    FloatArray discreteTimeScale;

    double timeFactor;

    //double zeroStiffness;

    int preCastingTimeMat;

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

    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_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 void giveRealStressVector_2dBeamLayer(FloatArray &answer, GaussPoint *gp, const FloatArray &reducedE, TimeStep *tStep)
    { this->giveRealStressVector(answer, gp, reducedE, tStep); }
    virtual void giveRealStressVector_PlateLayer(FloatArray &answer, GaussPoint *gp, const FloatArray &reducedE, TimeStep *tStep)
    { this->giveRealStressVector(answer, gp, reducedE, tStep); }

    virtual void giveThermalDilatationVector(FloatArray &answer, GaussPoint *gp, TimeStep *tStep);

    /*    virtual void giveThermalDilatationVector(FloatArray &answer, GaussPoint *gp, TimeStep *tStep)
     *    { answer.clear(); }*/

    virtual double giveEModulus(GaussPoint *gp, TimeStep *tStep) = 0;

    /*    virtual double giveIncrementalModulus(GaussPoint *gp, TimeStep *tStep) {
     * if ( (tStep->giveIntrinsicTime() < this->castingTime) && ( this->zeroStiffness > 0. ) ) {
     *  return this->zeroStiffness;
     * } else {
     *  return this->giveEModulus(gp, tStep);
     * }
     * }*/

    virtual void computeCharCoefficients(FloatArray &answer, double tPrime, GaussPoint *gp, TimeStep *tStep) = 0;

    // identification and auxiliary functions
    virtual int hasNonLinearBehaviour() { return 0; }
    virtual int hasMaterialModeCapability(MaterialMode mode);

    virtual int hasCastingTimeSupport() { return 1; }

    virtual const char *giveClassName() const { return "RheoChainMaterial"; }
    virtual IRResultType initializeFrom(InputRecord *ir);

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

    // store & restore context functions
    virtual contextIOResultType saveIPContext(DataStream &stream, ContextMode mode, GaussPoint *gp);
    virtual contextIOResultType restoreIPContext(DataStream &stream, ContextMode mode, GaussPoint *gp);

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

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

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

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

    virtual void computeStressIndependentStrainVector(FloatArray &answer,
                                                      GaussPoint *gp, TimeStep *tStep, ValueModeType mode);

    virtual void giveShrinkageStrainVector(FloatArray &answer,
                                           GaussPoint *gp,
                                           TimeStep *tStep,
                                           ValueModeType mode)
    { answer.clear(); }

    // Note: must take LoadResponseMode into account
    virtual void giveEigenStrainVector(FloatArray &answer, GaussPoint *gp, TimeStep *tStep, ValueModeType mode) { }

    virtual MaterialStatus *CreateStatus(GaussPoint *gp) const;

    double giveAlphaOne() const { return this->alphaOne; }
    double giveAlphaTwo() const { return this->alphaTwo; }

    virtual double computeCreepFunction(double t, double t_prime, GaussPoint *gp, TimeStep *tStep) = 0;

    virtual bool isActivated(TimeStep *tStep) {
        if ( this->preCastingTimeMat > 0 ) {
            return true;
        } else {
            return Material :: isActivated(tStep);
        }
    }


protected:
    virtual int hasIncrementalShrinkageFormulation() { return 0; }

    static void generateLogTimeScale(FloatArray &answer, double from, double to, int nsteps);
    const FloatArray &giveDiscreteTimes();

    void computeDiscreteRelaxationFunction(FloatArray &answer, const FloatArray &tSteps, double t0, double tr, GaussPoint *gp, TimeStep *tSte);

    void giveUnitComplianceMatrix(FloatMatrix &answer, GaussPoint *gp, TimeStep *tStep);
    void giveUnitStiffnessMatrix(FloatMatrix &answer, GaussPoint *gp, TimeStep *tStep);

    virtual void updateEparModuli(double tPrime, GaussPoint *gp, TimeStep *tStep);

    double giveEparModulus(int iChain);

    virtual void computeCharTimes();

    double giveCharTime(int) const;

    virtual double giveCharTimeExponent(int i) { return 1.0; }

    LinearElasticMaterial *giveLinearElasticMaterial();

    double giveEndOfTimeOfInterest();

    void computeTrueStressIndependentStrainVector(FloatArray &answer, GaussPoint *gp,
                                                  TimeStep *tStep, ValueModeType mode);
};
} // end namespace oofem
#endif // rheochm_h