ndg_kinetic.h

Go to the documentation of this file.

#ifndef dfem_spatial_solver_ndg_kinetic_h
#define dfem_spatial_solver_ndg_kinetic_h
 
// WARPXM includes
#include "dfem/spatial_solvers/spatial_solver.h"
#include "dfem/tools/tools.h"
#include "ndg.h" // for req_buffer_size
#include "lib/geometry/phase_space_geometry/phase_space_dg_geometry.h"
#include "lib/geometry/phase_space_element/phase_space_element.h"
 
namespace wxm
{
namespace dfem
{
namespace solver
{
namespace dg
{
 
class NDGKinetic : public wxm::dfem::solver::spatial_solver_t
{
public:
    NDGKinetic();
 
    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;
    }
 
protected:
    size_t get_num_dof() const override
    {
        size_t dof =
            _phase_space_dg_geometry->getPhaseSpaceBasisArraySet()->getNumTotalNodes();
        for (int dim = 0; dim < _phase_space_dg_geometry->getVspaceNdims(); dim++)
        {
            dof *= _phase_space_dg_geometry->getVspaceNelems()[dim];
        }
 
        return dof;
    }
 
    void zero_fluxes() override;
 
 
 
    const std::shared_ptr<TimestepConstraint>
    calcElementInternalFluxCSRFormat(
        const std::vector<wxm::array::patch_array_t*>& input,
        const int physical_element_index,
        const int velocity_space_element_indexes[3],
        const std::vector<std::vector<real>>& J_inv_lm,
        solverVariables_t* element_pSV, // not const!
        std::vector<std::vector<real>>& internal_flux_ij,
        std::vector<std::vector<real>>& allocation,
        std::vector<real>& theta_ilk,
        std::vector<real>& F_mik,
        std::vector<real>& q,
        std::vector<real>& aux) const;
    
    // real calcElementInternalFlux(const std::vector<wxm::array::patch_array_t*>& input,
    //                              const int physical_element_index,
    //                              const int velocity_space_element_indexes[3],
    //                              const std::vector<real>& A_jkm,
    //                              solverVariables_t* element_pSV, // not const!
    //                              std::vector<std::vector<real>>& internal_flux_ij,
    //                              std::vector<std::vector<real>>& allocation,
    //                              std::vector<std::vector<real>>& F_mi,
    //                              std::vector<real>& q,
    //                              std::vector<real>& aux) const;
 
    const std::shared_ptr<TimestepConstraint>
    calcElementSourceTerm(const std::vector<wxm::array::patch_array_t*>& input,
                               const int physical_element_index,
                               const int velocity_space_element_indexes[3],
                               solverVariables_t* element_pSV, // not const!
                               std::vector<std::vector<real>>& source_term_ij,
                               std::vector<real>& source_allocation,
                               std::vector<real>& q,
                               std::vector<real>& aux) const;
 
    const std::shared_ptr<TimestepConstraint>
    calcElementNumericalFluxCSRFormat(
        const std::vector<wxm::array::patch_array_t*>& input,
        const int physical_element_index,
        const int velocity_space_element_indexes[3],
        const std::vector<std::vector<real>>& inverse_jacobian_phase_space,
        solverVariables_t* face_pSV, // not const!
        std::vector<std::vector<real>>& numerical_flux_ij,
        std::vector<real>& allocation,
        std::vector<real>& F_ik,
        std::vector<real>& q_in,
        std::vector<real>& q_out,
        std::vector<real>& aux_in,
        std::vector<real>& aux_out,
        std::vector<real>& a) const;
    
    // real calcElementNumericalFlux(
    //     const std::vector<wxm::array::patch_array_t*>& input,
    //     const int physical_element_index,
    //     const int velocity_space_element_indexes[3],
    //     const std::vector<std::vector<real>>& inverse_jacobian_phase_space,
    //     solverVariables_t* face_pSV, // not const!
    //     std::vector<std::vector<real>>& numerical_flux_ij,
    //     std::vector<real>& allocation,
    //     std::vector<real>& F_i,
    //     std::vector<real>& q_in,
    //     std::vector<real>& q_out,
    //     std::vector<real>& aux_in,
    //     std::vector<real>& aux_out,
    //     std::vector<real>& a) const;
 
private:
    // Temporal solver
    real _cfl;
    
    // flux booleans
    bool _has_fluxes;
    bool _has_sources;
    
    // penalty eta and beta
    real _penalty_eta;
    real _penalty_beta;
 
 
    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;
 
    wxm::dfem::tools::scope_t _element_flux;
 
    // velocity space range
    std::unique_ptr<WxRange> _velocity_space_element_range;
    std::unique_ptr<WxRange> _velocity_space_interior_element_range;
 
    // Phase space geometry
    std::shared_ptr<geometry::phase_space::PhaseSpaceDGGeometry> _phase_space_dg_geometry;
 
    // phase space element type
    std::unique_ptr<geometry::phase_space_element::PhaseSpaceElement>
        _phase_space_element;
 
    NDGKinetic& operator=(const NDGKinetic& var) = delete;
 
    NDGKinetic(const NDGKinetic& var) = delete;
};
} // namespace dg
} // namespace solver
} // namespace dfem
} // namespace wxm
 
#endif