nsa-solutions.hpp

Go to the documentation of this file.

#ifndef NS_SOLUTIONS_HPP
#define NS_SOLUTIONS_HPP
 
#include <Eigen/Dense>
 
#include <mesh.hpp>
 
namespace HArDCore2D
{
  namespace NSASolutions
  {   
    //------------------------------------------------------------------------------
    // Interface for exact solutions
 
    struct IExactSolution {
      IExactSolution(std::string name, bool is_stokes, double viscosity);
      virtual ~IExactSolution();
      
      inline std::string name() const {
        return m_name;
      }
      
      inline bool isStokes() const {
        return m_is_stokes;
      }
 
      inline double viscosity() const {
        return m_viscosity;
      }
    
      virtual Eigen::Vector2d momentumForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const = 0;
      virtual double compressibilityForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const = 0;
      virtual double densityForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const = 0;
      virtual Eigen::Vector2d velocity(const Eigen::Vector2d & x, const double & t = 0) const = 0;
      virtual double pressure(const Eigen::Vector2d & x, const double & t = 0) const = 0;
      virtual Eigen::Matrix2d velocityGradient(const Eigen::Vector2d & x, const double & t = 0) const = 0;
      virtual Eigen::Vector2d pressureGradient(const Eigen::Vector2d & x, const double & t = 0) const = 0;
      virtual double volumicFraction(const Eigen::Vector2d & x, const double & t = 0) const = 0;
      //virtual Eigen::Vector2d volumicFractionGradient(const Eigen::Vector2d & x, const double t = 0) const = 0;
 
    protected:
      std::string m_name;
      bool m_is_stokes;
      double m_viscosity;
    };
  
    //------------------------------------------------------------------------------
    // Linear
 
    struct Linear : public IExactSolution {
      Linear(const int & stokes);
      
      Eigen::Vector2d momentumForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const;
      double compressibilityForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const;
      double densityForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const;
      Eigen::Vector2d velocity(const Eigen::Vector2d & x, const double & t = 0) const;   
      double pressure(const Eigen::Vector2d & x, const double & t = 0) const;
      Eigen::Matrix2d velocityGradient(const Eigen::Vector2d & x, const double & t = 0) const;    
      Eigen::Vector2d pressureGradient(const Eigen::Vector2d & x, const double & t = 0) const;
      double volumicFraction(const Eigen::Vector2d & x, const double & t = 0) const; 
      //Eigen::Vector2d volumicFractionGradient(const Eigen::Vector2d & x, const double & t = 0) const;
      
      private:
        int m_stokes;
    };
    
    //------------------------------------------------------------------------------
    // Trigonometric
 
    struct Trigonometric : public IExactSolution {
      Trigonometric(const int & stokes);
      
      Eigen::Vector2d momentumForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const;
      double compressibilityForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const;
      double densityForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const;
      Eigen::Vector2d velocity(const Eigen::Vector2d & x, const double & t = 0) const;   
      double pressure(const Eigen::Vector2d & x, const double & t = 0) const;
      Eigen::Matrix2d velocityGradient(const Eigen::Vector2d & x, const double & t = 0) const;    
      Eigen::Vector2d pressureGradient(const Eigen::Vector2d & x, const double & t = 0) const;
      double volumicFraction(const Eigen::Vector2d & x, const double & t = 0) const; 
      
      private:
        int m_stokes;
    };
    
    //------------------------------------------------------------------------------
    // Cai et al.
 
    struct CaiEtAl : public IExactSolution {
      CaiEtAl(const int & stokes);
      
      Eigen::Vector2d momentumForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const;
      double compressibilityForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const;
      double densityForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const;
      Eigen::Vector2d velocity(const Eigen::Vector2d & x, const double & t = 0) const;   
      double pressure(const Eigen::Vector2d & x, const double & t = 0) const;
      Eigen::Matrix2d velocityGradient(const Eigen::Vector2d & x, const double & t = 0) const;    
      Eigen::Vector2d pressureGradient(const Eigen::Vector2d & x, const double & t = 0) const;
      double volumicFraction(const Eigen::Vector2d & x, const double & t = 0) const; 
      
      private:
        int m_stokes;
    };
    
    //------------------------------------------------------------------------------
    // Guermond and Quartapelle
 
    struct GuermondQuartapelle : public IExactSolution {
      GuermondQuartapelle(const int & stokes);
      
      Eigen::Vector2d momentumForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const;
      double compressibilityForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const;
      double densityForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const;
      Eigen::Vector2d velocity(const Eigen::Vector2d & x, const double & t = 0) const;   
      double pressure(const Eigen::Vector2d & x, const double & t = 0) const;
      Eigen::Matrix2d velocityGradient(const Eigen::Vector2d & x, const double & t = 0) const;    
      Eigen::Vector2d pressureGradient(const Eigen::Vector2d & x, const double & t = 0) const;
      double volumicFraction(const Eigen::Vector2d & x, const double & t = 0) const; 
      
      private:
        int m_stokes;
    };
    
    //------------------------------------------------------------------------------
    // Lid-Driven Cavity
 
    struct LidDrivenCavity : public IExactSolution {
      LidDrivenCavity(const int & stokes);
      
      Eigen::Vector2d momentumForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const;
      double compressibilityForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const;
      double densityForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const;
      Eigen::Vector2d velocity(const Eigen::Vector2d & x, const double & t = 0) const;   
      double pressure(const Eigen::Vector2d & x, const double & t = 0) const;
      Eigen::Matrix2d velocityGradient(const Eigen::Vector2d & x, const double & t = 0) const;    
      Eigen::Vector2d pressureGradient(const Eigen::Vector2d & x, const double & t = 0) const;
      double volumicFraction(const Eigen::Vector2d & x, const double & t = 0) const; 
      
      private:
        int m_stokes;
    };
    
    //------------------------------------------------------------------------------
    // Rayleigh-Taylor Instabilities Test Case
 
    struct RayleighTaylor : public IExactSolution {
    static double s_L;
    
      RayleighTaylor(const double & rho_min, 
                     const double & rho_max, 
                     const double & Re, 
                     const double & L, 
                     const double & a, 
                     const double & g);
                     
     /* static inline Mesh2D::MeshBuilder::TransformationType domain_transformation = [](const std::array<double, 2> & x) {
        return std::array<double, 2>{s_L * ( x[0] - 0.5 ), s_L * (2. * x[1] - 1)};
      };*/
      
      Eigen::Vector2d momentumForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const;
      double compressibilityForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const;
      double densityForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const;
      Eigen::Vector2d velocity(const Eigen::Vector2d & x, const double & t = 0) const;   
      double pressure(const Eigen::Vector2d & x, const double & t = 0) const;
      Eigen::Matrix2d velocityGradient(const Eigen::Vector2d & x, const double & t = 0) const;    
      Eigen::Vector2d pressureGradient(const Eigen::Vector2d & x, const double & t = 0) const;
      double volumicFraction(const Eigen::Vector2d & x, const double & t = 0) const; 
      
      private:
        double m_rho_min;
        double m_rho_max;
        double m_Re;
        double m_L;
        double m_a;
        double m_g;
    };
    
    //------------------------------------------------------------------------------
    // Dam Break Test Case
 
    struct DamBreak : public IExactSolution {
    
      DamBreak(      const double & rho_min, 
                     const double & rho_max, 
                     const double & Re, 
                     const double & L, 
                     const double & H,
                     const double & g);
 
      Eigen::Vector2d momentumForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const;
      double compressibilityForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const;
      double densityForcingTerm(const Eigen::Vector2d & x, const double & t = 0) const;
      Eigen::Vector2d velocity(const Eigen::Vector2d & x, const double & t = 0) const;   
      double pressure(const Eigen::Vector2d & x, const double & t = 0) const;
      Eigen::Matrix2d velocityGradient(const Eigen::Vector2d & x, const double & t = 0) const;    
      Eigen::Vector2d pressureGradient(const Eigen::Vector2d & x, const double & t = 0) const;
      double volumicFraction(const Eigen::Vector2d & x, const double & t = 0) const; 
      
      private:
        double m_rho_min;
        double m_rho_max;
        double m_Re;
        double m_L;
        double m_H;
        double m_g;
    };
 
  } // namespace NavierStokesSolutions
 
} // namespace HArDCore2D
#endif