river_data_observer.h

Go to the documentation of this file.

 
#ifndef UG4_RIVER_DATA_OBSERVER_H
#define UG4_RIVER_DATA_OBSERVER_H
 
#include <fstream>
#include "lib_disc/time_disc/time_integrator_observers/time_integrator_observer_interface.h"
#include "common/common.h"
#include "integrate_river_outflow.h"
 
namespace ug {
namespace d3f {
 
template<class TDomain, class TAlgebra>
class OutflowIntegrationObserver : public ITimeIntegratorObserver<TDomain, TAlgebra> {
public:
    static const int dim = TDomain::dim;
    typedef ITimeIntegratorObserver<TDomain, TAlgebra> base_type;
    typedef GridFunction<TDomain, TAlgebra>            grid_function_type;
    typedef CplUserData<MathVector<dim>, dim>          TVectorData;
    typedef CplUserData<number, dim>                   TNumberData;
 
    OutflowIntegrationObserver(SmartPtr<TVectorData> velocity, 
                               SmartPtr<TNumberData> area, 
                               const char* subset = "Sink", 
                               const char* inner_subset = "River") 
        : m_value(0.0), subset_name(subset), inner_subset_name(inner_subset),
          m_vel(velocity), m_A(area) {}
 
    virtual ~OutflowIntegrationObserver() = default;
 
    bool step_process(SmartPtr<grid_function_type> uNew, int step, number time, number dt) override {
        // We multiply by 1000 assuming a water density of 1000 kg/m^3 to get mass if IntegrateRiverOutflow returns m^3/s
        m_value += 1000.0 * dt * IntegrateRiverOutflow<grid_function_type>(m_vel, m_A, uNew, subset_name, inner_subset_name, 1);
        return true;
    }
 
    number value() const { return m_value; }
 
    void reset_value() { m_value = 0.0; }
 
protected:
    number          m_value;
    const char*     subset_name;
    const char*     inner_subset_name;
    SmartPtr<TVectorData> m_vel;
    SmartPtr<TNumberData> m_A;
};
 
template<class TDomain, class TAlgebra>
class TimestepObserver : public ITimeIntegratorObserver<TDomain, TAlgebra> {
public:
    static const int dim = TDomain::dim;
    typedef ITimeIntegratorObserver<TDomain, TAlgebra> base_type;
    typedef GridFunction<TDomain, TAlgebra>            grid_function_type;
 
    explicit TimestepObserver(const char* filename) : m_filename(filename) {
#ifdef UG_PARALLEL
        if (pcl::ProcRank() == 0) 
#endif
        {
            m_file.open(m_filename, std::ios::out | std::ios::trunc);
            if (m_file.is_open()) {
                m_file << "time\tdt\n";
                m_file.flush();
            } else {
                UG_THROW("TimestepObserver: Could not open file '" << m_filename << "' for writing.");
            }
        }
    }
 
    virtual ~TimestepObserver() {
        if (m_file.is_open()) m_file.close();
    }
 
    bool step_process(SmartPtr<grid_function_type> uNew, int step, number time, number dt) override {
        if (
            #ifdef UG_PARALLEL
            pcl::ProcRank() == 0 && 
            #endif
        m_file.is_open()) {
            m_file << time << "\t" << dt << "\n";
            m_file.flush(); 
        }
        m_last_dt = dt;
        return true;
    }
 
    number get_last_timestep() const { return m_last_dt; }
 
protected:
    number        m_last_dt = 0.0;
    std::ofstream m_file;
    const char*   m_filename;
};
 
} // namespace d3f
} // namespace ug
 
#endif // UG4_RIVER_DATA_OBSERVER_H