MechanicsManufacturedSolutions.h

Go to the documentation of this file.

#include "AMP/utils/Database.h"
#include "AMP/utils/UtilityMacros.h"
 
#include <memory>
#include <string>
#include <vector>
 
 
namespace AMP::MechanicsManufacturedSolution {
 
class MMS
{
public:
    MMS( double YM = 0.0, double PR = 0.0 );
 
    virtual ~MMS() {}
 
    void setYoungsModulus( double YM ) { E = YM; }
 
    void setPoissonsRatio( double PR ) { nu = PR; }
 
    void scaleX( double L ) { Lx = L; }
    void scaleY( double L ) { Ly = L; }
    void scaleZ( double L ) { Lz = L; }
    void scaleXYZ( double L )
    {
        Lx = L;
        Ly = L;
        Lz = L;
    }
    void multX( double M ) { Mx = M; }
    void multY( double M ) { My = M; }
    void multZ( double M ) { Mz = M; }
    void multXYZ( double M )
    {
        Mx = M;
        My = M;
        Mz = M;
    }
 
    void set_axx( double v ) { axx = v; }
    void set_bxx( double v ) { bxx = v; }
    void set_axy( double v ) { axy = v; }
    void set_bxy( double v ) { bxy = v; }
    void set_axz( double v ) { axz = v; }
    void set_bxz( double v ) { bxz = v; }
    void set_ayx( double v ) { ayx = v; }
    void set_byx( double v ) { byx = v; }
    void set_ayy( double v ) { ayy = v; }
    void set_byy( double v ) { byy = v; }
    void set_ayz( double v ) { ayz = v; }
    void set_byz( double v ) { byz = v; }
    void set_azx( double v ) { azx = v; }
    void set_bzx( double v ) { bzx = v; }
    void set_azy( double v ) { azy = v; }
    void set_bzy( double v ) { bzy = v; }
    void set_azz( double v ) { azz = v; }
    void set_bzz( double v ) { bzz = v; }
 
    const std::string &getName() const { return name; }
 
    virtual double getExactSolutionX( double x, double y, double z ) const = 0;
    virtual double getExactSolutionY( double x, double y, double z ) const = 0;
    virtual double getExactSolutionZ( double x, double y, double z ) const = 0;
    virtual double getForcingTermX( double x, double y, double z ) const   = 0;
    virtual double getForcingTermY( double x, double y, double z ) const   = 0;
    virtual double getForcingTermZ( double x, double y, double z ) const   = 0;
    // I deactivated this because there was no need for it so far but I can provide these on request
    // virtual std::vector<double> getGradientX(double x, double y, double z) const = 0;
    // virtual std::vector<double> getGradientY(double x, double y, double z) const = 0;
    // virtual std::vector<double> getGradientZ(double x, double y, double z) const = 0;
    // virtual std::vector<double> getStrainTensor(double x, double y, double z) const = 0;
 
    virtual std::vector<double> getStressTensor( double x, double y, double z ) const = 0;
 
    std::vector<double> getExactSolutions( double x, double y, double z ) const
    {
        std::vector<double> ExactSolutions;
        ExactSolutions.push_back( getExactSolutionX( x, y, z ) );
        ExactSolutions.push_back( getExactSolutionY( x, y, z ) );
        ExactSolutions.push_back( getExactSolutionZ( x, y, z ) );
        return ExactSolutions;
    }
    std::vector<double> getForcingTerms( double x, double y, double z ) const
    {
        std::vector<double> ForcingTerms;
        ForcingTerms.push_back( getForcingTermX( x, y, z ) );
        ForcingTerms.push_back( getForcingTermY( x, y, z ) );
        ForcingTerms.push_back( getForcingTermZ( x, y, z ) );
        return ForcingTerms;
    }
    std::vector<double> getExactSolutions( const std::vector<double> &xyz ) const
    {
        return getExactSolutions( xyz[0], xyz[1], xyz[2] );
    }
    std::vector<double> getForcingTerms( const std::vector<double> &xyz ) const
    {
        return getForcingTerms( xyz[0], xyz[1], xyz[2] );
    }
    double getExactSolutionX( const std::vector<double> &xyz ) const
    {
        AMP_ASSERT( xyz.size() != 3 );
        return getExactSolutionX( xyz[0], xyz[1], xyz[2] );
    }
    double getExactSolutionY( const std::vector<double> &xyz ) const
    {
        AMP_ASSERT( xyz.size() != 3 );
        return getExactSolutionY( xyz[0], xyz[1], xyz[2] );
    }
    double getExactSolutionZ( const std::vector<double> &xyz ) const
    {
        AMP_ASSERT( xyz.size() != 3 );
        return getExactSolutionZ( xyz[0], xyz[1], xyz[2] );
    }
    double getForcingTermX( const std::vector<double> &xyz ) const
    {
        AMP_ASSERT( xyz.size() != 3 );
        return getForcingTermX( xyz[0], xyz[1], xyz[2] );
    }
    double getForcingTermY( const std::vector<double> &xyz ) const
    {
        AMP_ASSERT( xyz.size() != 3 );
        return getForcingTermY( xyz[0], xyz[1], xyz[2] );
    }
    double getForcingTermZ( const std::vector<double> &xyz ) const
    {
        AMP_ASSERT( xyz.size() != 3 );
        return getForcingTermZ( xyz[0], xyz[1], xyz[2] );
    }
    // std::vector<double> getGradientX(const std::vector<double>& xyz) const {
    // AMP_ASSERT(xyz.size()!=3); return
    // getGradientX(xyz[0], xyz[1], xyz[2]); }
    // std::vector<double> getGradientY(const std::vector<double>& xyz) const {
    // AMP_ASSERT(xyz.size()!=3); return
    // getGradientY(xyz[0], xyz[1], xyz[2]); }
    // std::vector<double> getGradientZ(const std::vector<double>& xyz) const {
    // AMP_ASSERT(xyz.size()!=3); return
    // getGradientZ(xyz[0], xyz[1], xyz[2]); }
    // std::vector<double> getStrainTensor(const std::vector<double>& xyz) const {
    // AMP_ASSERT(xyz.size()!=3); return
    // getStrainTensor(xyz[0], xyz[1], xyz[2]); }
    std::vector<double> getStressTensor( const std::vector<double> &xyz ) const
    {
        AMP_ASSERT( xyz.size() != 3 );
        return getStressTensor( xyz[0], xyz[1], xyz[2] );
    }
 
protected:
    double E;          
    double nu;         
    double Lx, Ly, Lz; 
    double Mx, My, Mz; 
    double axx, bxx, axy, bxy, axz, bxz;
    double ayx, byx, ayy, byy, ayz, byz;
    double azx, bzx, azy, bzy, azz, bzz;
    std::string name; 
};                    // end class MMS
 
 
class MMSLinear : public MMS
{
public:
    MMSLinear( double E = 0.0, double nu = 0.0 ) : MMS( E, nu ) { name = "Linear"; }
    double getExactSolutionX( double x, double y, double z ) const override;
    double getExactSolutionY( double x, double y, double z ) const override;
    double getExactSolutionZ( double x, double y, double z ) const override;
    double getForcingTermX( double /* x */, double y, double z ) const override;
    double getForcingTermY( double x, double /* y */, double z ) const override;
    double getForcingTermZ( double x, double y, double /* z */ ) const override;
    std::vector<double> getStressTensor( double x, double y, double z ) const override;
}; // end class MMSLinear
 
 
class MMSTrigonometric : public MMS
{
public:
    MMSTrigonometric( double E = 0.0, double nu = 0.0 ) : MMS( E, nu ) { name = "Trigonometric"; }
    double getExactSolutionX( double x, double y, double z ) const override;
    double getExactSolutionY( double /* x */, double y, double z ) const override;
    double getExactSolutionZ( double /* x */, double y, double z ) const override;
    double getForcingTermX( double x, double y, double z ) const override;
    double getForcingTermY( double x, double y, double z ) const override;
    double getForcingTermZ( double x, double y, double z ) const override;
    std::vector<double> getStressTensor( double x, double y, double z ) const override;
}; // end class MMSTrigonometric
 
 
class MMSBuilder
{
public:
    MMSBuilder() {}
 
    static std::shared_ptr<MMS> createMMS( std::shared_ptr<AMP::Database> mmsDatabase );
}; // end class MMSBuilder
 
 
} // namespace AMP::MechanicsManufacturedSolution