st_venant_submodule.h

Go to the documentation of this file.

 
#ifndef ST_D3F_VENANT_SUBMODULE_H
#define ST_D3F_VENANT_SUBMODULE_H
 
#include "st_venant_elem_disc.h"
#include "../i_coupling_bridge.h"
#include "lib_disc/function_spaces/approximation_space.h"
 
namespace ug {
namespace d3f {
 
template<int dim>
struct StVenantParameters {
    StVenantParameters() {
        b                = make_sp(new ConstUserNumber<dim>(1.0));    
        gravity          = 9.81;                                      
        diffusion        = 1e-2;                                      
        ks               = make_sp(new ConstUserNumber<dim>(1.0e-3)); 
        qr               = make_sp(new ConstUserNumber<dim>(1.0e-6)); 
        dirichlet_A      = 1e-8;                                      
        dirichlet_v      = 1.0;                                       
        interface_subset = "top";                                     
        river_subset     = "River";                                   
    }
 
    typedef SmartPtr<CplUserData<number, dim>>            TSPNumberData;
    typedef SmartPtr<CplUserData<MathVector<dim>, dim>>   TSPVectorData;
 
    TSPNumberData b;                
    number        gravity;          
    number        diffusion;        
    TSPNumberData ks;               
    TSPNumberData qr;               
    number        dirichlet_A;      
    number        dirichlet_v;      
    std::string   interface_subset; 
    std::string   river_subset;     
};
 
template<typename TGridFunction, int dim = TGridFunction::dim>
class StVenantSubmodule : public ISubmodule<TGridFunction, dim> {
public:
    typedef typename TGridFunction::domain_type   domain_type;
    typedef StVenantElemDisc<domain_type>         elem_disc_type;
    typedef typename TGridFunction::algebra_type  algebra_type;
    typedef ApproximationSpace<domain_type>       approx_space_type;
    typedef StVenantElemDiscFactory<domain_type>  factory_type;
    typedef SmartPtr<CplUserData<number, dim>>    TSPNumberData;
 
    StVenantSubmodule() = default;
    virtual ~StVenantSubmodule() = default;
 
    void run(number tStart, number tEnd, number dt) override;
 
    void init(const char* filename);
 
    void set_exfiltration_flux(TSPNumberData qex) { m_qex = qex; }
 
    void set_dirichlet(number A, number v) { params.dirichlet_v = v; params.dirichlet_A = A; }
    void set_tolerance(number tol)         { m_tol = tol; }
    void interpolate_A(number A)           { Interpolate(A, this->m_u, "A"); }
    void interpolate_v(number v)           { Interpolate(v, this->m_u, "v"); }
    void set_qr(TSPNumberData qr)          { params.qr = qr; }
    void set_width(TSPNumberData b)        { params.b = b; }
    void set_ks(TSPNumberData ks)          { params.ks = ks; }
    void set_diffusion(number d)           { params.diffusion = d; }
    
    void set_parameters(StVenantParameters<dim> p) { params = p; }
 
    void set_plot(bool p) { m_plot = p; }
 
    SmartPtr<TGridFunction> get_grid_function() { return this->m_u; }
 
    StVenantParameters<dim> params; 
 
private:
    // --- Discretization & Geometry ---
    SmartPtr<domain_type>       m_domain;
    SmartPtr<approx_space_type> m_approx_space;
    // Note: m_u is inherited from ISubmodule
    
    SmartPtr<elem_disc_type>    m_elem_disc_A;
    SmartPtr<elem_disc_type>    m_elem_disc_v;
 
    // --- Data & State ---
    TSPNumberData m_qex = make_sp(new ConstUserNumber<dim>(0.0)); 
    bool          m_plot = false;                                 
    number        m_tol  = 0.01;                                  
    int           m_step = 0;                                     
};
 
} // namespace d3f
} // namespace ug
 
#include "st_venant_submodule_impl.h"
 
#endif // ST_D3F_VENANT_SUBMODULE_H