structuralmaterial.h

Go to the documentation of this file.

/*
 *
 *                 #####    #####   ######  ######  ###   ###
 *               ##   ##  ##   ##  ##      ##      ## ### ##
 *              ##   ##  ##   ##  ####    ####    ##  #  ##
 *             ##   ##  ##   ##  ##      ##      ##     ##
 *            ##   ##  ##   ##  ##      ##      ##     ##
 *            #####    #####   ##      ######  ##     ##
 *
 *
 *             OOFEM : Object Oriented Finite Element Code
 *
 *               Copyright (C) 1993 - 2025   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 structuralmaterial_h
#define structuralmaterial_h
 
#include "material.h"
#include "floatarray.h"
#include "floatmatrix.h"
#include "floatarrayf.h"
#include "floatmatrixf.h"
#include "mathfem.h"
#include "matconst.h"
#include "matstatus.h"
#include "../stressstrainprincmode.h"
#include "valuemodetype.h"
#include <vector>


#define _IFT_StructuralMaterial_referencetemperature "referencetemperature"
#define _IFT_StructuralMaterial_talpha "talpha"
#define _IFT_StructuralMaterial_StressControl_stiffmode "scstiffmode"
#define _IFT_StructuralMaterial_StressControl_reltol "screltol"
#define _IFT_StructuralMaterial_StressControl_abstol "scabstol"
#define _IFT_StructuralMaterial_StressControl_maxiter "maxiter"
 
namespace oofem {
#define STRAIN_STEPS 10.0
 
class GaussPoint;

class OOFEM_EXPORT StructuralMaterial : public Material
{
protected:
    double referenceTemperature = 0.;
    MatResponseMode SCStiffMode = TangentStiffness; // tangent
    double SCRelTol = 1.e-3;  // relative stress control tolerance
    double SCAbsTol = 1.e-12;
    int SCMaxiter = 100000;
 
public:
    static std::array< std::array< int, 3 >, 3 >vIindex;

    static std::array< std::array< int, 3 >, 3 >svIndex;
 
    static int giveSymVI(int ind1, int ind2) { return svIndex [ ind1 - 1 ] [ ind2 - 1 ]; }
    static int giveVI(int ind1, int ind2) { return vIindex [ ind1 - 1 ] [ ind2 - 1 ]; }

    StructuralMaterial(int n, Domain *d);
 
    bool hasMaterialModeCapability(MaterialMode mode) const override;
    const char *giveClassName() const override { return "StructuralMaterial"; }
 
    void initializeFrom(InputRecord &ir) override;
    void giveInputRecord(DynamicInputRecord &input) override;
    void giveCharacteristicMatrix(FloatMatrix &answer, MatResponseMode type, GaussPoint* gp, TimeStep *tStep) const override;
    void giveCharacteristicVector(FloatArray &answer, FloatArray& flux, MatResponseMode type, GaussPoint* gp, TimeStep *tStep) const override;

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

    virtual void giveRealStressVector(FloatArray &answer, GaussPoint *gp,
                                      const FloatArray &reducedStrain, TimeStep *tStep) const;
    virtual FloatArrayF< 6 >giveRealStressVector_3d(const FloatArrayF< 6 > &strain, GaussPoint *gp, TimeStep *tStep) const;
    virtual FloatArrayF< 4 >giveRealStressVector_PlaneStrain(const FloatArrayF< 4 > &strain, GaussPoint *gp, TimeStep *tStep) const;
    virtual FloatArray giveRealStressVector_StressControl(const FloatArray &reducedE, const IntArray &strainControl, GaussPoint *gp, TimeStep *tStep) const;
    virtual FloatArray giveRealStressVector_ShellStressControl(const FloatArray &reducedE, const IntArray &strainControl, GaussPoint *gp, TimeStep *tStep) const;
    virtual FloatArrayF< 3 >giveRealStressVector_PlaneStress(const FloatArrayF< 3 > &reducedE, GaussPoint *gp, TimeStep *tStep) const;
    virtual FloatArrayF< 1 >giveRealStressVector_1d(const FloatArrayF< 1 > &reducedE, GaussPoint *gp, TimeStep *tStep) const;

    virtual FloatArrayF< 2 >giveRealStressVector_Warping(const FloatArrayF< 2 > &reducedE, GaussPoint *gp, TimeStep *tStep) const;
    virtual FloatArrayF< 2 >giveRealStressVector_2dBeamLayer(const FloatArrayF< 2 > &reducedE, GaussPoint *gp, TimeStep *tStep) const;
    virtual FloatArrayF< 5 >giveRealStressVector_PlateLayer(const FloatArrayF< 5 > &reducedE, GaussPoint *gp, TimeStep *tStep) const;
    virtual FloatArrayF< 3 >giveRealStressVector_Fiber(const FloatArrayF< 3 > &reducedE, GaussPoint *gp, TimeStep *tStep) const;

    virtual FloatArrayF< 3 >giveRealStressVector_2dPlateSubSoil(const FloatArrayF< 3 > &reducedE, GaussPoint *gp, TimeStep *tStep) const;
    virtual FloatArrayF< 6 >giveRealStressVector_3dBeamSubSoil(const FloatArrayF< 6 > &reducedE, GaussPoint *gp, TimeStep *tStep) const;


    virtual FloatArrayF< 9 >giveFirstPKStressVector_3d(const FloatArrayF< 9 > &vF, GaussPoint *gp, TimeStep *tStep) const;
    virtual FloatArrayF< 5 >giveFirstPKStressVector_PlaneStrain(const FloatArrayF< 5 > &vF, GaussPoint *gp, TimeStep *tStep) const;
    virtual FloatArray giveFirstPKStressVector_StressControl(const FloatArray &reducedvF, const IntArray &FControl, GaussPoint *gp, TimeStep *tStep) const;
    virtual FloatArrayF< 4 >giveFirstPKStressVector_PlaneStress(const FloatArrayF< 4 > &vF, GaussPoint *gp, TimeStep *tStep) const;
    virtual FloatArrayF< 1 >giveFirstPKStressVector_1d(const FloatArrayF< 1 > &vF, GaussPoint *gp, TimeStep *tStep) const;

    virtual void giveCauchyStressVector_3d(FloatArray &answer, GaussPoint *gp, const FloatArray &reducedF, TimeStep *tStep)
    { OOFEM_ERROR("not implemented "); }
    virtual void giveCauchyStressVector_PlaneStrain(FloatArray &answer, GaussPoint *gp, const FloatArray &reducedF, TimeStep *tStep)
    { OOFEM_ERROR("not implemented "); }
    virtual void giveCauchyStressVector_PlaneStress(FloatArray &answer, GaussPoint *gp, const FloatArray &reducedF, TimeStep *tStep)
    { OOFEM_ERROR("not implemented "); }
    virtual void giveCauchyStressVector_1d(FloatArray &answer, GaussPoint *gp, const FloatArray &reducedF, TimeStep *tStep)
    { OOFEM_ERROR("not implemented "); }


    virtual void giveEshelbyStressVector_PlaneStrain(FloatArray &answer, GaussPoint *gp, const FloatArray &reducedF, TimeStep *tStep);
 
    static FloatMatrixF< 9, 9 >convert_dSdE_2_dPdF_3D(const FloatMatrixF< 6, 6 > &dSdE, const FloatArrayF< 6 > &S, const FloatArrayF< 9 > &F);
    static FloatMatrixF< 5, 5 >convert_dSdE_2_dPdF_PlaneStrain(const FloatMatrixF< 4, 4 > &dSdE, const FloatArrayF< 4 > &S, const FloatArrayF< 5 > &F);
    static FloatMatrixF< 4, 4 >convert_dSdE_2_dPdF_PlaneStress(const FloatMatrixF< 3, 3 > &dSdE, const FloatArrayF< 3 > &S, const FloatArrayF< 4 > &F);
    static FloatMatrixF< 1, 1 >convert_dSdE_2_dPdF_1D(const FloatMatrixF< 1, 1 > &dSdE, const FloatArrayF< 1 > &S, const FloatArrayF< 1 > &F);

    virtual FloatArrayF< 6 >giveThermalDilatationVector(GaussPoint *gp, TimeStep *tStep) const;
    double giveReferenceTemperature() { return referenceTemperature; }

    virtual FloatArray computeStressIndependentStrainVector(GaussPoint *gp, TimeStep *tStep, ValueModeType mode) const;
    FloatArrayF< 6 >computeStressIndependentStrainVector_3d(GaussPoint *gp, TimeStep *tStep, ValueModeType mode) const;


    static void computePrincipalValues(FloatArray &answer, const FloatArray &s, stressStrainPrincMode mode);
    static FloatArrayF< 3 >computePrincipalValues(const FloatMatrixF< 3, 3 > &s);

    static FloatArrayF< 3 >computePrincipalValues(double I1, double I2, double I3);
    static void computePrincipalValDir(FloatArray &answer, FloatMatrix &dir, const FloatArray &s, stressStrainPrincMode mode);
    static std::pair< FloatArrayF< 3 >, FloatMatrixF< 3, 3 > >computePrincipalValDir(const FloatMatrixF< 3, 3 > &s);

    static FloatArrayF< 6 >computeDeviator(const FloatArrayF< 6 > &s);
    static std::pair< FloatArrayF< 6 >, double >computeDeviatoricVolumetricSplit(const FloatArrayF< 6 > &s);
    static FloatArrayF< 6 >computeDeviatoricVolumetricSum(const FloatArrayF< 6 > &dev, double mean);
 
    static FloatArrayF< 6 >applyDeviatoricElasticCompliance(const FloatArrayF< 6 > &stress, double EModulus, double nu);
    static FloatArrayF< 6 >applyDeviatoricElasticCompliance(const FloatArrayF< 6 > &stress, double GModulus);
 
    static FloatArrayF< 6 >applyDeviatoricElasticStiffness(const FloatArrayF< 6 > &strain, double EModulus, double nu);
    static FloatArrayF< 6 >applyDeviatoricElasticStiffness(const FloatArrayF< 6 > &strain, double GModulus);
 
    static FloatArrayF< 6 >applyElasticStiffness(const FloatArrayF< 6 > &strain, double EModulus, double nu);
    static FloatArrayF< 6 >applyElasticCompliance(const FloatArrayF< 6 > &stress, double EModulus, double nu);
 
    static double computeStressNorm(const FloatArrayF< 6 > &stress);
 
    static double computeFirstInvariant(const FloatArrayF< 6 > &s);
    static double computeSecondStressInvariant(const FloatArrayF< 6 > &s);
    static double computeThirdStressInvariant(const FloatArrayF< 6 > &s);
 
    static double computeFirstCoordinate(const FloatArrayF< 6 > &s);
    static double computeSecondCoordinate(const FloatArrayF< 6 > &s);
    static double computeThirdCoordinate(const FloatArrayF< 6 > &s);

    virtual FloatMatrixF< 6, 6 >give3dMaterialStiffnessMatrix(MatResponseMode mode, GaussPoint *gp, TimeStep *tStep) const
    { OOFEM_ERROR("not implemented "); }
 

    virtual void giveStiffnessMatrix_dPdF(FloatMatrix &answer,
                                          MatResponseMode mode,
                                          GaussPoint *gp,
                                          TimeStep *tStep);
 
 
 
 
    virtual FloatMatrixF< 9, 9 >give3dMaterialStiffnessMatrix_dPdF(MatResponseMode mode,
                                                                   GaussPoint *gp, TimeStep *tStep) const;
 
    virtual void give3dMaterialStiffnessMatrix_dCde(FloatMatrix &answer,
                                                    MatResponseMode mode,
                                                    GaussPoint *gp, TimeStep *tStep);

    static int giveVoigtVectorMask(IntArray &answer, MaterialMode mmode);

    static int giveVoigtSymVectorMask(IntArray &answer, MaterialMode mmode);
    static void giveInvertedVoigtVectorMask(IntArray &answer, MaterialMode mmode);

    static int giveSizeOfVoigtVector(MaterialMode mmode);
    static int giveSizeOfVoigtSymVector(MaterialMode mmode);

    static void giveFullVectorForm(FloatArray &answer, const FloatArray &strainVector,  MaterialMode matMode);
    static void giveFullVectorFormF(FloatArray &answer, const FloatArray &strainVector,  MaterialMode matMode);
    static void giveFullSymVectorForm(FloatArray &answer, const FloatArray &vec, MaterialMode matMode);
    static void giveReducedVectorForm(FloatArray &answer, const FloatArray &vec, MaterialMode matMode);
    static void giveReducedSymVectorForm(FloatArray &answer, const FloatArray &vec, MaterialMode matMode);

    static void giveFullSymMatrixForm(FloatMatrix &answer, const FloatMatrix &red, MaterialMode matMode);
    static void giveReducedMatrixForm(FloatMatrix &answer, const FloatMatrix &full, MaterialMode matMode);
    static void giveReducedSymMatrixForm(FloatMatrix &answer, const FloatMatrix &full, MaterialMode matMode);

    void giveStressDependentPartOfStrainVector(FloatArray &answer, GaussPoint *gp, const FloatArray &reducedStrainVector,
                                               TimeStep *tStep, ValueModeType mode) const;
 
    int setIPValue(const FloatArray &value, GaussPoint *gp, InternalStateType type) override;
    int giveIPValue(FloatArray &answer, GaussPoint *gp, InternalStateType type, TimeStep *tStep) override;

    virtual FloatMatrixF< 3, 3 >givePlaneStressStiffMtrx(MatResponseMode mmode, GaussPoint *gp, TimeStep *tStep) const;
    virtual FloatMatrixF< 4, 4 >givePlaneStressStiffnessMatrix_dPdF(MatResponseMode mmode, GaussPoint *gp, TimeStep *tStep) const;
 
    virtual void givePlaneStressStiffMtrx_dCde(FloatMatrix &answer,
                                               MatResponseMode mmode, GaussPoint *gp,
                                               TimeStep *tStep);

    virtual FloatMatrixF< 4, 4 >givePlaneStrainStiffMtrx(MatResponseMode mmode, GaussPoint *gp, TimeStep *tStep) const;
    virtual FloatMatrixF< 5, 5 >givePlaneStrainStiffnessMatrix_dPdF(MatResponseMode mmode, GaussPoint *gp, TimeStep *tStep) const;
 
    virtual void givePlaneStrainStiffMtrx_dCde(FloatMatrix &answer,
                                               MatResponseMode mmode, GaussPoint *gp,
                                               TimeStep *tStep);

    virtual FloatMatrixF< 1, 1 >give1dStressStiffMtrx(MatResponseMode mmode, GaussPoint *gp, TimeStep *tStep) const;
    virtual FloatMatrixF< 1, 1 >give1dStressStiffnessMatrix_dPdF(MatResponseMode mmode, GaussPoint *gp, TimeStep *tStep) const;
 
    virtual void give1dStressStiffMtrx_dCde(FloatMatrix &answer,
                                            MatResponseMode mmode, GaussPoint *gp,
                                            TimeStep *tStep);

    virtual FloatMatrixF< 2, 2 >give2dBeamLayerStiffMtrx(MatResponseMode mmode, GaussPoint *gp, TimeStep *tStep) const;
    virtual FloatMatrixF< 5, 5 >givePlateLayerStiffMtrx(MatResponseMode mmode, GaussPoint *gp, TimeStep *tStep) const;
    virtual FloatMatrixF< 3, 3 >giveFiberStiffMtrx(MatResponseMode mmode, GaussPoint *gp, TimeStep *tStep) const;

    virtual FloatMatrixF< 3, 3 >give2dPlateSubSoilStiffMtrx(MatResponseMode mmode, GaussPoint *gp, TimeStep *tStep) const;
    virtual FloatMatrixF< 6, 6 >give3dBeamSubSoilStiffMtrx(MatResponseMode mmode, GaussPoint *gp, TimeStep *tStep) const;
    static FloatArrayF< 6 >transformStrainVectorTo(const FloatMatrixF< 3, 3 > &base,
                                                   const FloatArrayF< 6 > &strain, bool transpose = false);
    static FloatArrayF< 6 >transformStressVectorTo(const FloatMatrixF< 3, 3 > &base,
                                                   const FloatArrayF< 6 > &stress, bool transpose = false);
    static double computeVonMisesStress(const FloatArray &currentStress);
    static double computeVonMisesStress_3D(const FloatArrayF< 6 > &stress);
    static double computeVonMisesStress_PlaneStress(const FloatArrayF< 3 > &stress);

    static FloatMatrixF< 6, 6 >giveStrainVectorTranformationMtrx(const FloatMatrixF< 3, 3 > &base, bool transpose = false);

    static FloatMatrixF< 3, 3 >give2DStrainVectorTranformationMtrx(const FloatMatrixF< 2, 2 > &base, bool transpose = false);

    static FloatMatrixF< 6, 6 >giveStressVectorTranformationMtrx(const FloatMatrixF< 3, 3 > &base, bool transpose = false);
    static FloatMatrixF< 3, 3 >givePlaneStressVectorTranformationMtrx(const FloatMatrixF< 2, 2 > &base, bool transpose = false);
    static void sortPrincDirAndValCloseTo(FloatArray &pVal, FloatMatrix &pDir, const FloatMatrix &toPDir);
 
    friend class CrossSection;
    friend class StructuralCrossSection;
    friend class SimpleCrossSection;
    friend class LayeredCrossSection;
};
} // end namespace oofem
#endif // structuralmaterial_h