RadiationDiffusionModel.h

Go to the documentation of this file.

#ifndef RAD_DIF_MODEL
#define RAD_DIF_MODEL
 
#include "AMP/mesh/Mesh.h"
#include "AMP/mesh/MeshElement.h"
#include "AMP/operators/radiationDiffusionFD/RadiationDiffusionFDDiscretization.h"
#include "AMP/utils/Constants.h"
#include "AMP/utils/Database.h"
 
namespace AMP::Operator {
 
#define PI AMP::Constants::pi
 
class RadDifModel
{
 
public:
    static constexpr bool IsNonlinear = AMP::Operator::RadDifCoefficients::IsNonlinear;
 
    RadDifModel( std::shared_ptr<AMP::Database> basic_db_,
                 std::shared_ptr<AMP::Database> mspecific_db_ );
 
    virtual ~RadDifModel(){};
 
    double getCurrentTime() const;
 
    void setCurrentTime( double currentTime_ );
 
    virtual double sourceTerm( size_t component, const AMP::Mesh::Point &point ) const = 0;
 
    virtual double initialCondition( size_t component, const AMP::Mesh::Point &point ) const = 0;
 
    virtual double exactSolution( size_t component, const AMP::Mesh::Point &point ) const;
 
    std::shared_ptr<AMP::Database> getRadiationDiffusionFD_input_db() const;
 
    bool exactSolutionAvailable() const;
 
    // Data
protected:
    double d_k11 = 0;
    double d_k12 = 0;
    double d_k21 = 0;
    double d_k22 = 0;
 
    std::array<double, 6> d_ak{ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
    std::array<double, 6> d_bk{ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
 
    double d_zatom = 1.0;
 
    double d_currentTime = 0.0;
 
    size_t d_dim = (size_t) -1;
 
    std::shared_ptr<AMP::Database> d_basic_db;
 
    std::shared_ptr<AMP::Database> d_mspecific_db;
 
    std::shared_ptr<AMP::Database> d_RadiationDiffusionFD_input_db = nullptr;
 
    bool d_RadiationDiffusionFD_input_db_completed = false;
 
    bool d_exactSolutionAvailable = false;
 
    // Methods
protected:
    /* Convert specific model parameters into parameters expected by the general formulation */
    virtual void finalizeGeneralPDEModel_db() = 0;
 
    void setMemberPDEConstants();
 
    double diffusionCoefficientE( double T, double zatom ) const;
};
 
 
/* -----------------------------------------------------------------------------------------------
    Class representing certain Radiation diffusion equations considered by Mousseau et al. (2000)
------------------------------------------------------------------------------------------------ */
class Mousseau_etal_2000_RadDifModel final : public RadDifModel
{
 
    //
public:
    Mousseau_etal_2000_RadDifModel( std::shared_ptr<AMP::Database> basic_db_,
                                    std::shared_ptr<AMP::Database> mspecific_db_ );
 
    virtual ~Mousseau_etal_2000_RadDifModel(){};
 
    double sourceTerm( size_t component, const AMP::Mesh::Point &point ) const override;
 
    double initialCondition( size_t component, const AMP::Mesh::Point &point ) const override;
 
    //
private:
    void finalizeGeneralPDEModel_db() override;
};
 
 
/* ------------------------------------------------------------------
    Class representing a manufactured radiation diffusion equation
------------------------------------------------------------------ */
class Manufactured_RadDifModel final : public RadDifModel
{
 
private:
    // Constants that the maufactured solutions depends on.
    constexpr static double kE0   = 2.0;
    constexpr static double kT    = 1.7;
    constexpr static double kX    = 1.5;
    constexpr static double kXPhi = 0.245;
    constexpr static double kY    = 3.5;
    constexpr static double kYPhi = 0.784;
    constexpr static double kZ    = 2.5;
    constexpr static double kZPhi = 0.154;
 
    //
public:
    Manufactured_RadDifModel( std::shared_ptr<AMP::Database> basic_db_,
                              std::shared_ptr<AMP::Database> specific_db_ );
 
    virtual ~Manufactured_RadDifModel(){};
 
    double sourceTerm( size_t component, const AMP::Mesh::Point &point ) const override;
 
    double initialCondition( size_t component, const AMP::Mesh::Point &point ) const override;
 
    double exactSolution( size_t component, const AMP::Mesh::Point &point ) const override;
 
    double getBoundaryFunctionValueE( size_t boundaryID, const AMP::Mesh::Point &point ) const;
 
    double getBoundaryFunctionValueT( size_t boundaryID, const AMP::Mesh::Point &point ) const;
 
    //
private:
    // Flag used inside exactSolution_ functions to determine whether to use the currentTime or 0.0
    // when evaluating the function. This is a bit hacky, but allows for initialCondition to be a
    // const function (without requiring currentTime to be mutable).
    mutable bool d_settingInitialCondition = false;
 
    void finalizeGeneralPDEModel_db() override;
 
    void getNormalVector( size_t boundaryID, size_t &normalComponent, double &normalSign ) const;
 
    double exactSolutionGradient( size_t component,
                                  const AMP::Mesh::Point &point,
                                  size_t gradComponent ) const;
 
    // Exact solution, its gradient and corresponding source term
    double exactSolution1D( size_t component, double x ) const;
    double exactSolutionGradient1D( size_t component, double x ) const;
    double sourceTerm1D( size_t component, double x ) const;
    //
    double exactSolution2D( size_t component, double x, double y ) const;
    double
    exactSolutionGradient2D( size_t component, double x, double y, size_t gradComponent ) const;
    double sourceTerm2D( size_t component, double x, double y ) const;
    //
    double exactSolution3D( size_t component, double x, double y, double z ) const;
    double exactSolutionGradient3D(
        size_t component, double x, double y, double z, size_t gradComponent ) const;
    double sourceTerm3D( size_t component, double x, double y, double z ) const;
};
 
 
} // namespace AMP::Operator
 
#endif