river_observer.h

Go to the documentation of this file.

 
#ifndef D3F_UG4_RIVER_OBSERVER_H
#define D3F_UG4_RIVER_OBSERVER_H
 
#include <lib_disc/function_spaces/grid_function.h>
#include "common/common.h"
#include "add_river_sss.h"
#include "st_venant_submodule/st_venant_submodule.h"
#include <lib_disc/time_disc/time_integrator_observers/time_integrator_observer_interface.h>
 
namespace ug {
namespace d3f {
 
template <typename TDomain, typename TAlgebra>
class RiverObserver :
    public ITimeIntegratorObserver<TDomain, TAlgebra>,
    public ITimeIntegratorStageObserver_finalize<TDomain, TAlgebra> 
{
public:
    typedef ITimeIntegratorObserver<TDomain, TAlgebra>      TBase;
    typedef GridFunction<TDomain, TAlgebra>                 grid_function_type;
    typedef SmartPtr<StVenantSubmodule<grid_function_type>> TSubModule;
    typedef SmartPtr<RiverSSSManager<TDomain, TAlgebra>>    TRiverSSSMngr;
    typedef RiverSingularSourcesAndSinks<TDomain::dim>      TSSSManager;
    static const int dim = TDomain::dim;
 
    RiverObserver(const char* filename, SmartPtr<grid_function_type> u) {
        m_sp_submodule = make_sp(new StVenantSubmodule<grid_function_type>());
        m_sp_submodule->init(filename);
 
        m_sp_sss_mngr = make_sp(new RiverSSSManager<TDomain, TAlgebra>(
            m_sp_submodule->get_grid_function(),
            u
        ));
    }
 
    virtual ~RiverObserver() = default;
 
    void set_density(SmartPtr<CplUserData<number, dim>> density) { m_sp_sss_mngr->set_density(density); }
    void set_rainfall_rate(number qr) { m_sp_submodule->set_qr(make_sp(new ConstUserNumber<dim>(qr))); }
    void set_bottom_permeability(number perm) { m_sp_sss_mngr->set_bottom_permeability(perm); }
    void set_bottom_thickness(number thickness) { m_sp_sss_mngr->set_bottom_thickness(thickness); }
    void set_river_width(number width) { m_sp_sss_mngr->set_river_width(width); }
 
    void push_sss_manager(SmartPtr<TSSSManager> ssmngr) {
        m_sp_sss_mngr->push_sss_manager(ssmngr);
    }
 
    void init() {
        m_sp_sss_mngr->init_line_sss();
        m_sp_submodule->run(0.0, 1e6, 0.1);
    }
 
    bool step_process(SmartPtr<grid_function_type> u, int step, number time, number dt) override {
        return solve_submodule(u, time, dt, "STEP PROCESS");
    }
 
    bool finalize_action(SmartPtr<grid_function_type> u, int step, number time, number dt) override {
        return solve_submodule(u, time, dt, "FINALIZE STEP");
    }
 
    SmartPtr<grid_function_type> get_river_u() {
        return m_sp_submodule->get_grid_function();
    }
 
private:
    bool solve_submodule(SmartPtr<grid_function_type> u, number time, number dt, const char* context) {
        // 1. Evaluate current exchange flux based on subsurface state (u)
        m_sp_sss_mngr->evaluate_exchange_flux(u);
        
        UG_LOG("RIVEROBSERVER: " << context << " | time: " << time << " | dt: " << dt << "\n");
        
        // 2. Pass flux to 1D river submodule and run it
        m_sp_submodule->set_exfiltration_flux(m_sp_sss_mngr->get_qex());
        m_sp_submodule->run(time - dt, time, 1.0);
 
        // 3. Update the singular sources for the next subsurface step
        m_sp_sss_mngr->update_line_sss(dt);
 
        return true;
    }
 
    TSubModule m_sp_submodule;
    TRiverSSSMngr m_sp_sss_mngr;
};
 
} // namespace d3f
} // namespace ug
 
#endif // D3F_UG4_RIVER_OBSERVER_H