wmapplication.h

Go to the documentation of this file.

#ifndef WMAPPLICATION_H
#define WMAPPLICATION_H
 
// Wx includes
#include "lib/wxlogstream.h"
#include "lib/wxcryptset.h"
#include "warpxm/warpxm_config.h"
 
#include "app_base.h"
 
// STD libraries
#include <iostream>
#include <vector>
#include <memory>
 
enum
{
    WMAPPLICATIONFLAG_NONE = 0,
    WMAPPLICATIONFLAG_NUMERICALFLUX = 1,
    WMAPPLICATIONFLAG_BC_NUMERICALFLUX = 2,
    WMAPPLICATIONFLAG_GRADIENT_BC = 3,
    WMAPPLICATIONFLAG_INTERNALFLUX = 4,
    WMAPPLICATIONFLAG_NUMERICALDIFFUSION = 5,
    WMAPPLICATIONFLAG_BC_NUMERICALDIFFUSION = 6,
    WMAPPLICATIONFLAG_INTERNALDIFFUSION = 7,
    WMAPPLICATIONFLAG_SOURCE = 8,
    WMAPPLICATIONFLAG_BC_XQ = 9,
    WMAPPLICATIONFLAG_BC_Q = 10,
    WMAPPLICATIONFLAG_CONSERVED_PRIMITIVE_CONVERSION = 11,
    WMAPPLICATIONFLAG_EVALUATE_FUNCTION = 12,
    WMAPPLICATIONFLAG_KINETIC_BC_Q = 13,
    // WMAPPLICATIONFLAG_BC_GRADIENT_Q
};
 
// For now putting SolverVariables_t here.  Need to really consider where it
// belongs and whether it needs to be split up
struct solverVariables_t
{
    real time;
    real x[3];
    real dx[3];
    real dxn;
    real R[3][3];
    real cfl_max;
    real eta;
    real beta;
    int faceIndex;
    int num_dims;
    bool is_on_physical_boundary;
    real beta_times_common_n_dot_n;
    real common_n[3];
    int spatial_order;
    real v[3];                   // VELOCITY SPACE FOR KINETICS
    real dv[3];                  // VELOCITY SPACE FOR KINETICSN
    int num_dims_velocity_space; // VELOCITY SPACE FOR KINETICS
    real v_norm[3];              // VELOCITY SPACE FOR KINETICS
    real k[3]; // WAVENUMBER COORDINATE FOR DIFFUSION COEFFICIENT CALCULATION
};
 
// Perhaps later SolverVariables_t will be split up into these?
typedef solverVariables_t fluxVariables_t;
typedef solverVariables_t elementGeometry_t;
typedef solverVariables_t solver_variables_t;
 
std::vector<int> map_sub_app_indices(const std::vector<int>& parent_idcs,
                                     const std::vector<int>& child_idcs);
 
void map_parent_to_sub_app(const std::vector<int>& map,
                           const real* parent_q,
                           std::vector<real>& child_q);
 
void map_sub_app_to_parent(const std::vector<int>& map,
                           real* parent_q,
                           const std::vector<real>& child_q);
 
class WmApplication : public wxm::app_base
{
public:
    typedef Application_Variable WmApplication_Variable;
 
    typedef std::map<std::string, std::string> replaceMap_t;
 
    WmApplication();
 
    virtual ~WmApplication() = default;
 
    virtual void setup(const WxCryptSet& wxc);
 
    virtual const std::vector<int>&
    getAuxiliaryVariableIndexes(int flag = WMAPPLICATIONFLAG_NONE) const
    {
        return empty;
    }
 
    virtual const std::vector<int>&
    getCrossVariableIndexes(int flag = WMAPPLICATIONFLAG_NONE) const
    {
        return empty;
    }
 
    const std::vector<std::string>& getBoundaryNames() const
    {
        return _onBoundaries;
    }
 
    bool isOnBoundary(const std::string& boundaryName) const;
    bool has(int flag) const;
 
    // required app functions
    virtual real numerical_flux(const real* q_l,
                                const real* q_r,
                                const real* aux_l,
                                const real* aux_r,
                                const solverVariables_t* pFV,
                                real* numericalFlux) const
    {
        WxExcept wxe("No Numerical Flux function defined\n");
        throw wxe;
    }
 
    virtual real internal_flux(const real* q,
                               const real* aux,
                               const solverVariables_t* pSV,
                               std::vector<std::vector<real>>& internalFlux) const
    {
        WxExcept wxe("No Internal Flux function defined\n");
        throw wxe;
    }
 
    virtual real source(const real* q,
                        const real* aux,
                        const elementGeometry_t* pEG,
                        real* source) const
    {
        WxExcept wxe("No Source function defined\n");
        throw wxe;
    }
 
    virtual void bc_q(const real* q_in,
                      const real* aux_in,
                      const real* aux_out,
                      const solverVariables_t* pFV,
                      real* q_out) const
    {
        WxExcept wxe("No BC Q function defined\n");
        throw wxe;
    }
 
    virtual real bcNumericalFlux(const real* q_l,
                                 const real* q_r,
                                 const real* aux_l,
                                 const real* aux_r,
                                 const solverVariables_t* pFV,
                                 real* numericalFlux) const
    {
        WxExcept wxe("No BC Numerical Flux function defined\n");
        throw wxe;
    }
 
    virtual void conserved_to_primitive(const real* q, const real* aux, real* w) const
    {
        WxExcept wxe("No Conserved to Primitive Function defined\n");
        throw wxe;
    }
 
    virtual void primitive_to_conserved(const real* w, const real* aux, real* q) const
    {
        WxExcept wxe("No Primitive to Conserved Function defined\n");
        throw wxe;
    }
 
    virtual void evaluate_function(const real* q,
                                   const real* aux,
                                   const solverVariables_t* pSV,
                                   real* result) const
    {
        WxExcept wxe("No Evaluate Function defined\n");
        throw wxe;
    }
 
    virtual void bc_q_kinetic(const real* q_in,
                              const real* aux_in,
                              const solverVariables_t* pFV,
                              real* q_out) const
    {
        WxExcept wxe("No BC Q Kinetic function defined\n");
        throw wxe;
    }
 
    std::shared_ptr<std::string> app_name()
    {
        return std::make_shared<std::string>(_app_name);
    }
 
protected:
    std::string _app_name;
    WxLogStream _debStrm;
    std::vector<int> _allowedFlags;
 
    std::vector<std::string> _onBoundaries;
 
private:
    WmApplication& operator=(const WmApplication& var);
    WmApplication(const WmApplication& var);
};
 
#endif