convection_diffusion_settings.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ \.
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Riccardo Rossi
//                   Pablo Becker
//
 
#if !defined(KRATOS_CONVECTION_DIFFUSION_SETTINGS_INCLUDED )
#define  KRATOS_CONVECTION_DIFFUSION_SETTINGS_INCLUDED
 
// System includes
#include <string>
#include <iostream>
 
// External includes
 
// Project includes
#include "containers/variable.h"
#include "includes/define.h"
 
namespace Kratos {
 
 
 
 
 
 
 
class KRATOS_API(KRATOS_CORE) ConvectionDiffusionSettings
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(ConvectionDiffusionSettings);
 
 
    ConvectionDiffusionSettings() = default;
 
    ConvectionDiffusionSettings(const ConvectionDiffusionSettings& rOther):
        mpDensityVar(rOther.mpDensityVar),
        mpDiffusionVar(rOther.mpDiffusionVar),
        mpUnknownVar(rOther.mpUnknownVar),
        mpVolumeSourceVar(rOther.mpVolumeSourceVar),
        mpSurfaceSourceVar(rOther.mpSurfaceSourceVar),
        mpProjectionVar(rOther. mpProjectionVar),
        mpConvectionVar(rOther.mpConvectionVar),
        mpGradientVar(rOther.mpGradientVar),
        mpMeshVelocityVar(rOther.mpMeshVelocityVar),
        mpTransferCoefficientVar(rOther.mpTransferCoefficientVar),
        mpVelocityVar(rOther.mpVelocityVar),
        mpSpecificHeatVar(rOther.mpSpecificHeatVar),
        mpReactionVar(rOther.mpReactionVar),
        mpReactionGradientVar(rOther.mpReactionGradientVar),
        mis_defined_DensityVar(rOther.mis_defined_DensityVar),
        mis_defined_DiffusionVar(rOther.mis_defined_DiffusionVar),
        mis_defined_UnknownVar(rOther.mis_defined_UnknownVar),
        mis_defined_VolumeSourceVar(rOther.mis_defined_VolumeSourceVar),
        mis_defined_SurfaceSourceVar(rOther.mis_defined_SurfaceSourceVar),
        mis_defined_ProjectionVar(rOther.mis_defined_ProjectionVar),
        mis_defined_ConvectionVar(rOther.mis_defined_ConvectionVar),
        mis_defined_GradientVar(rOther.mis_defined_GradientVar),
        mis_defined_MeshVelocityVar(rOther.mis_defined_MeshVelocityVar),
        mis_defined_TransferCoefficientVar(rOther.mis_defined_TransferCoefficientVar),
        mis_defined_VelocityVar(rOther.mis_defined_VelocityVar),
        mis_defined_SpecificHeatVar(rOther.mis_defined_SpecificHeatVar),
        mis_defined_ReactionVar(rOther.mis_defined_ReactionVar),
        mIsDefinedReactionGradientVar(rOther.mIsDefinedReactionGradientVar)
    {
    }
 
    virtual ~ConvectionDiffusionSettings() {};
 
    void SetDensityVariable(const Variable<double>& rvar)
    {
        mpDensityVar = &rvar;
        mis_defined_DensityVar=true;
    }
    const Variable<double>& GetDensityVariable() const
    {
        return *mpDensityVar;
    }
    bool IsDefinedDensityVariable() const
    {
        return mpDensityVar != nullptr;
    }
 
    void SetDiffusionVariable(const Variable<double>& rvar)
    {
        mpDiffusionVar = &rvar;
        mis_defined_DiffusionVar=true;
    }
    const Variable<double>& GetDiffusionVariable() const
    {
        return *mpDiffusionVar;
    }
    bool IsDefinedDiffusionVariable() const
    {
        return mpDiffusionVar != nullptr;
    }
 
    void SetUnknownVariable(const Variable<double>& rvar)
    {
        mpUnknownVar = &rvar;
        mis_defined_UnknownVar=true;
    }
    const Variable<double>& GetUnknownVariable() const
    {
        return *mpUnknownVar;
    }
    bool IsDefinedUnknownVariable() const
    {
        return mpUnknownVar != nullptr;
    }
 
    void SetVolumeSourceVariable(const Variable<double>& rvar)
    {
        mpVolumeSourceVar = &rvar;
        mis_defined_VolumeSourceVar=true;
    }
    const Variable<double>& GetVolumeSourceVariable() const
    {
        return *mpVolumeSourceVar;
    }
    bool IsDefinedVolumeSourceVariable() const
    {
        return mpVolumeSourceVar != nullptr;
    }
 
    void SetSurfaceSourceVariable(const Variable<double>& rvar)
    {
        mpSurfaceSourceVar = &rvar;
        mis_defined_SurfaceSourceVar=true;
    }
    const Variable<double>& GetSurfaceSourceVariable() const
    {
        return *mpSurfaceSourceVar;
    }
    bool IsDefinedSurfaceSourceVariable() const
    {
        return mpSurfaceSourceVar != nullptr;
    }
 
    void SetProjectionVariable(const Variable<double>& rvar)
    {
        mpProjectionVar = &rvar;
        mis_defined_ProjectionVar=true;
    }
    const Variable<double>& GetProjectionVariable() const
    {
        return *mpProjectionVar;
    }
    bool IsDefinedProjectionVariable() const
    {
        return mpProjectionVar != nullptr;
    }
 
    void SetConvectionVariable(const Variable<array_1d<double,3> >& rvar)
    {
        mpConvectionVar = &rvar;
        mis_defined_ConvectionVar=true;
    }
    const Variable<array_1d<double,3> >& GetConvectionVariable() const
    {
        return *mpConvectionVar;
    }
    bool IsDefinedConvectionVariable() const
    {
        return mpConvectionVar != nullptr;
    }
 
    void SetGradientVariable(const Variable<array_1d<double,3> >& rvar)
    {
        mpGradientVar = &rvar;
        mis_defined_GradientVar=true;
    }
    const Variable<array_1d<double,3> >& GetGradientVariable() const
    {
        return *mpGradientVar;
    }
    bool IsDefinedGradientVariable() const
    {
        return mpGradientVar != nullptr;
    }
 
    void SetMeshVelocityVariable(const Variable<array_1d<double,3> >& rvar)
    {
        mpMeshVelocityVar = &rvar;
        mis_defined_MeshVelocityVar=true;
    }
    const Variable<array_1d<double,3> >& GetMeshVelocityVariable() const
    {
        return *mpMeshVelocityVar;
    }
    bool IsDefinedMeshVelocityVariable() const
    {
        return mpMeshVelocityVar != nullptr;
    }
 
    void SetTransferCoefficientVariable(const Variable<double>& rvar)
    {
        mpTransferCoefficientVar = &rvar;
        mis_defined_TransferCoefficientVar=true;
    }
    const Variable<double>& GetTransferCoefficientVariable() const
    {
        return *mpTransferCoefficientVar;
    }
    bool IsDefinedTransferCoefficientVariable() const
    {
        return mpTransferCoefficientVar != nullptr;
    }
 
    void SetVelocityVariable(const Variable<array_1d<double,3> >& rvar)
    {
        mpVelocityVar = &rvar;
        mis_defined_VelocityVar=true;
    }
    const Variable<array_1d<double,3> >& GetVelocityVariable() const
    {
        return *mpVelocityVar;
    }
    bool IsDefinedVelocityVariable() const
    {
        return mpVelocityVar != nullptr;
    }
 
    void SetSpecificHeatVariable(const Variable<double>& rvar)
    {
        mpSpecificHeatVar = &rvar;
        mis_defined_SpecificHeatVar=true;
    }
    const Variable<double>& GetSpecificHeatVariable() const
    {
        return *mpSpecificHeatVar;
    }
    bool IsDefinedSpecificHeatVariable() const
    {
        return mpSpecificHeatVar != nullptr;
    }
 
    void SetReactionVariable(const Variable<double>& rvar)
    {
        mpReactionVar = &rvar;
        mis_defined_ReactionVar=true;
    }
    const Variable<double>& GetReactionVariable() const
    {
        return *mpReactionVar;
    }
    bool IsDefinedReactionVariable() const
    {
        return mpReactionVar != nullptr;
    }
 
    void SetReactionGradientVariable(const Variable<array_1d<double,3>>& rVar)
    {
        mpReactionGradientVar = &rVar;
        mIsDefinedReactionGradientVar=true;
    }
    const Variable<array_1d<double,3>>& GetReactionGradientVariable() const
    {
        return *mpReactionGradientVar;
    }
    bool IsDefinedReactionGradientVariable() const
    {
        return mpReactionGradientVar != nullptr;
    }
 
 
 
    ConvectionDiffusionSettings& operator=(ConvectionDiffusionSettings const& rOther)
    {
        mpDensityVar = rOther.mpDensityVar;
        mpDiffusionVar = rOther.mpDiffusionVar;
        mpUnknownVar = rOther.mpUnknownVar;
        mpVolumeSourceVar = rOther.mpVolumeSourceVar;
        mpSurfaceSourceVar = rOther.mpSurfaceSourceVar;
        mpProjectionVar = rOther.mpProjectionVar;
        mpConvectionVar = rOther.mpConvectionVar;
        mpGradientVar = rOther.mpGradientVar;
        mpMeshVelocityVar = rOther.mpMeshVelocityVar;
        mpTransferCoefficientVar = rOther.mpTransferCoefficientVar;
        mpVelocityVar = rOther.mpVelocityVar;
        mpSpecificHeatVar = rOther.mpSpecificHeatVar;
        mpReactionVar = rOther.mpReactionVar;
        mpReactionGradientVar = rOther.mpReactionGradientVar;
        //now the is_defined
        mis_defined_DensityVar = rOther.mis_defined_DensityVar;
        mis_defined_DiffusionVar = rOther.mis_defined_DiffusionVar;
        mis_defined_UnknownVar = rOther.mis_defined_UnknownVar;
        mis_defined_VolumeSourceVar = rOther.mis_defined_VolumeSourceVar;
        mis_defined_SurfaceSourceVar = rOther.mis_defined_SurfaceSourceVar;
        mis_defined_ProjectionVar = rOther.mis_defined_ProjectionVar;
        mis_defined_ConvectionVar = rOther.mis_defined_ConvectionVar;
        mis_defined_GradientVar = rOther.mis_defined_GradientVar;
        mis_defined_MeshVelocityVar = rOther.mis_defined_MeshVelocityVar;
        mis_defined_TransferCoefficientVar = rOther.mis_defined_TransferCoefficientVar;
        mis_defined_VelocityVar = rOther.mis_defined_VelocityVar;
        mis_defined_SpecificHeatVar = rOther.mis_defined_SpecificHeatVar;
        mis_defined_ReactionVar = rOther.mis_defined_ReactionVar;
        mIsDefinedReactionGradientVar = rOther.mIsDefinedReactionGradientVar;
 
        return *this;
    }
 
 
 
 
 
    virtual std::string Info() const
    {
        std::stringstream buffer;
        buffer << "ConvectionDiffusionSettings #" ;
        return buffer.str();
    }
 
    virtual void PrintInfo(std::ostream& rOStream) const
    {
        rOStream << "ConvectionDiffusionSettings #";
    }
 
    virtual void PrintData(std::ostream& rOStream) const
    {
    }
 
 
 
 
 
protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
 
 
    const Variable<double>* mpDensityVar = nullptr;
    const Variable<double>* mpDiffusionVar = nullptr;
    const Variable<double>* mpUnknownVar = nullptr;
    const Variable<double>* mpVolumeSourceVar = nullptr;
    const Variable<double>* mpSurfaceSourceVar = nullptr;
    const Variable<double>* mpProjectionVar = nullptr;
    const Variable<array_1d<double,3> >* mpConvectionVar = nullptr;
    const Variable<array_1d<double,3> >* mpGradientVar = nullptr;
    const Variable<array_1d<double,3> >* mpMeshVelocityVar = nullptr;
    const Variable<double>* mpTransferCoefficientVar = nullptr;
    const Variable<array_1d<double,3> >* mpVelocityVar = nullptr;
    const Variable<double>* mpSpecificHeatVar = nullptr;
    const Variable<double>* mpReactionVar = nullptr;
    const Variable<array_1d<double,3>>* mpReactionGradientVar = nullptr;
    bool mis_defined_DensityVar = false;
    bool mis_defined_DiffusionVar = false;
    bool mis_defined_UnknownVar = false;
    bool mis_defined_VolumeSourceVar = false;
    bool mis_defined_SurfaceSourceVar = false;
    bool mis_defined_ProjectionVar = false;
    bool mis_defined_ConvectionVar = false;
    bool mis_defined_GradientVar = false;
    bool mis_defined_MeshVelocityVar = false;
    bool mis_defined_TransferCoefficientVar = false;
    bool mis_defined_VelocityVar = false;
    bool mis_defined_SpecificHeatVar = false;
    bool mis_defined_ReactionVar = false;
    bool mIsDefinedReactionGradientVar = false;
 
 
 
    friend class Serializer;
 
 
    virtual void save(Serializer& rSerializer) const;
 
    virtual void load(Serializer& rSerializer);
 
 
 
 
 
 
 
 
 
 
 
 
 
}; // Class ConvectionDiffusionSettings
 
 
 
 
 
 
inline std::istream& operator >> (std::istream& rIStream,
                                  ConvectionDiffusionSettings& rThis)
{
    return rIStream;
}
 
inline std::ostream& operator << (std::ostream& rOStream,
                                  const ConvectionDiffusionSettings& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
#undef  KRATOS_EXPORT_MACRO
#define KRATOS_EXPORT_MACRO KRATOS_API
 
KRATOS_DEFINE_VARIABLE(ConvectionDiffusionSettings::Pointer, CONVECTION_DIFFUSION_SETTINGS)
 
#undef  KRATOS_EXPORT_MACRO
#define KRATOS_EXPORT_MACRO KRATOS_NO_EXPORT
 
}  // namespace Kratos.
 
#endif // KRATOS_CONVECTION_DIFFUSION_SETTINGS_INCLUDED  defined