oedg_limiter.h

Go to the documentation of this file.

#pragma once
 
#include "basis/wmbasisarrayset.h"
#include "dfem/tools/tools.h"
#include "dfem/array/patch_array.h"
#include "dfem/variable_adjusters/variable_adjuster.h"
#include "lib/geometry/unstructured_geometry/wmudggeometry.h"
#include "lib/wxobject.h"
 
namespace wxm
{
namespace dfem
{
namespace variable_adjuster
{
namespace limiter
{
 
enum OEDG_WAVESPEED_ESTIMATOR_STRATEGY
{
    EULER = 0,
    IMHD = 1,
};
 
class oedg_limiter : public wxm::dfem::variable_adjuster::variable_adjuster_t,
                     public WxObject
{
public:
    oedg_limiter() = default;
 
    virtual void setup(const WxCryptSet& wxc) override;
 
    void solve(real time, variables_type& input, real dt) override;
 
    void Barrier(const WxMsgBase& msg, const real time, variables_type& input) override;
 
protected:
    void allocate();
 
    void zero();
 
    real& derivative_face_jump_sum_at(unsigned int comp_index,
                                      unsigned int face_index,
                                      unsigned int m);
 
    real element_volume(unsigned int element);
 
    // Computes dst = A * x, assuming row-major storage of NpxNp matrices.
    void matvec_Np(const real* A, real* x, real* dst);
 
    void compute_multiderivatives(unsigned int element);
 
    void store_multiderivatives_to_global_nodes(unsigned int comp_index,
                                                unsigned int element);
 
    real sum_over_face_integrals(unsigned int comp_index,
                                 unsigned int global_face_index,
                                 unsigned int m);
 
    real estimate_wavespeed_normal_to_face(unsigned int element_index,
                                           unsigned int face_index,
                                           std::vector<wxm::array::patch_array_t*> input);
 
    void
    filter_orthogonal_polynomial_modes(unsigned int comp_index,
                                       unsigned int element_index,
                                       real dt,
                                       std::vector<wxm::array::patch_array_t*> input);
 
private:
    std::string _basisSetName;
    WmBasisArraySet _basis_set;
 
    std::unique_ptr<WmUDGGeometry> _dg_geometry;
 
    unsigned int _N_dims;
 
    // The number of components being limited
    unsigned int _N_comps;
 
    // Total number of faces in the mesh
    unsigned int _N_global_faces;
 
    unsigned int _N_elements;
 
    // Faces per element
    unsigned int N_f;
 
    // Nodes per element
    unsigned int N_p;
 
    // Nodes per face
    unsigned int N_fp;
 
    // The greatest total degree of polynomials in the approximation space.
    unsigned int _N_poly_degree;
 
    unsigned int _N_multiindices;
 
    wxm::dfem::tools::scope_t _element_scope;
    wxm::dfem::tools::scope_t _limiting_scope;
    wxm::dfem::tools::scope_t _faces_scope;
 
    OEDG_WAVESPEED_ESTIMATOR_STRATEGY wavespeed_estimator_strategy;
 
    real _global_volume_sum;
    std::vector<real> _global_sums;
    std::vector<real> _global_averages;
    std::vector<real> _global_mins;
    std::vector<real> _global_maxs;
 
    real patch_global_volume_sum;
    std::vector<real> patch_global_sums;
    std::vector<real> patch_global_averages;
    std::vector<real> patch_global_mins;
    std::vector<real> patch_global_maxs;
 
    std::vector<real> _nodal_derivative_values_scratch;
 
    std::vector<real> derivative_face_values;
 
    std::vector<real> multiderivative_nodal_values;
 
    std::vector<real> derivative_face_jump_integrals;
 
    std::vector<real> derivative_face_jump_sums;
 
    std::vector<real> delta_m_Ks;
 
    std::vector<real> modes;
    std::vector<real> filtered_modes;
    std::vector<real> values;
    std::vector<real> filtered_values;
 
    real gas_gamma;
};
 
} // namespace limiter
} // namespace variable_adjuster
 
} // namespace dfem
} // namespace wxm