TestCase.hpp

Go to the documentation of this file.

// Class to provide various test cases (diffusion, exact solution, and their derivatives)
//
//
// Author: Jerome Droniou (jerome.droniou@monash.edu)
//
 
/*
*
*   This library was developed around HHO methods, although some parts of it have a more
* general purpose. If you use this code or part of it in a scientific publication, 
* please mention the following book as a reference for the underlying principles
* of HHO schemes:
*
* The Hybrid High-Order Method for Polytopal Meshes: Design, Analysis, and Applications.
* D. A. Di Pietro and J. Droniou. 2019, 516p. 
* url: https://hal.archives-ouvertes.fr/hal-02151813.
*
*/
 
#ifndef _TEST_CASE_HPP
#define _TEST_CASE_HPP
 
#include "basis.hpp"
 
//namespace HArDCore2D
//{ // Forward declaration
//class Cell;
//}
 
using namespace HArDCore2D;
 
// @addtogroup TestCases
 
// Types
template <typename T>
using CellFType = std::function<T(const VectorRd &, const Cell *)>; 
 
struct Solution
  {
    // Constructor
    Solution(
      const FType<double> value,       
      const CellFType<VectorRd> gradient,  
      const CellFType<MatrixRd> hessian    
    )
    : value(value),
      gradient(gradient),
      hessian(hessian)
    {
      // Do nothing
    }
    
    // Members
    const FType<double> value;
    const CellFType<VectorRd> gradient;
    const CellFType<MatrixRd> hessian;
  };
 
struct Diffusion
  {
    // Constructor
    Diffusion(
      const CellFType<MatrixRd> value,       
      const CellFType<VectorRd> divergence,  
      const size_t degree                    
    )
    : value(value),
      divergence(divergence),
      degree(degree)
    {
      // Do nothing
    }
    
    // Members
    const CellFType<MatrixRd> value;
    const CellFType<VectorRd> divergence;
    const size_t degree;
  };
 
struct Advection
  {
    // Constructor
    Advection(
      const CellFType<VectorRd> value,      
      const CellFType<double> divergence,   
      const bool is_zero,          
      const bool is_divergence_zero,        
      const bool is_divergence_constant    
    )
    : value(value),
      divergence(divergence),
      is_zero(is_zero),
      is_divergence_zero(is_divergence_zero),
      is_divergence_constant(is_divergence_constant)
    {
      // Do nothing
    }
    
    // Default constructor
    Advection()
      : value([](const VectorRd x, const Cell *cell) -> VectorRd { return VectorRd::Zero();}),
        divergence([](const VectorRd x, const Cell *cell) -> double { return 0;}),
        is_zero(true),
        is_divergence_zero(true),
        is_divergence_constant(true)
    {
      // Do nothing
    }
    
    // Members
    CellFType<VectorRd> value;
    CellFType<double> divergence;
    bool is_zero;
    bool is_divergence_zero;
    bool is_divergence_constant;
  };
 
struct Reaction
  {
    // Constructor
    Reaction(
      const CellFType<double> value,   
      const bool is_zero,                
      const bool is_constant             
    )
    : value(value),
      is_zero(is_zero),
      is_constant(is_constant)
    {
      // Do nothing
    }
    
    // Default constructor
    Reaction()
      : value([](const VectorRd x, const Cell *cell) -> double { return 0.;}),
        is_zero(true),
        is_constant(true)
    {
      // Do nothing
    }
    
    // Members
    CellFType<double> value;
    bool is_zero;
    bool is_constant;
  };
  
// ----------------------------------------------------------------------------
//                            Class definition
// ----------------------------------------------------------------------------
 
class TestCase
{
 
public:
     TestCase(
         std::vector<int> iTC 
     );
 
     inline Solution get_solution();
 
     inline Diffusion get_diffusion();
 
     inline Advection get_advection();
 
     inline Reaction get_reaction();
 
     CellFType<double> diff_source();
 
     CellFType<double> diff_advec_reac_source();
 
     inline double get_lambda();
 
     void validate();
 
 
 
private:
     // Parameters: id of test case, pi
     std::vector<int> m_iTC;
     const double pi = acos(-1);
     const double sqrt2 = std::pow(2, 0.5);
     const double eps = 1e-5; // constant for rotating diffusion case
 
     // Generic parameter (e.g. for changing anisotropy etc.)
     double _lambda;
     
     // Advection, reaction, etc and functions to create them
     Solution m_sol;
     Diffusion m_diff;
     Advection m_advec;
     Reaction m_reac;
 
     Solution create_solution(const size_t n);
     Diffusion create_diffusion(const size_t n);
     Advection create_advection(const size_t n);
     Reaction create_reaction(const size_t n);
 
};
 
inline double TestCase::get_lambda() { return _lambda; };
inline Solution TestCase::get_solution() { return m_sol; };
inline Diffusion TestCase::get_diffusion() { return m_diff; };
inline Advection TestCase::get_advection() { return m_advec; };
inline Reaction TestCase::get_reaction() { return m_reac; };
 
 
#endif //_TEST_CASE_HPP