mps.h

Go to the documentation of this file.

/*
 *
 *                 #####    #####   ######  ######  ###   ###
 *               ##   ##  ##   ##  ##      ##      ## ### ##
 *              ##   ##  ##   ##  ####    ####    ##  #  ##
 *             ##   ##  ##   ##  ##      ##      ##     ##
 *            ##   ##  ##   ##  ##      ##      ##     ##
 *            #####    #####   ##      ######  ##     ##
 *
 *
 *             OOFEM : Object Oriented Finite Element Code
 *
 *               Copyright (C) 1993 - 2015   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 Material Model based on Microprestress Solidification Theory & Status ***
//   ***********************************************************************************

#ifndef mps_h
#define mps_h

#include "kelvinChSolM.h"


#define _IFT_MPSMaterial_Name "mps"
#define _IFT_MPSMaterial_mode "mode"
#define _IFT_MPSMaterial_coupledanalysistype "coupledanalysistype"
#define _IFT_MPSMaterial_fc "fc"
#define _IFT_MPSMaterial_cc "cc"
#define _IFT_MPSMaterial_wc "w/c"
#define _IFT_MPSMaterial_ac "a/c"
#define _IFT_MPSMaterial_q1 "q1"
#define _IFT_MPSMaterial_q2 "q2"
#define _IFT_MPSMaterial_q3 "q3"
#define _IFT_MPSMaterial_q4 "q4"
#define _IFT_MPSMaterial_lambda0 "lambda0"
#define _IFT_MPSMaterial_t0 "t0"
#define _IFT_MPSMaterial_ksh "ksh"
//#define _IFT_MPSMaterial_wh "w_h"
//#define _IFT_MPSMaterial_ncoeff "ncoeff"
//#define _IFT_MPSMaterial_a "a"
#define _IFT_MPSMaterial_qetor "qetor"
#define _IFT_MPSMaterial_qrtor "qrtor"
#define _IFT_MPSMaterial_qstor "qstor"
#define _IFT_MPSMaterial_alphae "alphae"
#define _IFT_MPSMaterial_alphar "alphar"
#define _IFT_MPSMaterial_alphas "alphas"
#define _IFT_MPSMaterial_mus "mus"
#define _IFT_MPSMaterial_ktm "ktm"
#define _IFT_MPSMaterial_ktc "ktc"
#define _IFT_MPSMaterial_stiffnessfactor "stiffnessfactor"
#define _IFT_MPSMaterial_p "p"
#define _IFT_MPSMaterial_p_tilde "p_tilde"
#define _IFT_MPSMaterial_k3 "k3"
#define _IFT_MPSMaterial_sh_a "sh_a"
#define _IFT_MPSMaterial_sh_hC "sh_hc"
#define _IFT_MPSMaterial_sh_n "sh_n"
#define _IFT_MPSMaterial_alpha_as "alpha_as"
#define _IFT_MPSMaterial_eps_cas0 "eps_cas0"
#define _IFT_MPSMaterial_B4_eps_au_infty "b4_eps_au_infty"
#define _IFT_MPSMaterial_B4_tau_au "b4_tau_au"
#define _IFT_MPSMaterial_B4_alpha "b4_alpha"
#define _IFT_MPSMaterial_B4_r_t "b4_r_t"
#define _IFT_MPSMaterial_B4_cem_type "b4_cem_type"
#define _IFT_MPSMaterial_temperInCelsius "temperincelsius"


namespace oofem {
class MPSMaterialStatus : public KelvinChainSolidMaterialStatus
{
protected:
    double hum;
    double hum_increment;
    double T;
    double T_increment;
    double T_max;
    double equivalentTime;
    double equivalentTimeTemp;
    double flowTermViscosity;
    double flowTermViscosityTemp;
    bool storedEmodulusFlag;
    double storedEmodulus;

#ifdef keep_track_of_strains
    double dryingShrinkageStrain;
    double tempDryingShrinkageStrain;
    double autogenousShrinkageStrain;
    double tempAutogenousShrinkageStrain;
    FloatArray creepStrain;
    FloatArray creepStrainIncrement;
#endif


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

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

    double giveHum() { return hum; }
    void setHum(double src) { hum = src; }
    double giveHumIncrement() { return hum_increment; }
    void setHumIncrement(double src) { hum_increment = src; }

    double giveT() { return T; }
    void setT(double src) { T = src; }

    double giveTIncrement() { return T_increment; }
    void setTIncrement(double src) { T_increment = src; }

    double giveTmax() { return T_max; }
    void setTmax(double src) { T_max = src; }

    double giveEquivalentTime() { return equivalentTime; }
    void setEquivalentTimeTemp(double src) { equivalentTimeTemp = src; }

    double giveFlowTermViscosity() { return flowTermViscosity; }
    double giveFlowTermViscosityTemp() { return flowTermViscosityTemp; }
    void setFlowTermViscosityTemp(double src) { flowTermViscosityTemp = src; }

    void storeEmodulus(double src) { storedEmodulus = src; }
    void setEmodulusFlag(bool src) { storedEmodulusFlag = src; }
    double giveStoredEmodulus(void) { return storedEmodulus; }
    bool giveStoredEmodulusFlag(void) { return storedEmodulusFlag; }

#ifdef keep_track_of_strains
    void setTempDryingShrinkageStrain(double src) { tempDryingShrinkageStrain = src; }
    double giveTempDryingShrinkageStrain(void) { return tempDryingShrinkageStrain; }
    double giveDryingShrinkageStrain(void) { return dryingShrinkageStrain; }

    void setTempAutogenousShrinkageStrain(double src) { tempAutogenousShrinkageStrain = src; }
    double giveTempAutogenousShrinkageStrain(void) { return tempAutogenousShrinkageStrain; }
    double giveAutogenousShrinkageStrain(void) { return autogenousShrinkageStrain; }

    void setCreepStrainIncrement(FloatArray src) { creepStrainIncrement  = std :: move(src); }
    const FloatArray &giveCreepStrain() const { return creepStrain; }
#endif

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


class MPSMaterial : public KelvinChainSolidMaterial
{
protected:


    double t0;
    double q1, q2, q3, q4;
    double lambda0;


    enum coupledAnalysisType { Basic, MPS_full, MPS_humidity, MPS_temperature } CoupledAnalysis;

    double EspringVal; // elastic modulus of the aging spring (first member of Kelvin chain if retardation spectrum is used)

    //double w_h, n, a; //constant (obtained from experiments) A [Pedersen, 1990]

    // MPS theory parameters
    double kSh;
    double muS, k3;
    double kTm;
    double kTc;
    double ct;
    double roomTemperature;
    double QEtoR, QRtoR, QStoR; //[K]
    double alphaE, alphaR, alphaS; //[-]
    double p;
    double sh_a, sh_hC, sh_n;
    double eps_cas0;
    double b4_eps_au_infty, b4_tau_au, b4_alpha, b4_r_t;

    double stiffnessFactor;

    double temperScaleDifference;


public:
    MPSMaterial(int n, Domain *d) : KelvinChainSolidMaterial(n, d) { }
    virtual ~MPSMaterial() { }

    virtual const char *giveInputRecordName() const { return _IFT_MPSMaterial_Name; }
    virtual const char *giveClassName() const { return "MPSMaterial"; }

    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);
    //virtual void updateYourself(GaussPoint *gp, TimeStep *tStep);



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

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

    virtual MaterialStatus *CreateStatus(GaussPoint *gp) const;

protected:
    void predictParametersFrom(double, double, double, double);

    virtual void computeCharTimes();

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

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

    virtual double computeSolidifiedVolume(GaussPoint *gp, TimeStep *tStep);

    virtual double computeBetaMu(GaussPoint *gp, TimeStep *tStep, int Mu);
    virtual double computeLambdaMu(GaussPoint *gp, TimeStep *tStep, int Mu);

    double computeFlowTermViscosity(GaussPoint *gp, TimeStep *tStep);

    double giveInitViscosity(TimeStep *tStep);

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

    virtual int hasIncrementalShrinkageFormulation() { return 1; }


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

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

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

    //double inverse_sorption_isotherm(double w);

    double giveHumidity(GaussPoint *gp, TimeStep *tStep, int option);

    double giveTemperature(GaussPoint *gp, TimeStep *tStep, int option);

    double computePsiR(GaussPoint *gp, TimeStep *tStep, int option);

    double computePsiS(GaussPoint *gp, TimeStep *tStep);

    double computePsiE(GaussPoint *gp, TimeStep *tStep);

    double computeEquivalentTime(GaussPoint *gp, TimeStep *tStep, int option);

    friend class RankineMPSmat;
};
} // end namespace oofem
#endif // mps_h