structuralslipfe2material.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 structuralslipfe2material_h
#define structuralslipfe2material_h
 
#include "sm/Materials/structuralmaterial.h"
#include "sm/Materials/structuralms.h"
#include "sm/Materials/structuralfe2material.h"
#include "prescribeddispsliphomogenization.h"
 
#include <memory>


#define _IFT_StructuralSlipFE2Material_Name "structslipfe2material"
#define _IFT_StructuralSlipFE2Material_useExternalStiffness "use_ext_stiffness"
#define _IFT_StructuralSlipFE2Material_allGPResults "export_all_gps"
#define _IFT_StructuralSlipFE2Material_outputSelectedResults "output_selected_el_gps"
#define _IFT_StructuralSlipFE2Material_dStressdEps "dsde"
#define _IFT_StructuralSlipFE2Material_dBStressdEps "dbsde"
#define _IFT_StructuralSlipFE2Material_dRStressdEps "drsde"
#define _IFT_StructuralSlipFE2Material_dStressdS "dsds"
#define _IFT_StructuralSlipFE2Material_dBStressdS "dbsds"
#define _IFT_StructuralSlipFE2Material_dRStressdS "drsds"
#define _IFT_StructuralSlipFE2Material_dStressdG "dsdg"
#define _IFT_StructuralSlipFE2Material_dBStressdG "dbsdg"
#define _IFT_StructuralSlipFE2Material_dRStressdG "drsdg"

 
namespace oofem {
class EngngModel;
class PrescribedGradientHomogenization;
class PrescribedDispSlipHomogenization;
 
class StructuralSlipFE2MaterialStatus : public StructuralMaterialStatus
{
protected:
    std :: unique_ptr< EngngModel > rve;
    PrescribedDispSlipHomogenization *bc = nullptr;
 
    std :: string mInputFile;
 
    int nel=1; //macroscopic element number
    int gpn=1; //gauss point number
 
    //Tangents wrt to strain, slip and slip gradient
    FloatMatrix dStressdEpsTangent, dBStressdEpsTangent, dRStressdEpsTangent;
    bool olddSdETangent = true, olddBSdETangent = true, olddRSdETangent =true;
 
    FloatMatrix dStressdSTangent, dBStressdSTangent, dRStressdSTangent;
    bool olddSdSTangent = true, olddBSdSTangent = true, olddRSdSTangent = true;
 
    FloatMatrix dStressdGTangent, dBStressdGTangent, dRStressdGTangent;
    bool olddSdGTangent = true, olddBSdGTangent = true, olddRSdGTangent = true;
 
    FloatArray slipVector;
    FloatArray bStressVector;
    FloatArray tempSlipVector;
    FloatArray tempBStressVector;
 
    FloatArray slipGradVector;
    FloatArray rStressVector;
    FloatArray tempSlipGradVector;
    FloatArray tempRStressVector;
 
public:
    StructuralSlipFE2MaterialStatus(int rank, GaussPoint * g,  const std :: string & inputfile, int el, int gp);
 
    EngngModel *giveRVE() const { return this->rve.get(); }
    PrescribedDispSlipHomogenization *giveBC();
 
    bool createRVE(const std :: string &inputfile, int rank, int el, int gp);
    void setTimeStep(TimeStep *tStep);
 
    void markOldTangent();
    void computeTangent(TimeStep *tStep);
 
    void initTempStatus() override;
 
    void updateYourself(TimeStep *tStep) override;
 
    const char *giveClassName() const override { return "StructuralSlipFE2MaterialStatus"; }

    FloatMatrix &givedStressdEpsTangent() { return dStressdEpsTangent; }
    void setdStressdEpsTangent(const FloatMatrix &iTangent) {dStressdEpsTangent = iTangent; olddSdETangent = false;}
    void setdBStressdEpsTangent(const FloatMatrix &iTangent) {dBStressdEpsTangent = iTangent; olddBSdETangent = false;}
    void setdRStressdEpsTangent(const FloatMatrix &iTangent) {dRStressdEpsTangent = iTangent; olddRSdETangent = false;}
 
    void setdStressdSTangent(const FloatMatrix &iTangent) {dStressdSTangent = iTangent; olddSdSTangent = false;}
    void setdBStressdSTangent(const FloatMatrix &iTangent) {dBStressdSTangent = iTangent; olddBSdSTangent = false;}
    void setdRStressdSTangent(const FloatMatrix &iTangent) {dRStressdSTangent = iTangent; olddRSdSTangent = false;}
 
    void setdStressdGTangent(const FloatMatrix &iTangent) {dStressdGTangent = iTangent; olddSdGTangent = false;}
    void setdBStressdGTangent(const FloatMatrix &iTangent) {dBStressdGTangent = iTangent; olddBSdGTangent = false;}
    void setdRStressdGTangent(const FloatMatrix &iTangent) {dRStressdGTangent = iTangent; olddRSdGTangent = false;}
 
    const FloatArray &giveSlipVector() const { return slipVector; }
    const FloatArray &giveTransferStressVector() const { return bStressVector; }
    const FloatArray &giveTempSlipVector() const { return tempSlipVector; }
    void letTempTransferStressVectorBe(const FloatArray &v) { tempBStressVector = v; }
    void letTempSlipVectorBe(const FloatArray &v) { tempSlipVector = v; }
 
    const FloatArray &giveSlipGradVector() const { return slipGradVector; }
    const FloatArray &giveReinfStressVector() const { return rStressVector; }
    const FloatArray &giveTempSlipGradVector() const { return tempSlipGradVector; }
    void letTempReinfStressVectorBe(const FloatArray &v) { tempRStressVector = v; }
    void letTempSlipGradVectorBe(const FloatArray &v) { tempSlipGradVector = v; }
};
 

class StructuralSlipFE2Material : public StructuralFE2Material
{
protected:
    bool useExtStiff = false;
    bool allGPRes = false;
    IntArray outputSelected;
 
    //sensitivities
    FloatMatrix givendStressdEpsTangent; //3x3 stiffness matrix (plane stress)
    FloatMatrix givendBStressdEpsTangent, givendRStressdEpsTangent;
    FloatMatrix givendStressdSTangent, givendBStressdSTangent, givendRStressdSTangent;
    FloatMatrix givendStressdGTangent, givendBStressdGTangent, givendRStressdGTangent;
 
public:
    StructuralSlipFE2Material(int n, Domain * d);
 
    void initializeFrom(InputRecord &ir) override;
    void giveInputRecord(DynamicInputRecord &input) override;
    const char *giveInputRecordName() const override { return _IFT_StructuralSlipFE2Material_Name; }
    const char *giveClassName() const override { return "StructuralSlipFE2Material"; }
 
    FloatMatrixF<3,3> givePlaneStressStiffMtrx(MatResponseMode mmode, GaussPoint *gp, TimeStep *tStep) const override;
    FloatArrayF<3> giveRealStressVector_PlaneStress(const FloatArrayF< 3 > &strain, GaussPoint *gp, TimeStep *tStep) const override;
 
    std::unique_ptr<MaterialStatus> CreateStatus(GaussPoint *gp) const override;

    virtual void giveHomogenizedFields(FloatArray &stress, FloatArray &bStress, FloatArray &rStress, const FloatArray &strain, const FloatArray &slip,
                                       const FloatArray &slipGradient, GaussPoint *gp, TimeStep *tStep);
    virtual void giveSensitivities(FloatMatrix &dStressdEps, FloatMatrix &dStressdS, FloatMatrix &dStressdG, FloatMatrix &dBStressdEps, FloatMatrix &dBStressdS,
                           FloatMatrix &dBStressdG, FloatMatrix &dRStressdEps, FloatMatrix &dRStressdS, FloatMatrix &dRStressdG, MatResponseMode mode, GaussPoint *gp, TimeStep *tStep);
 
};
 
} // end namespace oofem
#endif // structuralslipfe2material_h