transportmaterial.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 transportmaterial_h
#define transportmaterial_h
 
#include "material.h"
#include "floatarray.h"
#include "floatarrayf.h"
#include "floatmatrix.h"
#include "matconst.h"
#include "matstatus.h"
#include "tm/Elements/transportelement.h"
 
namespace oofem {
class TransportMaterialStatus : public MaterialStatus
{
protected:
    double field = 0.; 
    FloatArrayF<3> gradient; 
    FloatArrayF<3> flux; 
 
    double temp_field = 0.; 
    FloatArrayF<3> temp_gradient; 
    FloatArrayF<3> temp_flux; 
 
    double maturity = 0.; 
 
public:
    TransportMaterialStatus(GaussPoint * g);
 
    void printOutputAt(FILE *file, TimeStep *tStep) const override;
 
    void initTempStatus() override;
    void updateYourself(TimeStep *tStep) override;
 
    void saveContext(DataStream &stream, ContextMode mode) override;
    void restoreContext(DataStream &stream, ContextMode mode) override;
 
    const char *giveClassName() const override { return "TransportMaterialStatus"; }

    void setTempGradient(const FloatArrayF<3> &newGradient) { temp_gradient = newGradient; }
    void setTempField(double newField) { temp_field = newField; }
    void setTempFlux(const FloatArrayF<3> &newFlux) { temp_flux = newFlux; }

    const FloatArrayF<3> &giveGradient() const { return gradient; }
    double giveField() const { return field; }
    const FloatArrayF<3> &giveFlux() const { return flux; }

    const FloatArrayF<3> &giveTempGradient() const { return temp_gradient; }
    double giveTempField() const { return temp_field; }
    const FloatArrayF<3> &giveTempFlux() const { return temp_flux; }
    double giveMaturity() const { return maturity; }
};

class HeMoTransportMaterialStatus : public MaterialStatus
{
protected:
    double temperature = 0.; 
    FloatArrayF<3> t_gradient; 
    FloatArrayF<3> t_flux; 
 
    double humidity = 0.; 
    FloatArrayF<3> h_gradient; 
    FloatArrayF<3> h_flux; 
 
    double temp_temperature = 0.; 
    FloatArrayF<3> temp_t_gradient; 
    FloatArrayF<3> temp_t_flux; 
 
    double temp_humidity = 0.; 
    FloatArrayF<3> temp_h_gradient; 
    FloatArrayF<3> temp_h_flux; 
 
public:
    HeMoTransportMaterialStatus(GaussPoint * g);
 
    void printOutputAt(FILE *file, TimeStep *tStep) const override;
 
    void initTempStatus() override;
    void updateYourself(TimeStep *tStep) override;
 
    void saveContext(DataStream &stream, ContextMode mode) override;
    void restoreContext(DataStream &stream, ContextMode mode) override;
 
    const char *giveClassName() const override { return "TransportMaterialStatus"; }

    void setTempTemperatureGradient(const FloatArrayF<3> &newGradient) { temp_t_gradient = newGradient; }
    void setTempTemperature(double newField) { temp_temperature = newField; }
    void setTempHeatFlux(const FloatArrayF<3> &newFlux) { temp_t_flux = newFlux; }

    const FloatArrayF<3> &giveTemperatureGradient() const { return t_gradient; }
    double giveTemperature() const { return temperature; }
    const FloatArrayF<3> &giveHeatFlux() const { return t_flux; }

    const FloatArrayF<3> &giveTempTemperatureGradient() const { return temp_t_gradient; }
    double giveTempTemperature() const { return temp_temperature; }
    const FloatArrayF<3> &giveTempHeatFlux() const { return temp_t_flux; }
    

    void setTempHumidityGradient(const FloatArrayF<3> &newGradient) { temp_h_gradient = newGradient; }
    void setTempHumidity(double newField) { temp_humidity = newField; }
    void setTempHumidityFlux(const FloatArrayF<3> &newFlux) { temp_h_flux = newFlux; }

    const FloatArrayF<3> &giveHumidityGradient() const { return h_gradient; }
    double giveHumidity() const { return humidity; }
    const FloatArrayF<3> &giveHumidityFlux() const { return h_flux; }

    const FloatArrayF<3> &giveTempHumidityGradient() const { return temp_h_gradient; }
    double giveTempHumidity() const { return temp_humidity; }
    const FloatArrayF<3> &giveTempHumidityFlux() const { return temp_h_flux; }
};
 

class TransportMaterial : public Material
{
public:
    TransportMaterial(int n, Domain * d) : Material(n, d) { }

    virtual void giveFluxVector(FloatArray &answer, GaussPoint *gp, const FloatArray &grad, const FloatArray &field, TimeStep *tStep) const;
    virtual FloatArrayF<3> computeFlux3D(const FloatArrayF<3> &grad, double field, GaussPoint *gp, TimeStep *tStep) const;
    FloatArrayF<2> computeFlux2D(const FloatArrayF<2> &grad, double field, GaussPoint *gp, TimeStep *tStep) const;
    FloatArrayF<1> computeFlux1D(const FloatArrayF<1> &grad, double field, GaussPoint *gp, TimeStep *tStep) const;
 
    // HeMo:
    virtual std::pair<FloatArrayF<3>, FloatArrayF<3>> computeHeMoFlux3D(const FloatArrayF<3> &grad_t, const FloatArrayF<3> &grad_w, double t, double h, GaussPoint *gp, TimeStep *tStep) const;
    std::pair<FloatArrayF<2>, FloatArrayF<2>> computeHeMoFlux2D(const FloatArrayF<2> &grad_t, const FloatArrayF<2> &grad_w, double t, double h, GaussPoint *gp, TimeStep *tStep) const;
    std::pair<FloatArrayF<1>, FloatArrayF<1>> computeHeMoFlux1D(const FloatArrayF<1> &grad_t, const FloatArrayF<1> &grad_w, double t, double h, GaussPoint *gp, TimeStep *tStep) const;
 
    //virtual FloatMatrixF<3,3> computeHeMoTangent3D(MatResponseMode mode, GaussPoint *gp, TimeStep *tStep) const;
    //virtual FloatMatrixF<2,2> computeHeMoTangent2D(MatResponseMode mode, GaussPoint *gp, TimeStep *tStep) const;
    //virtual FloatMatrixF<1,1> computeHeMoTangent1D(MatResponseMode mode, GaussPoint *gp, TimeStep *tStep) const;

    virtual void giveCharacteristicMatrix(FloatMatrix &answer,
                                          MatResponseMode mode,
                                          GaussPoint *gp,
                                          TimeStep *tStep) const override;
 
    virtual FloatMatrixF<3,3> computeTangent3D(MatResponseMode mode, GaussPoint *gp, TimeStep *tStep) const = 0;
    FloatMatrixF<2,2> computeTangent2D(MatResponseMode mode, GaussPoint *gp, TimeStep *tStep) const;
    FloatMatrixF<1,1> computeTangent1D(MatResponseMode mode, GaussPoint *gp, TimeStep *tStep) const;

    virtual double giveCharacteristicValue(MatResponseMode mode,
                                           GaussPoint *gp,
                                           TimeStep *tStep) const override = 0;

    virtual void updateInternalState(const FloatArray &state, GaussPoint *gp, TimeStep *tStep);

    virtual bool hasInternalSource() const { return false; }
    virtual void computeInternalSourceVector(FloatArray &val, GaussPoint *gp, TimeStep *tStep, ValueModeType mode) const
    { val.clear(); }

    virtual double giveHumidity(GaussPoint *gp, ValueModeType mode) const { return -1.0; }
 
    int giveIPValue(FloatArray &answer, GaussPoint *gp, InternalStateType type, TimeStep *tStep) override;
 
    std::unique_ptr<MaterialStatus> CreateStatus(GaussPoint *gp) const override { return std::make_unique<TransportMaterialStatus>(gp); }
};
} // end namespace oofem
#endif // transportmaterial_h