ndg.h

Go to the documentation of this file.

#ifndef WXM_DFEM_SPATIALSOLVER_NDG_H
#define WXM_DFEM_SPATIALSOLVER_NDG_H
 
// STL libraries
#include <algorithm>
#include <fstream>
#include <iostream>
#include <list>
#include <map>
#include <vector>
 
// Wm includes
#include "basis/wmbasisarrayset.h"
#include "dfem/spatial_solvers/spatial_solver.h"
#include "dfem/tools/tools.h"
#include "lib/geometry/unstructured_geometry/wmudggeometry.h"
 
#include "lib/wmunstructuredpatch.h"
 
class WmApplication;
 
namespace wxm
{
namespace dfem
{
namespace solver
{
namespace dg
{
// /**
//  * \addtogroup spatialsolver
//  * @{
//  */
 
// /**
//  * \addtogroup spatialsolver
//  * @{
//  */
 
class ndg_t : public wxm::dfem::solver::spatial_solver_t
{
public:
    ndg_t();
 
    void setup(const WxCryptSet& wxc) override;
 
    const std::shared_ptr<TimestepConstraint>
    solve(const real time, const variables_type& input, variables_type& output) override;
 
    const WxRange& element_interior_range() const override
    {
        return _element_flux._interior;
    }
 
    const WxRange& element_periphery_range() const override
    {
        return _element_flux._periphery;
    }
 
    const WxRange& element_full_range() const override
    {
        return _element_flux._full;
    }
 
    size_t get_num_dof() const override
    {
        return _basis_set.getNumTotalNodes();
    }
 
protected:
    void initializer_function();
    bool add_definition(const WmApplication& app, const int key);
 
    // void grad_q_approx(const WxRange& element_scope_range, const real time, const
    // std::vector<wxm::array::patch_array_t*>& input,
    // std::vector<std::vector<std::vector<real>>>);
 
    const std::shared_ptr<TimestepConstraint>
    ex_kernel(const WxRange& face_scope_range,
              const real time,
              const std::vector<wxm::array::patch_array_t*>& input);
 
    const std::shared_ptr<TimestepConstraint>
    exKernelBC(const WxRange& face_scope_range,
               const real time,
               const std::vector<wxm::array::patch_array_t*>& input);
 
    // real in_kernel(const WxRange& element_scope_range, const real time,
    //     const std::vector<wxm::array::patch_array_t*>& input,
    //     std::vector<wxm::array::patch_array_t*>& output);
 
    virtual const std::shared_ptr<TimestepConstraint>
    in_kernel(const WxRange& element_scope_range,
              const real time,
              const std::vector<wxm::array::patch_array_t*>& input);
 
    virtual void rhs_kernel(const WxRange& element_scope_range,
                            std::vector<wxm::array::patch_array_t*>& output);
 
    void print_kernel(const WxRange& element_scope_range);
 
    // void rhs_kernel_old(const WxRange& element_scope_range,
    //     std::vector<wxm::array::patch_array_t*>& output);
 
    // TODO: this is only override because zero_fluxes isn't
    // designed to take advantage of scopes yet. Need to fix in
    // ndg_t
    void zero_fluxes() override;
 
    void alloc_fluxes();
 
    // Temporal solver
    real _cfl;
    bool _test_dt;
 
    bool _sources_lgl;
    bool _sources_gq;
 
    real _penalty_beta;
    real _penalty_eta;
 
    bool _has_fluxes;
    bool _has_sources;
 
    // Spatial basis set name
    std::string _basisSetName;
 
    // Spatial basis set
    WmBasisArraySet _basis_set;
 
    // Source quadrature style
    std::string _source_quad_style;
 
    // // Log Stream
    // WxLogStream _debug_stream;
 
    // WmUDGGeometry
    std::unique_ptr<WmUDGGeometry> _dg_geometry;
 
    // Fluxes
    std::vector<std::vector<std::vector<real>>> _numerical_fluxes;
    std::vector<std::vector<std::vector<std::vector<real>>>> _internal_fluxes;
 
    // Sources
    std::vector<std::vector<std::vector<real>>> _sources;
 
    std::vector<std::vector<size_t>> app_to_rhs_idcs_num_flux;
 
    std::vector<std::vector<size_t>> app_to_rhs_idcs_int_flux;
 
    std::vector<std::vector<size_t>> app_to_rhs_idcs_source;
 
    std::vector<std::vector<size_t>> _app_to_rhs_idcs_bc_num_flux;
 
    wxm::dfem::tools::scope_t _element_flux;
    wxm::dfem::tools::scope_t _face_flux;
 
    WxRange _chunk_size_element;
    WxRange _chunk_size_face;
 
    std::vector<std::string> _numerical_flux_bc_boundaries;
 
    std::vector<int> _numerical_flux_bc_boundary_global_face_indexes;
 
private:
    ndg_t& operator=(const ndg_t& var) = delete;
 
    ndg_t(const ndg_t& var) = delete;
};
} // namespace dg
} // namespace solver
} // namespace dfem
} // namespace wxm
 
#endif