diff --git a/cmf/cmf_core_src/atmosphere/Weather.h b/cmf/cmf_core_src/atmosphere/Weather.h index f29a1f57..7d9571b8 100644 --- a/cmf/cmf_core_src/atmosphere/Weather.h +++ b/cmf/cmf_core_src/atmosphere/Weather.h @@ -58,7 +58,7 @@ namespace cmf { - If sub daily: \f$ R_a = \frac{12\ 24\ 60}{\pi}G_{sc}\ d_r \left(\left(\omega^+ -\omega^-\right) \sin\phi \sin\delta + \cos\phi \cos\delta \left(\sin\omega^+ - \sin\omega^-\right)\right) \f$ - \f$ \omega^+,\omega^- = \omega \pm\frac{\pi}{24} \f$ **/ - double extraterrestrial_radiation(cmf::math::Time t, double longitude=8, double latitude=51, double time_zone=1, bool daily=false); + double extraterrestrial_radiation(cmf::math::Time t, double longitude=8, double latitude=51, double time_zone=1, bool daily=0); /// /** @brief Calculates the global radiation in MJ/(m2 day) from the sun position and the sunshine fraction diff --git a/cmf/cmf_core_src/atmosphere/meteorology.cpp b/cmf/cmf_core_src/atmosphere/meteorology.cpp index a1352cbb..9988593c 100644 --- a/cmf/cmf_core_src/atmosphere/meteorology.cpp +++ b/cmf/cmf_core_src/atmosphere/meteorology.cpp @@ -22,7 +22,6 @@ #include "../math/num_array.h" #include "../upslope/cell.h" #include "../project.h" -#include "Weather.h" #include #define min(a,get_b) ((a)<(get_b)) ? (a) : (get_b) #define max(a,get_b) ((a)>(get_b)) ? (a) : (get_b) @@ -33,7 +32,7 @@ using namespace cmf::math; using namespace cmf::geometry; -cmf::atmosphere::Weather cmf::atmosphere::MeteoStation::get_data( cmf::math::Time t,double height ) const +cmf::atmosphere::Weather cmf::atmosphere::MeteoStation::get_data( cmf::math::Time t, double height ) const { Weather A; if (Tmax.is_empty()) @@ -71,7 +70,7 @@ cmf::atmosphere::Weather cmf::atmosphere::MeteoStation::get_data( cmf::math::Tim else // no humidity data available, assume Tmin=Tdew A.e_a=vapour_pressure(A.Tmin); A.sunshine=Sunshine.is_empty() ? 0.5 : Sunshine[t]; - A.Ra = cmf::atmosphere::extraterrestrial_radiation(t, Longitude, Latitude, Timezone, daily); + A.Ra = extraterrestrial_radiation(t, Longitude, Latitude, Timezone, daily); if (Rs.is_empty()) A.Rs=global_radiation(A.Ra, height, A.sunshine); else diff --git a/cmf/cmf_core_src/cmf.i b/cmf/cmf_core_src/cmf.i index 5f94154c..697eb8da 100644 --- a/cmf/cmf_core_src/cmf.i +++ b/cmf/cmf_core_src/cmf.i @@ -1,132 +1,141 @@ -// Copyright 2010 by Philipp Kraft -// This file is part of cmf. -// -// cmf is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// cmf is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with cmf. If not, see . -// -// Get Documentation - -%feature("compactdefaultargs"); -%include "docstrings.i" -%feature("autodoc","1"); - -// Usage for automated downcast -%include "factory.i" - -// Include typemaps for STL -%include "std_string.i" - -// enable exception support -%include "exception.i" -%exception { - try { - $action - } catch (const std::out_of_range& e) { - SWIG_exception(SWIG_IndexError, e.what()); - } catch (const std::exception& e) { - SWIG_exception(SWIG_RuntimeError, e.what()); - } - -} -%include "attribute.i" - -/* #define SWIG_SHARED_PTR_SUBNAMESPACE */ -%include -%{ - #include "cmfmemory.h" -%} -%include "cmf_swiglib.i" - -%{ -std::string pyrepr(PyObject* o) { - PyObject* s = PyObject_Repr(o); - #if PY_MAJOR_VERSION < 3 - std::string res = PyString_AsString(s); - #else - std::string res = PyUnicode_AsUTF8(s); - #endif - Py_XDECREF(s); - return res; -} -%} - -// Start my Module -%module cmf_core -%include "math/num_array.i" -%include "geometry/geometry.i" -%include "math/time.i" -%include "math/ODEsystem.i" -%include "water/water.i" -%include "atmosphere/meteorology.i" -%include "upslope/cell.i" -%include "upslope/Layer.i" -%include "reach/Reach.i" - -/////////////////////////// -// Surfacewater -////////////////////////// - -%shared_ptr(cmf::upslope::SurfaceWater); -%attribute(cmf::upslope::SurfaceWater,real,puddledepth,get_puddledepth,set_puddledepth); -%attribute(cmf::upslope::SurfaceWater,real,nManning,get_nManning,set_nManning); - -%include "upslope/surfacewater.h" -%extend__repr__(cmf::upslope::SurfaceWater) - -///////////////////////////// -%{ - #include "upslope/groundwater.h" - #include "upslope/connections/subsurfacefluxes.h" - #include "upslope/connections/surfacefluxes.h" - #include "upslope/connections/AtmosphericFluxes.h" - #include "upslope/connections/infiltration.h" - #include "upslope/connections/Percolation.h" - #include "upslope/vegetation/ET.h" - #include "upslope/vegetation/ShuttleworthWallace.h" - // Include river model - #include "reach/ManningConnection.h" -%} - -%shared_ptr(cmf::upslope::aquifer); -%attribute(cmf::upslope::aquifer,double,base_height,get_base_height); -%attribute(cmf::upslope::aquifer,double,top_height,get_top_height); -%include "upslope/groundwater.h" -%extend__repr__(cmf::upslope::aquifer) - -%include "upslope/connections/subsurfacefluxes.h" -%include "reach/ManningConnection.h" - -%include "upslope/connections/surfacefluxes.h" -%include "upslope/connections/AtmosphericFluxes.h" -%include "upslope/connections/infiltration.h" -%include "upslope/connections/Percolation.h" -%include "upslope/vegetation/waterstress.h" - -%include "upslope/vegetation/ET.h" - -%shared_ptr(cmf::upslope::ET::ShuttleworthWallace); -%include "upslope/vegetation/ShuttleworthWallace.h" - -%include "project.i" - -%include "math/integrator.i" - - -%pythoncode { - ConstantFlux = TechnicalFlux - ConstantStateFlux = statecontrol_connection - WaterBalanceFlux = waterbalance_connection - ConceptualInfiltration = SimpleInfiltration -} - - +// Copyright 2010 by Philipp Kraft +// This file is part of cmf. +// +// cmf is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// cmf is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with cmf. If not, see . +// +// Get Documentation + +%feature("compactdefaultargs"); +%include "docstrings.i" +%feature("autodoc","1"); + +// Usage for automated downcast +%include "factory.i" + +// Include typemaps for STL +%include "std_string.i" +%include "std_vector.i" + +namespace std { + %template(vector_int) vector; + %template(vector_double) vector; + %template(vector_size_t) vector; +}; + +// enable exception support +%include "exception.i" +%exception { + try { + $action + } catch (const std::out_of_range& e) { + SWIG_exception(SWIG_IndexError, e.what()); + } catch (const std::exception& e) { + SWIG_exception(SWIG_RuntimeError, e.what()); + } + +} +%include "attribute.i" + +/* #define SWIG_SHARED_PTR_SUBNAMESPACE */ +%include +%{ + #include "cmfmemory.h" +%} +%include "cmf_swiglib.i" + +%{ +std::string pyrepr(PyObject* o) { + PyObject* s = PyObject_Repr(o); + #if PY_MAJOR_VERSION < 3 + std::string res = PyString_AsString(s); + #else + std::string res = PyUnicode_AsUTF8(s); + #endif + Py_XDECREF(s); + return res; +} +%} + +// Start my Module +%module cmf_core +%include "math/num_array.i" +%include "geometry/geometry.i" +%include "math/time.i" + +%include "math/ODEsystem.i" + +%include "water/water.i" +%include "atmosphere/meteorology.i" +%include "upslope/cell.i" +%include "upslope/Layer.i" +%include "reach/Reach.i" + +/////////////////////////// +// Surfacewater +////////////////////////// + +%shared_ptr(cmf::upslope::SurfaceWater); +%attribute(cmf::upslope::SurfaceWater,real,puddledepth,get_puddledepth,set_puddledepth); +%attribute(cmf::upslope::SurfaceWater,real,nManning,get_nManning,set_nManning); + +%include "upslope/surfacewater.h" +%extend__repr__(cmf::upslope::SurfaceWater) + +///////////////////////////// +%{ + #include "upslope/groundwater.h" + #include "upslope/connections/subsurfacefluxes.h" + #include "upslope/connections/surfacefluxes.h" + #include "upslope/connections/AtmosphericFluxes.h" + #include "upslope/connections/infiltration.h" + #include "upslope/connections/Percolation.h" + #include "upslope/vegetation/ET.h" + #include "upslope/vegetation/ShuttleworthWallace.h" + // Include river model + #include "reach/ManningConnection.h" +%} + +%shared_ptr(cmf::upslope::aquifer); +%attribute(cmf::upslope::aquifer,double,base_height,get_base_height); +%attribute(cmf::upslope::aquifer,double,top_height,get_top_height); +%include "upslope/groundwater.h" +%extend__repr__(cmf::upslope::aquifer) + +%include "upslope/connections/subsurfacefluxes.h" +%include "reach/ManningConnection.h" + +%include "upslope/connections/surfacefluxes.h" +%include "upslope/connections/AtmosphericFluxes.h" +%include "upslope/connections/infiltration.h" +%include "upslope/connections/Percolation.h" +%include "upslope/vegetation/waterstress.h" + +%include "upslope/vegetation/ET.h" + +%shared_ptr(cmf::upslope::ET::ShuttleworthWallace); +%include "upslope/vegetation/ShuttleworthWallace.h" + +%include "project.i" + +%include "math/integrator.i" + + +%pythoncode { + ConstantFlux = TechnicalFlux + ConstantStateFlux = statecontrol_connection + WaterBalanceFlux = waterbalance_connection + ConceptualInfiltration = SimpleInfiltration +} + + diff --git a/cmf/cmf_core_src/docstrings.i b/cmf/cmf_core_src/docstrings.i index 6ee101d9..824d614a 100644 --- a/cmf/cmf_core_src/docstrings.i +++ b/cmf/cmf_core_src/docstrings.i @@ -1,28 +1,44 @@ // File: index.xml -// File: struct___dls_mat.xml -%feature("docstring") _DlsMat ""; +// File: classcmf__core_1_1_adsorption.xml +%feature("docstring") cmf_core::Adsorption " +Abstract class to use adsorption process for tracers on surfaces. Use +the derived classes to use a certain isotherm C++ includes: +adsorption.h "; -// File: struct__generic___n___vector.xml -%feature("docstring") _generic_N_Vector ""; +%feature("docstring") cmf_core::Adsorption::__init__ "def +__init__(self, args, kwargs) "; +%feature("docstring") cmf_core::Adsorption::copy "def copy(self, +args, kwargs) -// File: struct__generic___n___vector___ops.xml -%feature("docstring") _generic_N_Vector_Ops ""; - - -// File: struct___n___vector_content___parallel.xml -%feature("docstring") _N_VectorContent_Parallel ""; +copy(Adsorption self, real m=-1) -> Adsorption virtual Adsorption* +copy(real m=-1) const =0 returns a copy of the Adsorption object. If +the adsorption is depending on the sorbent mass, you can give a +positive value for the sorbent mass m. If the value is not given or +negative, m is used from the original object. "; +%feature("docstring") cmf_core::Adsorption::freesolute "def +freesolute(self, args, kwargs) -// File: struct___n___vector_content___serial.xml -%feature("docstring") _N_VectorContent_Serial ""; +freesolute(Adsorption self, real xt, real V) -> real virtual real +freesolute(real xt, real V) const =0 Returns the mass of dissolved +tracer as a function of the total tracer mass in the solute storage +and the water volume. Parameters: ----------- xt: :math:`x_t` the +total tracer mass in the storage V: :math:`V m^3` the water volume +in the storage :math:`x_f` the dissolved mass of the tracer "; +%feature("docstring") cmf_core::Adsorption::totalsolute "def +totalsolute(self, args, kwargs) -// File: struct___spgmr_mem_rec.xml -%feature("docstring") _SpgmrMemRec ""; +totalsolute(Adsorption self, real xf, real V) -> real virtual real +totalsolute(real xf, real V) const =0 Returns the total mass of the +tracer from the dissolved concetration in tracer unit/m3. Parameters: +----------- xf: :math:`x_f` the dissolved tracer mass in the +storage V: :math:`V m^3` the water volume in the storage +:math:`x_t` the total mass of the tracer "; // File: classcmf_1_1water_1_1_adsorption.xml @@ -96,6 +112,26 @@ aerodynamic resistance from ground to atmosphere (r_ag) and from canopy to atmosphere (r_ac) "; +// File: classcmf__core_1_1aerodynamic__resistance.xml +%feature("docstring") cmf_core::aerodynamic_resistance " + +Abstract class. Child classes can be used to calculate aerodynamic +resistances against turbulent heat fluxes. C++ includes: +meteorology.h "; + +%feature("docstring") cmf_core::aerodynamic_resistance::__init__ "def __init__(self, args, kwargs) "; + +%feature("docstring") +cmf_core::aerodynamic_resistance::get_aerodynamic_resistance "def +get_aerodynamic_resistance(self, args, kwargs) + +get_aerodynamic_resistance(aerodynamic_resistance self, double & r_ag, +double & r_ac, Time t) virtual void get_aerodynamic_resistance(double +&r_ag, double &r_ac, cmf::math::Time t) const =0 aerodynamic +resistance from ground to atmosphere (r_ag) and from canopy to +atmosphere (r_ac) "; + + // File: classcmf_1_1draw_1_1cellmap_1_1_animator.xml %feature("docstring") cmf::draw::cellmap::Animator ""; @@ -113,6 +149,218 @@ __call__(self, args, kwargs) "; draw(self, frame=None) "; +// File: classcmf__core_1_1aquifer.xml +%feature("docstring") cmf_core::aquifer " + +A class to represent large groundwater storages, not bounded to the +usual horizontal discretization scheme, the Cell. Naturally aquifers +are connected with aquifer_Darcy or kinematic_wave connections. As a +boundary condition for a cell based soil water system, aquifers are +used as a right hand side node of percolation connections. Basic head +( :math:`\\\\\\\\Psi`) / volume ( :math:`V`) relation: .. math:: +\\\\\\\\Psi = z_{base} + \\\\\\\\frac {V}{A \\\\\\\\Phi} +:math:`\\\\\\\\Psi` water head in m :math:`z_{base}` base height of +the aquifer :math:`V` volume of stored water in m3 :math:`A` Base +area of the aquifer in m2 :math:`\\\\\\\\Phi` Porosity, or more +general, :math:`\\\\\\\\frac{dV_{bulk}}{dV_{H_2O}}` C++ includes: +groundwater.h "; + +%feature("docstring") cmf_core::aquifer::__init__ "def +__init__(self, args) + +__init__(cmf::upslope::aquifer self, project p, point position, real +area, real thickness, real porosity, real K=1e-4) -> aquifer +__init__(cmf::upslope::aquifer self, cell_vector cells, real +thickness, real porosity, real K=1e-4) -> aquifer +aquifer(cmf::upslope::cell_vector &cells, real thickness, real +porosity, real K=1e-4) Creates an aquifer below a collection of +cells. Parameters: ----------- cells: The cells above the aquifer. +The area of the aquifer equals the area of the cells, and the upper +boundary equals the soildepth of the lowest cell thickness: The +thickness of the aquifer in m porosity: Porosity of the aquifer K: +Conductivity of the aquifer in m/day. If the conductivity should be +anisotropic, change the x,y and z values of the member K "; + +%feature("docstring") cmf_core::aquifer::__call__ "def +__call__(self, args, kwargs) + +__call__(flux_node self, Time t) -> real "; + +%feature("docstring") cmf_core::aquifer::__eq__ "def __eq__(self, +args, kwargs) + +__eq__(flux_node self, flux_node other) -> bool "; + +%feature("docstring") cmf_core::aquifer::__getitem__ "def +__getitem__(self, args, kwargs) + +__getitem__(WaterStorage self, solute X) -> SoluteStorage "; + +%feature("docstring") cmf_core::aquifer::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::aquifer::cast "def cast(args, +kwargs) + +cast(cmf::water::flux_node::ptr for_cast) -> +cmf::upslope::aquifer::ptr "; + +%feature("docstring") cmf_core::aquifer::conc "def conc(self, args, +kwargs) + +conc(flux_node self, Time t, solute Solute) -> real virtual real +conc(cmf::math::Time t, const cmf::water::solute &Solute) const +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; + +%feature("docstring") cmf_core::aquifer::conc "def conc(self, args) + +conc(WaterStorage self, solute _Solute) -> real conc(WaterStorage +self, Time t, solute _Solute) -> real conc(WaterStorage self, solute +_Solute, real NewConcetration) void conc(const cmf::water::solute +&_Solute, real NewConcetration) Sets a new concentration. "; + +%feature("docstring") cmf_core::aquifer::connected_nodes "def +connected_nodes(self) "; + +%feature("docstring") cmf_core::aquifer::connection_to "def +connection_to(self, args, kwargs) + +connection_to(flux_node self, flux_node target) -> flux_connection +cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) Returns the connection between this and target. "; + +%feature("docstring") cmf_core::aquifer::create "def create(args, +kwargs) + +create(project _project, real initial_state=0.0, real scale=1.0) -> +std::shared_ptr< cmf::water::WaterStorage > "; + +%feature("docstring") cmf_core::aquifer::dxdt "def dxdt(self, args, +kwargs) + +dxdt(StateVariable self, Time time) -> real virtual real dxdt(const +cmf::math::Time &time)=0 Returns the derivate of the state variable +at time time. "; + +%feature("docstring") cmf_core::aquifer::flux3d_to "def +flux3d_to(self, args, kwargs) + +flux3d_to(flux_node self, flux_node target, Time t) -> point +cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; + +%feature("docstring") cmf_core::aquifer::flux_to "def flux_to(self, +args, kwargs) + +flux_to(flux_node self, flux_node target, Time t) -> real real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; + +%feature("docstring") cmf_core::aquifer::fluxes "def fluxes(self, t) +"; + +%feature("docstring") cmf_core::aquifer::from_node "def +from_node(args, kwargs) + +from_node(cmf::water::flux_node::ptr node) -> std::shared_ptr< +cmf::water::WaterStorage > "; + +%feature("docstring") cmf_core::aquifer::get_3d_flux "def +get_3d_flux(self, args, kwargs) + +get_3d_flux(flux_node self, Time t) -> point cmf::geometry::point +get_3d_flux(cmf::math::Time t) Returns the sum of all flux vectors. +"; + +%feature("docstring") cmf_core::aquifer::get_abs_errtol "def +get_abs_errtol(self, args, kwargs) + +get_abs_errtol(aquifer self, real rel_errtol) -> real virtual real +get_abs_errtol(real rel_errtol) const "; + +%feature("docstring") cmf_core::aquifer::get_K "def get_K(self, +args, kwargs) + +get_K(aquifer self, point direction) -> real virtual real +get_K(cmf::geometry::point direction) const Returns the conductivity +in m/day for a specific direction. Takes account for anisotropy .. +math:: \\\\\\\\|K\\\\\\\\|(d) = +\\\\\\\\frac{d}{\\\\\\\\|d\\\\\\\\|} \\\\\\\\bullet K "; + +%feature("docstring") cmf_core::aquifer::get_states "def +get_states(self, args, kwargs) + +get_states(StateVariableOwner self) -> StateVariableList virtual +StateVariableList get_states()=0 Add the state variables, owned by an +object derived from StateVariableOwner, to the given vector. "; + +%feature("docstring") cmf_core::aquifer::is_connected "def +is_connected(self, args, kwargs) + +is_connected(StateVariable self, StateVariable other) -> bool virtual +bool is_connected(const cmf::math::StateVariable &other) const "; + +%feature("docstring") cmf_core::aquifer::is_empty "def +is_empty(self, args, kwargs) + +is_empty(flux_node self) -> double virtual double is_empty() const +Returns true if the node has no water. "; + +%feature("docstring") cmf_core::aquifer::is_storage "def +is_storage(self, args, kwargs) + +is_storage(flux_node self) -> bool virtual bool is_storage() const +true, if this is a waterstorage "; + +%feature("docstring") cmf_core::aquifer::RecalcFluxes "def +RecalcFluxes(self, args, kwargs) + +RecalcFluxes(flux_node self, Time t) -> bool virtual bool +RecalcFluxes(cmf::math::Time t) Pure flux_nodes do not influence +fluxes, therefore no recalculation of fluxes is required by flux_node. +WaterStorage overrides this, since state changes require an update of +the fluxes "; + +%feature("docstring") cmf_core::aquifer::remove_connection "def +remove_connection(self, args, kwargs) + +remove_connection(flux_node self, cmf::water::flux_node::ptr To) -> +bool bool remove_connection(cmf::water::flux_node::ptr To) Remove +the connection. "; + +%feature("docstring") cmf_core::aquifer::Solute "def Solute(self, +args) + +Solute(WaterStorage self, solute _Solute) -> SoluteStorage +Solute(WaterStorage self, solute _Solute) -> SoluteStorage const +SoluteStorage& Solute(const cmf::water::solute _Solute) const "; + +%feature("docstring") cmf_core::aquifer::to_string "def +to_string(self, args, kwargs) + +to_string(StateVariable self) -> std::string virtual std::string +to_string() const =0 "; + +%feature("docstring") cmf_core::aquifer::to_string "def +to_string(self, args, kwargs) + +to_string(flux_node self) -> std::string virtual std::string +to_string() const "; + +%feature("docstring") cmf_core::aquifer::waterbalance "def +waterbalance(self, args, kwargs) + +waterbalance(flux_node self, Time t, flux_connection Without=None) -> +real real waterbalance(cmf::math::Time t, const flux_connection +*Without=0) const Returns the sum of all fluxes (positive and +negative) at time t. Single fluxes can be excluded from the +calculation Parameters: ----------- t: Time of the query Without: +A flux_connection that is excluded from the waterbalance (e.g. to +prevent closed circuits) "; + + // File: classcmf_1_1upslope_1_1aquifer.xml %feature("docstring") cmf::upslope::aquifer " @@ -203,6 +451,9 @@ porosity: Porosity of the aquifer K: Conductivity of the aquifer in m/day. If the conductivity should be anisotropic, change the x,y and z values of the member K "; +%feature("docstring") cmf::upslope::aquifer::add_connected_states "virtual void add_connected_states(cmf::math::StateVariable::list +&states) "; + %feature("docstring") cmf::upslope::aquifer::conc "real conc(const cmf::water::solute &_Solute) const @@ -224,9 +475,7 @@ Sets a new concentration. "; Returns the connection between this and target. "; %feature("docstring") cmf::upslope::aquifer::dxdt "virtual real -dxdt(const cmf::math::Time &time) - -Returns the derivate of the state variable at time time. "; +dxdt(const cmf::math::Time &time) "; %feature("docstring") cmf::upslope::aquifer::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, cmf::math::Time t) "; @@ -305,6 +554,11 @@ real get_volume() const Returns the volume of water in this storage in m3 "; +%feature("docstring") cmf::upslope::aquifer::is_connected "virtual +bool is_connected(const cmf::math::StateVariable &other) const + +Returns True if this waterstorage is effected by another state. "; + %feature("docstring") cmf::upslope::aquifer::is_storage "virtual bool is_storage() const @@ -360,6 +614,127 @@ Without: A flux_connection that is excluded from the waterbalance (e.g. to prevent closed circuits) "; +// File: classcmf__core_1_1aquifer___darcy.xml +%feature("docstring") cmf_core::aquifer_Darcy " + +Lateral darcy flow between aquifer objects. .. math:: +v_{Darcy}=K_{1,2}\\\\\\\\nabla\\\\\\\\Psi .. math:: q = +v_{Darcy} w \\\\\\\\Delta z C++ includes: groundwater.h "; + +%feature("docstring") cmf_core::aquifer_Darcy::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::aquifer_Darcy self, cmf::upslope::aquifer::ptr +left, cmf::water::flux_node::ptr right, real width) -> aquifer_Darcy +aquifer_Darcy(aquifer::ptr left, cmf::water::flux_node::ptr right, +real width) Creates a new Darcy flow connection between two aquifers, +or an aquifer and another node acting as Dirichlet boundary condition. +Parameters: ----------- left: One aquifer right: Another aquifer, +or a flux node that can be interpreted as an Dirichlet boundary width: +Width of the connection "; + +%feature("docstring") cmf_core::aquifer_Darcy::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::aquifer_Darcy::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::aquifer_Darcy::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::aquifer_Darcy::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::aquifer_Darcy::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::aquifer_Darcy::conc "def conc(self, +args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") cmf_core::aquifer_Darcy::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::aquifer_Darcy::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::aquifer_Darcy::get_tracer_filter "def get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::aquifer_Darcy::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::aquifer_Darcy::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::aquifer_Darcy::q "def q(self, args, +kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::aquifer_Darcy::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::aquifer_Darcy::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::aquifer_Darcy::set_tracer_filter "def set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::aquifer_Darcy::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::aquifer_Darcy::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + // File: classcmf_1_1upslope_1_1aquifer___darcy.xml %feature("docstring") cmf::upslope::aquifer_Darcy " @@ -573,6 +948,289 @@ cmf::upslope::connections::BaseMacroFlow::to_string "virtual std::string to_string() const "; +// File: classcmf__core_1_1_base_macro_flow.xml +%feature("docstring") cmf_core::BaseMacroFlow " + +Proxy of C++ cmf::upslope::connections::BaseMacroFlow class. "; + +%feature("docstring") cmf_core::BaseMacroFlow::__init__ "def +__init__(self, args, kwargs) "; + +%feature("docstring") cmf_core::BaseMacroFlow::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::BaseMacroFlow::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::BaseMacroFlow::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::BaseMacroFlow::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::BaseMacroFlow::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::BaseMacroFlow::conc "def conc(self, +args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") cmf_core::BaseMacroFlow::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::BaseMacroFlow::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::BaseMacroFlow::get_tracer_filter "def get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::BaseMacroFlow::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::BaseMacroFlow::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::BaseMacroFlow::q "def q(self, args, +kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::BaseMacroFlow::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::BaseMacroFlow::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::BaseMacroFlow::set_tracer_filter "def set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::BaseMacroFlow::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::BaseMacroFlow::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf__core_1_1_b_d_f2.xml +%feature("docstring") cmf_core::BDF2 " + +An order 2 BDF-Method with fixed-point iteration and variable step +size. Derived from Roussel C. and Roussel M. (2003) \"Generic Object- +Oriented Differential Equation Integrators\", C/C++ User Journal, Nov. +2003,http://www.ddj.com/cpp/184401724?pgno=8 and Eckert S., Baaser +H., Gross D. and Scherf O. (2004) \"A BDF2 integration method with +step size control for elasto-plasticity\", Computational Mechanics 34, +377 - 386, DOI: 10.1007/s00466-004-0581-1 Most important function: +Integrate C++ includes: bdf2.h "; + +%feature("docstring") cmf_core::BDF2::__init__ "def __init__(self, +args) + +__init__(cmf::math::BDF2 self, real epsilon=1e-9, Time tStepMin) -> +BDF2 __init__(cmf::math::BDF2 self, StateVariableOwner states, real +epsilon=1e-9, Time tStepMin) -> BDF2 __init__(cmf::math::BDF2 self, +Integrator templ) -> BDF2 BDF2(const Integrator &templ) Constructs a +new BDF2 integrator. Parameters: ----------- templ: Template to be +used to construct a BDF2 method "; + +%feature("docstring") cmf_core::BDF2::__call__ "def __call__(self, +t, dt=None, reset=False) + +Advances the integration until `t` A shortcut to .integrate_until +Parameters ---------- t : cmf.Time The time step to advance to. If +t < current time, the solver will advance to self.t + t dt : +cmf.Time, optional The timestep for the integration. If not given +try to integrate in one step reset : bool, optional If True, the +solver will perform a reset before starting Returns ------- cmf.Time +The new time stamp "; + +%feature("docstring") cmf_core::BDF2::__getitem__ "def +__getitem__(self, args, kwargs) + +__getitem__(Integrator self, long position) -> +cmf::math::StateVariable::ptr "; + +%feature("docstring") cmf_core::BDF2::__len__ "def __len__(self, +args, kwargs) + +__len__(Integrator self) -> size_t "; + +%feature("docstring") cmf_core::BDF2::__repr__ "def __repr__(self) +"; + +%feature("docstring") cmf_core::BDF2::add_single_state "def +add_single_state(self, args, kwargs) + +add_single_state(Integrator self, cmf::math::StateVariable::ptr state) +virtual void add_single_state(cmf::math::StateVariable::ptr state) +Adds a single state variable to the integrator. "; + +%feature("docstring") cmf_core::BDF2::add_states "def +add_states(self, args, kwargs) + +add_states(Integrator self, StateVariableOwner stateOwner) virtual +void add_states(cmf::math::StateVariableOwner &stateOwner) Add state +variables from a StateVariableOwner. "; + +%feature("docstring") cmf_core::BDF2::copy "def copy(self, args, +kwargs) + +copy(Integrator self) -> Integrator virtual Integrator* copy() const +=0 Polymorphic copy constructor. "; + +%feature("docstring") cmf_core::BDF2::get_dt "def get_dt(self, args, +kwargs) + +get_dt(Integrator self) -> Time cmf::math::Time get_dt() const +Returns the last time step. "; + +%feature("docstring") cmf_core::BDF2::get_dxdt "def get_dxdt(self, +args, kwargs) + +get_dxdt(Integrator self, Time time) -> cmf::math::num_array +cmf::math::num_array get_dxdt(Time time) const "; + +%feature("docstring") cmf_core::BDF2::get_error_position "def +get_error_position(self, args, kwargs) + +get_error_position(BDF2 self) -> int int get_error_position() const +Returns the position of the biggest error. "; + +%feature("docstring") cmf_core::BDF2::get_state "def get_state(self, +args, kwargs) + +get_state(Integrator self, ptrdiff_t position) -> real real +get_state(ptrdiff_t position) const Returns the statevariable at +position Simplifies the assessment of state variables. "; + +%feature("docstring") cmf_core::BDF2::get_states "def +get_states(self, args) + +get_states(Integrator self) -> cmf::math::num_array +get_states(Integrator self) -> StateVariableList StateVariableList +get_states() gets the state variables of the integrator "; + +%feature("docstring") cmf_core::BDF2::get_t "def get_t(self, args, +kwargs) + +get_t(Integrator self) -> Time cmf::math::Time get_t() const Returns +the current model time. "; + +%feature("docstring") cmf_core::BDF2::integrate "def integrate(self, +args, kwargs) + +integrate(Integrator self, Time t_max, Time dt) -> int virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt)=0 Integrates the +vector of state variables. Parameters: ----------- t_max: To stop +the model (if running in a model framework) at time steps of value +exchange e.g. full hours, the next value exchange time can be given +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; + +%feature("docstring") cmf_core::BDF2::integrate_until "def +integrate_until(self, args, kwargs) + +integrate_until(Integrator self, Time t_max, Time dt, bool +reset=False) void integrate_until(cmf::math::Time t_max, +cmf::math::Time dt=Time(), bool reset=false) Integrates the vector of +state variables until t_max. Parameters: ----------- t_max: Time, +the solver should run to dt: Time step (may be omitted) reset: If +true, solver is reseted before integration starts "; + +%feature("docstring") cmf_core::BDF2::reset "def reset(self, args, +kwargs) + +reset(Integrator self) virtual void reset() Resets any saved history +(for multistep methods) "; + +%feature("docstring") cmf_core::BDF2::run "def run(self, start=None, +end=None, step=day *1, max_errors=0, reset=False) + +Returns an iterator over the timesteps start..end **Examples:** >>> +solver=cmf.CVodeIntegrator(...) >>> for t in solver.run(solver.t, +solver.t + cmf.week, cmf.h): >>> print(t, solver[0].state) or with +list comprehension >>> states = [solver[0].state for t in +solver.run(solver.t, solver.t + cmf.week, cmf.h)] Parameters +---------- start : cmf.Time, optional Start time for the solver +iteration end : cmf.Time, optional End time of the iteration step : +cmf.Time, optional Step size for the integration max_errors: int +Number of tolerated errors. If >0, up to these number of runtime +errors will be saved with their time and the integration proceeds +after a reset of the solver. Some systems operate with values close to +their physical limits and inifinite values in the integration can +easily occur. For these kind of systems set max_errors to eg. 10. A +larger number of errors should be eliminated usually. reset: bool If +True, the solver performs a `reset` at every time step Yields ------ +cmf.Time the actual timestep "; + +%feature("docstring") cmf_core::BDF2::set_state "def set_state(self, +args, kwargs) + +set_state(Integrator self, ptrdiff_t position, real newState) void +set_state(ptrdiff_t position, real newState) Simplifies the +assessment of state variables. "; + +%feature("docstring") cmf_core::BDF2::set_t "def set_t(self, args, +kwargs) + +set_t(Integrator self, Time val) void set_t(cmf::math::Time val) Sets +the current model time. "; + +%feature("docstring") cmf_core::BDF2::size "def size(self, args, +kwargs) + +size(Integrator self) -> size_t size_t size() const returns the +number of state variables "; + + // File: classcmf_1_1math_1_1_b_d_f2.xml %feature("docstring") cmf::math::BDF2 " @@ -797,52 +1455,210 @@ set_states(real *newStates) "; returns the number of state variables "; -// File: classcmf_1_1water_1_1bidirectional__kinematic__exchange.xml -%feature("docstring") cmf::water::bidirectional_kinematic_exchange " +// File: classcmf__core_1_1bidirectional__kinematic__exchange.xml +%feature("docstring") cmf_core::bidirectional_kinematic_exchange " A conceptual flux between two storages that can be positive as well as -negative. +negative. The state of the right node is not monitored, hence +negative volumes of the right node can occur! Deprecated Behaviour +unclear, will be removed .. math:: q = q_{spill}^*-q_{suc}^* +\\\\\\\\\\\\\\\\ q_{spill}^* = q_{spill} +\\\\\\\\left(\\\\\\\\frac{V-V_{spill,min}}{V_{spill,min}}\\\\\\\\right)^{\\\\\\\\beta_{spill}} +\\\\\\\\\\\\\\\\ q_{suc}^* = q_{suc} +\\\\\\\\left(\\\\\\\\frac{V_{suc,max}-V}{V_{suc,max}}\\\\\\\\right)^{\\\\\\\\beta_{suc}} +where: :math:`q` is the flow to the target :math:`q_{spill}^*` is +the actual spill flow to the target :math:`q_{spill}` is the spill +flow at :math:`V = 2V_{spill}` :math:`q_{suc}^*` is the actual +suction flow from the target :math:`q_{suc}` is the sucked flow from +the target when :math:`V=0.0` :math:`\\\\\\\\beta` is a shape forming +exponent for spill and suction flow. C++ includes: +simple_connections.h "; + +%feature("docstring") +cmf_core::bidirectional_kinematic_exchange::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::water::bidirectional_kinematic_exchange self, +cmf::water::WaterStorage::ptr source, cmf::water::flux_node::ptr +target, real Vminspill, real Vmaxsuc, real qspill, real qsuc, real +beta_spill, real beta_suc) -> bidirectional_kinematic_exchange +bidirectional_kinematic_exchange(WaterStorage::ptr source, +flux_node::ptr target, real Vminspill, real Vmaxsuc, real qspill, real +qsuc, real beta_spill, real beta_suc) Creates a kinematic wave +connection. Parameters: ----------- source: Water storage from +which the water flows out. Flux is a function of source.volume target: +Target node (boundary condition or storage). Does not influence the +strength of the flow Vmaxsuc: Suction starts below this threshold +volume of source Vminspill: Spilling starts above this threshold +volume of source qspill: Spill flow at 2*Vminspill in m3/day qsuc: +Suction flow at V=0 m3 beta_suc: beta_spill: Exponent for spill / +suction flow "; -The state of the right node is not monitored, hence negative volumes -of the right node can occur! Deprecated Behaviour unclear, will be -removed +%feature("docstring") +cmf_core::bidirectional_kinematic_exchange::__contains__ "def +__contains__(self, cmp) "; -.. math:: +%feature("docstring") +cmf_core::bidirectional_kinematic_exchange::__eq__ "def __eq__(self, +args, kwargs) - q = q_{spill}^*-q_{suc}^* \\\\\\\\ q_{spill}^* = - q_{spill} - \\\\left(\\\\frac{V-V_{spill,min}}{V_{spill,min}}\\\\right)^{\\\\beta_{spill}} - \\\\\\\\ q_{suc}^* = q_{suc} - \\\\left(\\\\frac{V_{suc,max}-V}{V_{suc,max}}\\\\right)^{\\\\beta_{suc}} - +__eq__(flux_connection self, flux_connection other) -> bool "; -where: :math:`q` is the flow to the target +%feature("docstring") +cmf_core::bidirectional_kinematic_exchange::__getitem__ "def +__getitem__(self, index) "; -:math:`q_{spill}^*` is the actual spill flow to the target +%feature("docstring") +cmf_core::bidirectional_kinematic_exchange::__iter__ "def +__iter__(self) "; -:math:`q_{spill}` is the spill flow at :math:`V = 2V_{spill}` +%feature("docstring") +cmf_core::bidirectional_kinematic_exchange::__repr__ "def +__repr__(self) "; -:math:`q_{suc}^*` is the actual suction flow from the target +%feature("docstring") +cmf_core::bidirectional_kinematic_exchange::conc "def conc(self, +args, kwargs) -:math:`q_{suc}` is the sucked flow from the target when :math:`V=0.0` +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -:math:`\\\\beta` is a shape forming exponent for spill and suction flow. +%feature("docstring") +cmf_core::bidirectional_kinematic_exchange::exchange_target "def +exchange_target(self, args, kwargs) -C++ includes: simple_connections.h "; +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; %feature("docstring") -cmf::water::bidirectional_kinematic_exchange::bidirectional_kinematic_exchange -"bidirectional_kinematic_exchange(WaterStorage::ptr source, -flux_node::ptr target, real Vminspill, real Vmaxsuc, real qspill, real -qsuc, real beta_spill, real beta_suc) +cmf_core::bidirectional_kinematic_exchange::get_target "def +get_target(self, args) -Creates a kinematic wave connection. +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -Parameters: ------------ +%feature("docstring") +cmf_core::bidirectional_kinematic_exchange::get_tracer_filter "def +get_tracer_filter(self, args) -source: Water storage from which the water flows out. Flux is a -function of source.volume +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") +cmf_core::bidirectional_kinematic_exchange::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") +cmf_core::bidirectional_kinematic_exchange::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::bidirectional_kinematic_exchange::q "def q(self, args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") +cmf_core::bidirectional_kinematic_exchange::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") +cmf_core::bidirectional_kinematic_exchange::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") +cmf_core::bidirectional_kinematic_exchange::set_tracer_filter "def +set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf_core::bidirectional_kinematic_exchange::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") +cmf_core::bidirectional_kinematic_exchange::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf_1_1water_1_1bidirectional__kinematic__exchange.xml +%feature("docstring") cmf::water::bidirectional_kinematic_exchange " + +A conceptual flux between two storages that can be positive as well as +negative. + +The state of the right node is not monitored, hence negative volumes +of the right node can occur! Deprecated Behaviour unclear, will be +removed + +.. math:: + + q = q_{spill}^*-q_{suc}^* \\\\\\\\ q_{spill}^* = + q_{spill} + \\\\left(\\\\frac{V-V_{spill,min}}{V_{spill,min}}\\\\right)^{\\\\beta_{spill}} + \\\\\\\\ q_{suc}^* = q_{suc} + \\\\left(\\\\frac{V_{suc,max}-V}{V_{suc,max}}\\\\right)^{\\\\beta_{suc}} + + +where: :math:`q` is the flow to the target + +:math:`q_{spill}^*` is the actual spill flow to the target + +:math:`q_{spill}` is the spill flow at :math:`V = 2V_{spill}` + +:math:`q_{suc}^*` is the actual suction flow from the target + +:math:`q_{suc}` is the sucked flow from the target when :math:`V=0.0` + +:math:`\\\\beta` is a shape forming exponent for spill and suction flow. + +C++ includes: simple_connections.h "; + +%feature("docstring") +cmf::water::bidirectional_kinematic_exchange::bidirectional_kinematic_exchange +"bidirectional_kinematic_exchange(WaterStorage::ptr source, +flux_node::ptr target, real Vminspill, real Vmaxsuc, real qspill, real +qsuc, real beta_spill, real beta_suc) + +Creates a kinematic wave connection. + +Parameters: +----------- + +source: Water storage from which the water flows out. Flux is a +function of source.volume target: Target node (boundary condition or storage). Does not influence the strength of the flow @@ -1162,6 +1978,304 @@ cmf::upslope::BrooksCoreyRetentionCurve::Wetness_pF "cmf::math::num_array Wetnes "; +// File: classcmf__core_1_1_brooks_corey_retention_curve.xml +%feature("docstring") cmf_core::BrooksCoreyRetentionCurve " + +Provides the use of the Brooks-Corey retention curve. .. math:: +W(\\\\\\\\theta) &=& \\\\\\\\frac{\\\\\\\\theta - +\\\\\\\\theta_r}{\\\\\\\\theta_s - \\\\\\\\theta_r} \\\\\\\\\\\\\\\\ +K(W) &=& K_{sat} W^{2b+3} \\\\\\\\\\\\\\\\ \\\\\\\\Psi(W) &=& +\\\\\\\\Psi_X \\\\\\\\left(\\\\\\\\frac{W}{W_X}\\\\\\\\right)^{-b} +\\\\\\\\\\\\\\\\ W(\\\\\\\\Psi) &=& {\\\\\\\\left( +\\\\\\\\frac{\\\\\\\\Psi_X}{\\\\\\\\Psi}\\\\\\\\right) +}^{\\\\\\\\frac{1}{b}}\\\\\\\\ W_X where: :math:`K` is the +conductivity in :math:`\\\\\\\\frac m{day}` :math:`W` is the wetness +(Volume of soil water per volume of pores) :math:`b` is the shape of +the retention curve (usually between 4 (sand) and 14 (clay)) +:math:`\\\\\\\\Psi(W)` is the matric potential in :math:`m H_2O` at +wetness W :math:`\\\\\\\\Psi_X` is a matric potential at a known +wetness in :math:`m H_2O` :math:`W_X` is the wetness with a known +matric potential for dynamic changes with depth, exponential decays of +porosity and saturated conductivity are used The decay function is: +:math:`v(d)=v(0) (1+a)^{-d}`, where v is the value ( +:math:`K_{sat},\\\\\\\\Phi`), d is the depth in m and a is the +fractional decay per m. E.g. 0.1 means the value has in 1 m depth 90% +of the value at the surface C++ includes: RetentionCurve.h "; + +%feature("docstring") cmf_core::BrooksCoreyRetentionCurve::__init__ "def __init__(self, args, kwargs) + +__init__(cmf::upslope::BrooksCoreyRetentionCurve self, real ksat=15, +real porosity=0.5, real _b=5, real theta_x=0.2, real psi_x, real +porosity_decay=0) -> BrooksCoreyRetentionCurve +BrooksCoreyRetentionCurve(real ksat=15, real porosity=0.5, real _b=5, +real theta_x=0.2, real psi_x=pF_to_waterhead(2.5), real +porosity_decay=0) Creates a brooks corey retention curve. Parameters: +----------- ksat: Saturated conductivity +:math:`\\\\\\\\frac{m}{day}` porosity: :math:`\\\\\\\\frac{m^3 +Pores}{m^3 Soil}` _b: Shape of the retention curve (if you do not +know how to parameterize this, take a look at the other constructor) +theta_x: :math:`\\\\\\\\theta_X` Water content at a specific suction +pressure psi_x: Suction pressure for :math:`\\\\\\\\theta_X` in m +water column, use the conversion functions pF_to_waterhead, +pressure_to_waterhead to convert pressure in to waterhead height +(default pF=2.5) porosity_decay: Relative decay of porosity with +depth, e.g. 0.1 means conductivity gets 10% smaller per meter "; + +%feature("docstring") cmf_core::BrooksCoreyRetentionCurve::__repr__ "def __repr__(self) "; + +%feature("docstring") cmf_core::BrooksCoreyRetentionCurve::__str__ "def __str__(self) "; + +%feature("docstring") cmf_core::BrooksCoreyRetentionCurve::copy "def +copy(self, args, kwargs) + +copy(BrooksCoreyRetentionCurve self) -> BrooksCoreyRetentionCurve +virtual BrooksCoreyRetentionCurve* copy() const "; + +%feature("docstring") +cmf_core::BrooksCoreyRetentionCurve::CreateFrom2Points "def +CreateFrom2Points(args, kwargs) + +CreateFrom2Points(real ksat, real porosity, real theta1, real theta2, +real psi_1, real psi_2) -> BrooksCoreyRetentionCurve "; + +%feature("docstring") +cmf_core::BrooksCoreyRetentionCurve::Diffusivity "def +Diffusivity(self, args) + +Diffusivity(RetentionCurve self, real wetness) -> real +Diffusivity(RetentionCurve self, cmf::math::num_array & wetness) -> +cmf::math::num_array cmf::math::num_array +Diffusivity(cmf::math::num_array &wetness) "; + +%feature("docstring") cmf_core::BrooksCoreyRetentionCurve::dPsiM_dW "def dPsiM_dW(self, args) + +dPsiM_dW(RetentionCurve self, real wetness) -> real +dPsiM_dW(RetentionCurve self, cmf::math::num_array const & wetness) -> +cmf::math::num_array cmf::math::num_array dPsiM_dW(const +cmf::math::num_array &wetness) const "; + +%feature("docstring") cmf_core::BrooksCoreyRetentionCurve::FillHeight +"def FillHeight(self, args, kwargs) + +FillHeight(RetentionCurve self, real lowerDepth, real Area, real +Volume) -> real virtual real FillHeight(real lowerDepth, real Area, +real Volume) const Returns the thickness of a soil column with a +certain pore volume. "; + +%feature("docstring") cmf_core::BrooksCoreyRetentionCurve::K "def +K(self, args) + +K(RetentionCurve self, real wetness) -> real K(RetentionCurve self, +cmf::math::num_array const & wetness) -> cmf::math::num_array +cmf::math::num_array K(const cmf::math::num_array &wetness) const "; + +%feature("docstring") +cmf_core::BrooksCoreyRetentionCurve::MatricPotential "def +MatricPotential(self, args) + +MatricPotential(RetentionCurve self, real wetness) -> real +MatricPotential(RetentionCurve self, cmf::math::num_array const & +wetness) -> cmf::math::num_array cmf::math::num_array +MatricPotential(const cmf::math::num_array &wetness) const "; + +%feature("docstring") cmf_core::BrooksCoreyRetentionCurve::Porosity "def Porosity(self, args, kwargs) + +Porosity(RetentionCurve self, real depth=0.0) -> real virtual real +Porosity(real depth=0.0) const =0 Returns the porosity at a certain +depth. "; + +%feature("docstring") +cmf_core::BrooksCoreyRetentionCurve::SetPorosity "def +SetPorosity(self, args, kwargs) + +SetPorosity(BrooksCoreyRetentionCurve self, real porosity, real +porosity_decay=0) void SetPorosity(real porosity, real +porosity_decay=0) Sets the porosity (Volume of pores per volume of +soil) and the exponential porosity decline with depth. "; + +%feature("docstring") cmf_core::BrooksCoreyRetentionCurve::theta "def theta(self, args) + +theta(RetentionCurve self, real wetness) -> real theta(RetentionCurve +self, cmf::math::num_array const & wetness) -> cmf::math::num_array +cmf::math::num_array theta(const cmf::math::num_array &wetness) const +"; + +%feature("docstring") +cmf_core::BrooksCoreyRetentionCurve::Transmissivity "def +Transmissivity(self, args, kwargs) + +Transmissivity(BrooksCoreyRetentionCurve self, real upperDepth, real +lowerDepth, real theta) -> real real Transmissivity(real upperDepth, +real lowerDepth, real theta) const "; + +%feature("docstring") cmf_core::BrooksCoreyRetentionCurve::VoidVolume +"def VoidVolume(self, args, kwargs) + +VoidVolume(RetentionCurve self, real upperDepth, real lowerDepth, real +Area) -> real virtual real VoidVolume(real upperDepth, real +lowerDepth, real Area) const Returns the void volume of a soil +column. "; + +%feature("docstring") cmf_core::BrooksCoreyRetentionCurve::Wetness "def Wetness(self, args) + +Wetness(RetentionCurve self, real suction) -> real +Wetness(RetentionCurve self, cmf::math::num_array const & suction) -> +cmf::math::num_array cmf::math::num_array Wetness(const +cmf::math::num_array &suction) const "; + +%feature("docstring") +cmf_core::BrooksCoreyRetentionCurve::Wetness_eff "def +Wetness_eff(self, args, kwargs) + +Wetness_eff(RetentionCurve self, real wetness, real pF_r=4.2) -> real +virtual real Wetness_eff(real wetness, real pF_r=4.2) const Returns +the effective wetness, using a residual pF value .. math:: w_{eff} += +\\\\\\\\frac{w_{act}-w\\\\\\\\left(pF_r\\\\\\\\right)}{1-w\\\\\\\\left(pF_r\\\\\\\\right)} +. "; + +%feature("docstring") cmf_core::BrooksCoreyRetentionCurve::Wetness_pF +"def Wetness_pF(self, args) + +Wetness_pF(RetentionCurve self, real pF) -> real +Wetness_pF(RetentionCurve self, cmf::math::num_array const & pF) -> +cmf::math::num_array cmf::math::num_array Wetness_pF(const +cmf::math::num_array &pF) const "; + + +// File: classcmf__core_1_1_canopy_overflow.xml +%feature("docstring") cmf_core::CanopyOverflow " + +Calculates the overflow of a canopy storage using a kinematic wave +approach. This model routes only water that exceeds the canopy +capacity to the ground with an ad hoc estimated function: .. math:: +q_{CO} = +\\\\\\\\left(\\\\\\\\frac{V_{act}-V_{max}}{V_{max}}\\\\\\\\right) ^2 +\\\\\\\\cdot 2400 \\\\\\\\frac{A_{cell}}{1000} With: +:math:`q_{CO}(t)[\\\\\\\\frac{m^3}{day}]`: The flux from canopy to the +ground :math:`V_{act}[mm]=1000 [mm/m] +\\\\\\\\frac{V_{canopy}[m^3]}{A_{cell} [m^2]}` The stored water of the +canopy in mm :math:`V_{max}[mm]=c_{LAI}[mm] LAI` The capacity of the +canopy in mm, defined by the factor CanopyCapacityPerLAI [mm/LAI], and +the leaf area index LAI. (see: cmf::upslope::Vegetation) C++ +includes: surfacefluxes.h "; + +%feature("docstring") cmf_core::CanopyOverflow::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::connections::CanopyOverflow self, +cmf::water::WaterStorage::ptr Canopy, cmf::water::flux_node::ptr +target, Cell cell) -> CanopyOverflow +CanopyOverflow(cmf::water::WaterStorage::ptr Canopy, +cmf::water::flux_node::ptr target, cmf::upslope::Cell &cell) "; + +%feature("docstring") cmf_core::CanopyOverflow::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::CanopyOverflow::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::CanopyOverflow::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::CanopyOverflow::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::CanopyOverflow::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::CanopyOverflow::conc "def conc(self, +args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") cmf_core::CanopyOverflow::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::CanopyOverflow::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::CanopyOverflow::get_tracer_filter "def get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::CanopyOverflow::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::CanopyOverflow::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::CanopyOverflow::q "def q(self, args, +kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::CanopyOverflow::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::CanopyOverflow::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::CanopyOverflow::set_tracer_filter "def set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::CanopyOverflow::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::CanopyOverflow::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + +%feature("docstring") cmf_core::CanopyOverflow::use_for_cell "def +use_for_cell(args, kwargs) + +use_for_cell(Cell cell) -> CanopyOverflow "; + + // File: classcmf_1_1upslope_1_1connections_1_1_canopy_overflow.xml %feature("docstring") cmf::upslope::connections::CanopyOverflow " @@ -1289,6 +2403,123 @@ cmf::upslope::connections::CanopyOverflow::to_string "virtual std::string to_string() const "; +// File: classcmf__core_1_1_canopy_storage_evaporation.xml +%feature("docstring") cmf_core::CanopyStorageEvaporation " + +Calculates the evaporation from a canopy storage. C++ includes: ET.h +"; + +%feature("docstring") cmf_core::CanopyStorageEvaporation::__init__ "def __init__(self, args, kwargs) + +__init__(cmf::upslope::ET::CanopyStorageEvaporation self, +cmf::water::WaterStorage::ptr CanopyStorage, +cmf::water::flux_node::ptr ET_target, Cell cell) -> +CanopyStorageEvaporation +CanopyStorageEvaporation(cmf::water::WaterStorage::ptr CanopyStorage, +cmf::water::flux_node::ptr ET_target, cmf::upslope::Cell &cell) "; + +%feature("docstring") +cmf_core::CanopyStorageEvaporation::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::CanopyStorageEvaporation::__eq__ "def __eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::CanopyStorageEvaporation::__getitem__ +"def __getitem__(self, index) "; + +%feature("docstring") cmf_core::CanopyStorageEvaporation::__iter__ "def __iter__(self) "; + +%feature("docstring") cmf_core::CanopyStorageEvaporation::__repr__ "def __repr__(self) "; + +%feature("docstring") cmf_core::CanopyStorageEvaporation::conc "def +conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") +cmf_core::CanopyStorageEvaporation::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::CanopyStorageEvaporation::get_target +"def get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") +cmf_core::CanopyStorageEvaporation::get_tracer_filter "def +get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::CanopyStorageEvaporation::kill_me "def kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::CanopyStorageEvaporation::left_node "def left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::CanopyStorageEvaporation::q "def +q(self, args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::CanopyStorageEvaporation::refresh "def refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::CanopyStorageEvaporation::right_node +"def right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") +cmf_core::CanopyStorageEvaporation::set_tracer_filter "def +set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf_core::CanopyStorageEvaporation::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::CanopyStorageEvaporation::to_string "def to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + // File: classcmf_1_1upslope_1_1_e_t_1_1_canopy_storage_evaporation.xml %feature("docstring") cmf::upslope::ET::CanopyStorageEvaporation " @@ -1690,72 +2921,346 @@ StateVariableOwner, to the given vector. "; to_string() const "; -// File: classcmf_1_1upslope_1_1cell__const__iterator.xml -%feature("docstring") cmf::upslope::cell_const_iterator ""; +// File: classcmf__core_1_1_cell.xml +%feature("docstring") cmf_core::Cell " -%feature("docstring") -cmf::upslope::cell_const_iterator::cell_const_iterator "cell_const_iterator(const cell_const_iterator ©) "; +This class is the basic landscape object. It is the owner of water +storages, and the upper and lower boundary conditions of the system +(rainfall, atmospheric vapor, deep groundwater) C++ includes: cell.h +"; -%feature("docstring") -cmf::upslope::cell_const_iterator::cell_const_iterator "cell_const_iterator(const cell_iterator ©) "; +%feature("docstring") cmf_core::Cell::__init__ "def __init__(self, +args, kwargs) -%feature("docstring") cmf::upslope::cell_const_iterator::as_iterator -"const_iterator as_iterator() "; +__init__(cmf::upslope::Cell self, double x, double y, double z, double +area, project _project) -> Cell Cell(double x, double y, double z, +double area, cmf::project &_project) "; -%feature("docstring") cmf::upslope::cell_const_iterator::ptr "const -cmf::upslope::Cell* ptr() const "; +%feature("docstring") cmf_core::Cell::__eq__ "def __eq__(self, cmp) +"; +%feature("docstring") cmf_core::Cell::__hash__ "def __hash__(self) +"; -// File: classcmf_1_1upslope_1_1cell__iterator.xml -%feature("docstring") cmf::upslope::cell_iterator ""; +%feature("docstring") cmf_core::Cell::__repr__ "def __repr__(self) +"; -%feature("docstring") cmf::upslope::cell_iterator::cell_iterator "cell_iterator() "; +%feature("docstring") cmf_core::Cell::add_layer "def add_layer(self, +args) -%feature("docstring") cmf::upslope::cell_iterator::cell_iterator "cell_iterator(const cell_iterator ©) "; +add_layer(Cell self, real lowerboundary, RetentionCurve r_curve, real +saturateddepth=10) -> cmf::upslope::SoilLayer::ptr add_layer(Cell +self, real lowerboundary) -> cmf::upslope::SoilLayer::ptr +cmf::upslope::SoilLayer::ptr add_layer(real lowerboundary) Adds a +rather conceptual layer to the cell. Use this version for conceptual +models. The retention curve resambles an empty bucket. "; -%feature("docstring") cmf::upslope::cell_iterator::as_iterator "iterator as_iterator() "; +%feature("docstring") cmf_core::Cell::add_storage "def +add_storage(self, args) -%feature("docstring") cmf::upslope::cell_iterator::ptr "cmf::upslope::Cell* ptr() const "; +add_storage(Cell self, std::string Name, char storage_role, bool +isopenwater=False) -> cmf::water::WaterStorage::ptr add_storage(Cell +self, cmf::water::WaterStorage::ptr storage) -> ptrdiff_t ptrdiff_t +add_storage(cmf::water::WaterStorage::ptr storage) Bounds an existing +storage to the cell. "; +%feature("docstring") cmf_core::Cell::albedo "def albedo(self, args, +kwargs) -// File: classcmf_1_1upslope_1_1cell__vector.xml -%feature("docstring") cmf::upslope::cell_vector " +albedo(Cell self) -> real real albedo() const "; -A cell vector holds a bunch of cells. +%feature("docstring") cmf_core::Cell::connect_soil_with_node "def +connect_soil_with_node(self, node, ctype, flowwidth, distance, +upper_boundary=0, lower_boundary=None) -C++ includes: cell_vector.h "; +Connects all layers between the boundaries with a node using a flux +connection node: Target node (flux_node) type: Type of the connection +(e.g. cmf.Richards_lateral) flowwidth: Width of the connection +distance: distance of the connection upper_boundary: Connect only +layers, whose lower depth is greater then this value lower_boundary: +Connect only layers, whose upper depth is smaller then this value "; -%feature("docstring") cmf::upslope::cell_vector::cell_vector "cell_vector() "; +%feature("docstring") cmf_core::Cell::get_canopy "def +get_canopy(self, args, kwargs) -%feature("docstring") cmf::upslope::cell_vector::cell_vector "cell_vector(const cell_vector ©) "; +get_canopy(Cell self) -> cmf::water::WaterStorage::ptr +cmf::water::WaterStorage::ptr get_canopy() const "; -%feature("docstring") cmf::upslope::cell_vector::cell_vector "cell_vector(cell_const_iterator first, cell_const_iterator last) "; +%feature("docstring") cmf_core::Cell::get_layer "def get_layer(self, +args, kwargs) -%feature("docstring") cmf::upslope::cell_vector::~cell_vector "virtual ~cell_vector() "; +get_layer(Cell self, ptrdiff_t ndx) -> cmf::upslope::SoilLayer::ptr +cmf::upslope::SoilLayer::ptr get_layer(ptrdiff_t ndx) const Returns +the layer at position ndx. From python this function is masked as a +sequence: "; -%feature("docstring") cmf::upslope::cell_vector::append "void -append(cmf::upslope::Cell &cell) "; +%feature("docstring") cmf_core::Cell::get_position "def +get_position(self, args, kwargs) -%feature("docstring") cmf::upslope::cell_vector::as_set "std::set as_set() "; +get_position(Cell self) -> point cmf::geometry::point get_position() +const Returns the location of the cell. "; -%feature("docstring") cmf::upslope::cell_vector::begin "cell_iterator begin() "; +%feature("docstring") cmf_core::Cell::get_rainfall "def +get_rainfall(self, args, kwargs) -%feature("docstring") cmf::upslope::cell_vector::begin "cell_const_iterator begin() const "; +get_rainfall(Cell self, Time t) -> double double +get_rainfall(cmf::math::Time t) const Returns the current rainfall +flux in m3/day. "; -%feature("docstring") cmf::upslope::cell_vector::contains "bool -contains(const cmf::upslope::Cell &cell) const "; +%feature("docstring") cmf_core::Cell::get_snow "def get_snow(self, +args, kwargs) -%feature("docstring") cmf::upslope::cell_vector::end "cell_iterator -end() "; +get_snow(Cell self) -> cmf::water::WaterStorage::ptr +cmf::water::WaterStorage::ptr get_snow() const "; -%feature("docstring") cmf::upslope::cell_vector::end "cell_const_iterator end() const "; +%feature("docstring") cmf_core::Cell::get_states "def +get_states(self, args, kwargs) -%feature("docstring") cmf::upslope::cell_vector::get_area "double -get_area() const +get_states(StateVariableOwner self) -> StateVariableList virtual +StateVariableList get_states()=0 Add the state variables, owned by an +object derived from StateVariableOwner, to the given vector. "; -Returns sum of the area of the cells. "; +%feature("docstring") cmf_core::Cell::get_storage "def +get_storage(self, args, kwargs) -%feature("docstring") cmf::upslope::cell_vector::get_highest "Cell& +get_storage(Cell self, ptrdiff_t index) -> +cmf::water::WaterStorage::ptr cmf::water::WaterStorage::ptr +get_storage(ptrdiff_t index) const "; + +%feature("docstring") cmf_core::Cell::get_surfacewater "def +get_surfacewater(self, args, kwargs) + +get_surfacewater(Cell self) -> cmf::water::flux_node::ptr +cmf::water::flux_node::ptr get_surfacewater() returns the surface +water of this cell. This is either a flux node or a +cmf::upslope::SurfaceWater "; + +%feature("docstring") cmf_core::Cell::get_weather "def +get_weather(self, args, kwargs) + +get_weather(Cell self, Time t) -> Weather cmf::atmosphere::Weather +get_weather(cmf::math::Time t) const Returns the current +meteorological conditions of the cell at time t. "; + +%feature("docstring") cmf_core::Cell::get_WKB "def get_WKB(self, +args, kwargs) + +get_WKB(Cell self) -> cmf::bytestring cmf::bytestring get_WKB() const +"; + +%feature("docstring") cmf_core::Cell::heat_flux "def heat_flux(self, +args, kwargs) + +heat_flux(Cell self, Time t) -> real real heat_flux(cmf::math::Time +t) const Calculates the surface heat balance. Parameters: +----------- t: Time step "; + +%feature("docstring") cmf_core::Cell::install_connection "def +install_connection(self, connection_type) + +Calls the static use_for_cell method of the connection_type, if +present. The use_for_cell method might do quite a lot of stuff, please +consult the docs for the connection. Eg. +>>>help(Richards.use_for_cell) "; + +%feature("docstring") cmf_core::Cell::InvalidateSatDepth "def +InvalidateSatDepth(self, args, kwargs) + +InvalidateSatDepth(Cell self) void InvalidateSatDepth() const Marks +the saturated depth as unvalid. This is done automatically, when the +state of a layer changes. "; + +%feature("docstring") cmf_core::Cell::layer_count "def +layer_count(self, args, kwargs) + +layer_count(Cell self) -> size_t size_t layer_count() const Returns +the number of layers of the cell. "; + +%feature("docstring") cmf_core::Cell::leave_wetness "def +leave_wetness(self, args, kwargs) + +leave_wetness(Cell self) -> real real leave_wetness() const Return +the fraction of wet leaves in the canopy if a canopy water storage +exists. If no canopy storage is present, it returns 0.0 (=empty). The +fraction of wet leaves are calculated as the linear filling of the +canopy storage. "; + +%feature("docstring") cmf_core::Cell::m3_to_mm "def m3_to_mm(self, +args, kwargs) + +m3_to_mm(Cell self, double volume) -> double double m3_to_mm(double +volume) const Converts a volume in m3 in mm for the cell area. "; + +%feature("docstring") cmf_core::Cell::mm_to_m3 "def mm_to_m3(self, +args, kwargs) + +mm_to_m3(Cell self, double depth) -> double double mm_to_m3(double +depth) const "; + +%feature("docstring") cmf_core::Cell::neighbors "def neighbors(self) +"; + +%feature("docstring") cmf_core::Cell::remove_last_layer "def +remove_last_layer(self, args, kwargs) + +remove_last_layer(Cell self) void remove_last_layer() Remove the +lowest layer from this cell. "; + +%feature("docstring") cmf_core::Cell::remove_layers "def +remove_layers(self, args, kwargs) + +remove_layers(Cell self) void remove_layers() Removes all layers +from this cell. "; + +%feature("docstring") cmf_core::Cell::remove_storage "def +remove_storage(self, args, kwargs) + +remove_storage(Cell self, cmf::water::WaterStorage::ptr storage) void +remove_storage(cmf::water::WaterStorage::ptr storage) "; + +%feature("docstring") cmf_core::Cell::set_aerodynamic_resistance "def set_aerodynamic_resistance(self, args, kwargs) + +set_aerodynamic_resistance(Cell self, +cmf::atmosphere::aerodynamic_resistance::ptr Ra) void +set_aerodynamic_resistance(cmf::atmosphere::aerodynamic_resistance::ptr +Ra) Sets the method to calculate aerodynamic resistance against +turbulent sensible heat fluxes. "; + +%feature("docstring") cmf_core::Cell::set_rainfall "def +set_rainfall(self, args, kwargs) + +set_rainfall(Cell self, double rainfall) void set_rainfall(double +rainfall) Exchanges a timeseries of rainfall with a constant flux. "; + +%feature("docstring") cmf_core::Cell::set_uptakestress "def +set_uptakestress(self, args, kwargs) + +set_uptakestress(Cell self, RootUptakeStessFunction stressfunction) +void set_uptakestress(const ET::RootUptakeStessFunction +&stressfunction) Uses the given WaterStressFunction for all +stressedET like connections to the transpiration target. "; + +%feature("docstring") cmf_core::Cell::set_weather "def +set_weather(self, args, kwargs) + +set_weather(Cell self, Weather weather) void set_weather(const +cmf::atmosphere::Weather &weather) Sets the weather for this cell. +Connectivity to a meteorological station is lost. "; + +%feature("docstring") cmf_core::Cell::set_WKB "def set_WKB(self, +args, kwargs) + +set_WKB(Cell self, cmf::bytestring wkb) void set_WKB(cmf::bytestring +wkb) "; + +%feature("docstring") cmf_core::Cell::snow_coverage "def +snow_coverage(self, args, kwargs) + +snow_coverage(Cell self) -> real real snow_coverage() const "; + +%feature("docstring") cmf_core::Cell::storage_count "def +storage_count(self, args, kwargs) + +storage_count(Cell self) -> size_t size_t storage_count() const "; + +%feature("docstring") cmf_core::Cell::storages "def storages(self) +"; + +%feature("docstring") cmf_core::Cell::surface_storages "def +surface_storages(self) "; + +%feature("docstring") cmf_core::Cell::surface_water_coverage "def +surface_water_coverage(self, args, kwargs) + +surface_water_coverage(Cell self) -> real real +surface_water_coverage() const Returns the coverage of the surface +water. The covered fraction (0..1) is simply modelled as a piecewise +linear function of the surface water depth. If the depth is above the +aggregate height, the coverage is 1, below it is given as .. math:: +c = \\\\\\\\frac{h_{water}}{\\\\\\\\Delta h_{surface}} with c the +coverage, :math:`h_{water}` the depth of the surface water and +:math:`\\\\\\\\Delta h_{surface}` the amplitude of the surface +roughness "; + +%feature("docstring") cmf_core::Cell::surfacewater_as_storage "def +surfacewater_as_storage(self, args, kwargs) + +surfacewater_as_storage(Cell self) -> cmf::upslope::surfacewater_ptr +surfacewater_ptr surfacewater_as_storage() Makes the surfacewater of +this cell a cmf::upslope::SurfaceWater storage. "; + +%feature("docstring") cmf_core::Cell::to_string "def to_string(self, +args, kwargs) + +to_string(Cell self) -> std::string std::string to_string() const "; + + +// File: classcmf_1_1upslope_1_1cell__const__iterator.xml +%feature("docstring") cmf::upslope::cell_const_iterator ""; + +%feature("docstring") +cmf::upslope::cell_const_iterator::cell_const_iterator "cell_const_iterator(const cell_const_iterator ©) "; + +%feature("docstring") +cmf::upslope::cell_const_iterator::cell_const_iterator "cell_const_iterator(const cell_iterator ©) "; + +%feature("docstring") cmf::upslope::cell_const_iterator::as_iterator +"const_iterator as_iterator() "; + +%feature("docstring") cmf::upslope::cell_const_iterator::ptr "const +cmf::upslope::Cell* ptr() const "; + + +// File: classcmf_1_1upslope_1_1cell__iterator.xml +%feature("docstring") cmf::upslope::cell_iterator ""; + +%feature("docstring") cmf::upslope::cell_iterator::cell_iterator "cell_iterator() "; + +%feature("docstring") cmf::upslope::cell_iterator::cell_iterator "cell_iterator(const cell_iterator ©) "; + +%feature("docstring") cmf::upslope::cell_iterator::as_iterator "iterator as_iterator() "; + +%feature("docstring") cmf::upslope::cell_iterator::ptr "cmf::upslope::Cell* ptr() const "; + + +// File: classcmf_1_1upslope_1_1cell__vector.xml +%feature("docstring") cmf::upslope::cell_vector " + +A cell vector holds a bunch of cells. + +C++ includes: cell_vector.h "; + +%feature("docstring") cmf::upslope::cell_vector::cell_vector "cell_vector() "; + +%feature("docstring") cmf::upslope::cell_vector::cell_vector "cell_vector(const cell_vector ©) "; + +%feature("docstring") cmf::upslope::cell_vector::cell_vector "cell_vector(cell_const_iterator first, cell_const_iterator last) "; + +%feature("docstring") cmf::upslope::cell_vector::~cell_vector "virtual ~cell_vector() "; + +%feature("docstring") cmf::upslope::cell_vector::append "void +append(cmf::upslope::Cell &cell) "; + +%feature("docstring") cmf::upslope::cell_vector::as_set "std::set as_set() "; + +%feature("docstring") cmf::upslope::cell_vector::begin "cell_iterator begin() "; + +%feature("docstring") cmf::upslope::cell_vector::begin "cell_const_iterator begin() const "; + +%feature("docstring") cmf::upslope::cell_vector::contains "bool +contains(const cmf::upslope::Cell &cell) const "; + +%feature("docstring") cmf::upslope::cell_vector::end "cell_iterator +end() "; + +%feature("docstring") cmf::upslope::cell_vector::end "cell_const_iterator end() const "; + +%feature("docstring") cmf::upslope::cell_vector::get_area "double +get_area() const + +Returns sum of the area of the cells. "; + +%feature("docstring") cmf::upslope::cell_vector::get_highest "Cell& get_highest() const Returns the heighest cell. "; @@ -1791,6 +3296,81 @@ remove(const cmf::upslope::Cell &cell) "; const "; +// File: classcmf__core_1_1cell__vector.xml +%feature("docstring") cmf_core::cell_vector " + +A cell vector holds a bunch of cells. C++ includes: cell_vector.h "; + +%feature("docstring") cmf_core::cell_vector::__init__ "def +__init__(self, args) + +__init__(cmf::upslope::cell_vector self) -> cell_vector +__init__(cmf::upslope::cell_vector self, cell_vector copy) -> +cell_vector cell_vector(cell_const_iterator first, +cell_const_iterator last) "; + +%feature("docstring") cmf_core::cell_vector::__contains__ "def +__contains__(self, args, kwargs) + +__contains__(cell_vector self, Cell cell) -> bool bool contains(const +cmf::upslope::Cell &cell) const "; + +%feature("docstring") cmf_core::cell_vector::__getitem__ "def +__getitem__(self, args) + +__getitem__(cell_vector self, ptrdiff_t index) -> Cell +__getitem__(cell_vector self, ptrdiff_t index) -> Cell "; + +%feature("docstring") cmf_core::cell_vector::__getslice__ "def +__getslice__(self, args, kwargs) + +__getslice__(cell_vector self, ptrdiff_t start, ptrdiff_t end, +ptrdiff_t step=1) -> cell_vector cell_vector get_slice(ptrdiff_t +start, ptrdiff_t end, ptrdiff_t step=1) "; + +%feature("docstring") cmf_core::cell_vector::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::cell_vector::__len__ "def +__len__(self, args, kwargs) + +__len__(cell_vector self) -> size_t size_t size() const "; + +%feature("docstring") cmf_core::cell_vector::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::cell_vector::append "def +append(self, args, kwargs) + +append(cell_vector self, Cell cell) void append(cmf::upslope::Cell +&cell) "; + +%feature("docstring") cmf_core::cell_vector::get_area "def +get_area(self, args, kwargs) + +get_area(cell_vector self) -> double double get_area() const Returns +sum of the area of the cells. "; + +%feature("docstring") cmf_core::cell_vector::get_states "def +get_states(self, args, kwargs) + +get_states(StateVariableOwner self) -> StateVariableList virtual +StateVariableList get_states()=0 Add the state variables, owned by an +object derived from StateVariableOwner, to the given vector. "; + +%feature("docstring") cmf_core::cell_vector::pop "def pop(self, +args, kwargs) + +pop(cell_vector self) -> Cell Cell& pop() Returns and removes the +last cell. "; + +%feature("docstring") cmf_core::cell_vector::remove "def +remove(self, args) + +remove(cell_vector self, ptrdiff_t index) remove(cell_vector self, +Cell cell) void remove(const cmf::upslope::Cell &cell) "; + + // File: classcmf_1_1upslope_1_1_cell_connector.xml %feature("docstring") cmf::upslope::CellConnector " @@ -1806,6 +3386,34 @@ connect(cmf::upslope::Cell &cell1, cmf::upslope::Cell &cell2, ptrdiff_t start_at_layer=0) const "; +// File: classcmf__core_1_1_cell_connector.xml +%feature("docstring") cmf_core::CellConnector " + +A helper class to connect cells with flux_connection objects. This is +generated by flux_connection classes, intended to connect cells. C++ +includes: cell.h "; + +%feature("docstring") cmf_core::CellConnector::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::CellConnector self, +cmf::upslope::connectorfunction connector) -> CellConnector +CellConnector(connectorfunction connector) "; + +%feature("docstring") cmf_core::CellConnector::__call__ "def +__call__(self, args, kwargs) + +__call__(CellConnector self, Cell cell1, Cell cell2, ptrdiff_t +start_at_layer=0) "; + +%feature("docstring") cmf_core::CellConnector::connect "def +connect(self, args, kwargs) + +connect(CellConnector self, Cell cell1, Cell cell2, ptrdiff_t +start_at_layer=0) void connect(cmf::upslope::Cell &cell1, +cmf::upslope::Cell &cell2, ptrdiff_t start_at_layer=0) const "; + + // File: classcmf_1_1draw_1_1cellmap_1_1_cell_map.xml %feature("docstring") cmf::draw::cellmap::CellMap " @@ -2008,6 +3616,141 @@ const "; V(double h) const "; +// File: classcmf__core_1_1_channel.xml +%feature("docstring") cmf_core::Channel " + +A wrapper for channel geometries. C++ includes: ReachType.h "; + +%feature("docstring") cmf_core::Channel::__init__ "def +__init__(self, args) + +__init__(cmf::river::Channel self) -> Channel +__init__(cmf::river::Channel self, double length) -> Channel +__init__(cmf::river::Channel self, IChannel for_wrapping) -> Channel +__init__(cmf::river::Channel self, IVolumeHeightFunction for_casting) +-> Channel __init__(cmf::river::Channel self, Channel for_copy) -> +Channel __init__(cmf::river::Channel self, char typecode, double +length, double width=1., double depth=0.25) -> Channel Channel(char +typecode, double length, double width=1., double depth=0.25) Creates +a reachtype using a short cut character. Acceptes one of the +following characters: 'T' TriangularReach, width and depth are +ignored. 'R' RectangularReach, depth is ignored 'P' PipeReach, depth +is ignored, width is the diameter of the pipe 'S' SWATReachType, a +trapezoid flow cross section, as used in the SWAT model, width (bank +width) and depth are used the reach type Parameters: ----------- +typecode: Describes the geometry of the reach cross section. length: +The length of the channel in m width: width of the reach cross +section in m (ignored for typecode 'T') depth: depth of the reach +(ignored for typecode 'T','R','P','S') "; + +%feature("docstring") cmf_core::Channel::A "def A(self, args, +kwargs) + +A(IVolumeHeightFunction self, double V) -> double virtual double +A(double V) const =0 Returns the area of the surface for a given +volume. "; + +%feature("docstring") cmf_core::Channel::copy "def copy(self, args, +kwargs) + +copy(Channel self) -> Channel Channel* copy() const "; + +%feature("docstring") cmf_core::Channel::get_channel_width "def +get_channel_width(self, args, kwargs) + +get_channel_width(IChannel self, double depth) -> double virtual +double get_channel_width(double depth) const =0 Calculates the flow +width from a given actual depth [m] using the actual IChannel +geometry. "; + +%feature("docstring") cmf_core::Channel::get_depth "def +get_depth(self, args, kwargs) + +get_depth(IChannel self, double area) -> double virtual double +get_depth(double area) const =0 Calculates the actual depth of the +reach using the IChannel geometry. get_depth of the reach [m] +Parameters: ----------- area: Wetted area of a river cross section +[m2], can be obtained by V/l, where V is the stored volume and l is +the reach length "; + +%feature("docstring") cmf_core::Channel::get_flux_crossection "def +get_flux_crossection(self, args, kwargs) + +get_flux_crossection(IChannel self, double depth) -> double virtual +double get_flux_crossection(double depth) const =0 Calculates the +wetted area from a given depth using the IChannel geometry. In most +cases use get_flux_crossection=V/l, where V is the stored volume and l +is the reach length Wetted area of a river cross section [m2] +Parameters: ----------- depth: depth of the reach [m] "; + +%feature("docstring") cmf_core::Channel::get_length "def +get_length(self, args, kwargs) + +get_length(IChannel self) -> double virtual double get_length() const +=0 Length of the reach. "; + +%feature("docstring") cmf_core::Channel::get_nManning "def +get_nManning(self, args, kwargs) + +get_nManning(IChannel self) -> double virtual double get_nManning() +const =0 "; + +%feature("docstring") cmf_core::Channel::get_wetted_perimeter "def +get_wetted_perimeter(self, args, kwargs) + +get_wetted_perimeter(IChannel self, double depth) -> double virtual +double get_wetted_perimeter(double depth) const =0 Calculates the +wetted perimeter from a given actual depth [m] using the actual +IChannel geometry. "; + +%feature("docstring") cmf_core::Channel::h "def h(self, args, +kwargs) + +h(IVolumeHeightFunction self, double V) -> double virtual double +h(double V) const =0 Returns the depth of a given volume. "; + +%feature("docstring") cmf_core::Channel::q "def q(self, args, +kwargs) + +q(IVolumeHeightFunction self, double h, double slope) -> double +virtual double q(double h, double slope) const "; + +%feature("docstring") cmf_core::Channel::qManning "def +qManning(self, args, kwargs) + +qManning(IChannel self, double A, double slope) -> double virtual +double qManning(double A, double slope) const Calculates the flow +rate from a given water volume in the reach .. math:: q_{Manning}&=& +A R^{\\\\\\\\frac 2 3} \\\\\\\\sqrt{\\\\\\\\frac {\\\\\\\\Delta_z} +n} \\\\\\\\\\\\\\\\ A &=& \\\\\\\\frac V l \\\\\\\\mbox{, +(Crosssectional area of the wetted crossection, Volume per +length)} \\\\\\\\\\\\\\\\ R &=& \\\\\\\\frac A {P(d)} \\\\\\\\\\\\\\\\ +P(d) &=& \\\\\\\\mbox{ the perimeter of the wetted crosssection, a +function of reach depth} \\\\\\\\\\\\\\\\ d(V) &=& \\\\\\\\mbox{ +the depth of the reach a function of the volume} \\\\\\\\\\\\\\\\ +\\\\\\\\Delta_z &=& \\\\\\\\frac{z_{max} - z_{min}}{l} +\\\\\\\\mbox{ Slope of the reach} . Flow rate [m3/s] Parameters: +----------- A: The area of the cross section [m2] slope: The slope +of the reach [m/m] "; + +%feature("docstring") cmf_core::Channel::set_nManning "def +set_nManning(self, args, kwargs) + +set_nManning(IChannel self, double val) virtual void +set_nManning(double val)=0 "; + +%feature("docstring") cmf_core::Channel::typecode "def +typecode(self, args, kwargs) + +typecode(IChannel self) -> char virtual char typecode() const =0 "; + +%feature("docstring") cmf_core::Channel::V "def V(self, args, +kwargs) + +V(IVolumeHeightFunction self, double h) -> double virtual double +V(double h) const =0 "; + + // File: classcmf_1_1upslope_1_1conductable.xml %feature("docstring") cmf::upslope::conductable " @@ -2026,6 +3769,99 @@ C++ includes: conductable.h "; get_K(cmf::geometry::point direction) const =0 "; +// File: classcmf__core_1_1connection__list.xml +%feature("docstring") cmf_core::connection_list " + +A self sorting list of connections. C++ includes: flux_connection.h +"; + +%feature("docstring") cmf_core::connection_list::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::water::connection_list self) -> connection_list "; + +%feature("docstring") cmf_core::connection_list::__contains__ "def +__contains__(self, args, kwargs) + +__contains__(connection_list self, cmf::water::flux_connection::ptr +const & con) -> bool "; + +%feature("docstring") cmf_core::connection_list::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::connection_list::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::connection_list::__len__ "def +__len__(self, args, kwargs) + +__len__(connection_list self) -> size_t "; + +%feature("docstring") cmf_core::connection_list::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::connection_list::append "def +append(self, args, kwargs) + +append(connection_list self, cmf::water::flux_connection::ptr +connection) -> bool bool append(cmf::water::flux_connection::ptr +connection) "; + +%feature("docstring") cmf_core::connection_list::at "def at(self, +args, kwargs) + +at(connection_list self, size_t pos) -> +cmf::water::flux_connection::ptr cmf::water::flux_connection::ptr +at(size_t pos) const "; + +%feature("docstring") cmf_core::connection_list::begin "def +begin(self, args) + +begin(connection_list self) -> cmf::water::connection_list::iterator +begin(connection_list self) -> +cmf::water::connection_list::const_iterator const_iterator begin() +const "; + +%feature("docstring") cmf_core::connection_list::contains "def +contains(self, args, kwargs) + +contains(connection_list self, cmf::water::flux_connection::ptr +connection) -> bool bool contains(cmf::water::flux_connection::ptr +connection) const "; + +%feature("docstring") cmf_core::connection_list::do_action "def +do_action(self, args, kwargs) + +do_action(connection_list self, Time t, bool use_OpenMP=True) void +do_action(cmf::math::Time t, bool use_OpenMP=true) "; + +%feature("docstring") cmf_core::connection_list::end "def end(self, +args) + +end(connection_list self) -> cmf::water::connection_list::iterator +end(connection_list self) -> +cmf::water::connection_list::const_iterator const_iterator end() +const "; + +%feature("docstring") cmf_core::connection_list::extend "def +extend(self, args, kwargs) + +extend(connection_list self, connection_list connections) void +extend(const connection_list &connections) "; + +%feature("docstring") cmf_core::connection_list::remove "def +remove(self, args, kwargs) + +remove(connection_list self, cmf::water::flux_connection::ptr +connection) -> bool bool remove(cmf::water::flux_connection::ptr +connection) "; + +%feature("docstring") cmf_core::connection_list::size "def +size(self, args, kwargs) + +size(connection_list self) -> size_t size_t size() const "; + + // File: classcmf_1_1water_1_1connection__list.xml %feature("docstring") cmf::water::connection_list " @@ -2066,51 +3902,194 @@ remove(cmf::water::flux_connection::ptr connection) "; size() const "; -// File: classcmf_1_1upslope_1_1_e_t_1_1constant_e_tpot.xml -%feature("docstring") cmf::upslope::ET::constantETpot " - -A constant evapotranspiration. +// File: classcmf__core_1_1constant_e_tpot.xml +%feature("docstring") cmf_core::constantETpot " -Uses a constant measured or elsewhere modelled ETpot. Actual -Evapotranspiration is calculated from rootdepth and actual matrix -potential in the layers using Tact. The value of ETpot can be changed -during runtime +A constant evapotranspiration. Uses a constant measured or elsewhere +modelled ETpot. Actual Evapotranspiration is calculated from rootdepth +and actual matrix potential in the layers using Tact. The value of +ETpot can be changed during runtime C++ includes: ET.h "; -C++ includes: ET.h "; +%feature("docstring") cmf_core::constantETpot::__init__ "def +__init__(self, args, kwargs) -%feature("docstring") cmf::upslope::ET::constantETpot::constantETpot -"constantETpot(cmf::upslope::SoilLayer::ptr source, +__init__(cmf::upslope::ET::constantETpot self, +cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr +ET_target, double constantETpot_value) -> constantETpot +constantETpot(cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target, double constantETpot_value) "; -%feature("docstring") cmf::upslope::ET::constantETpot::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +%feature("docstring") cmf_core::constantETpot::__contains__ "def +__contains__(self, cmp) "; -Returns the concentration of the flux. +%feature("docstring") cmf_core::constantETpot::__eq__ "def +__eq__(self, args, kwargs) -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +__eq__(flux_connection self, flux_connection other) -> bool "; -%feature("docstring") cmf::upslope::ET::constantETpot::ETpot "virtual real ETpot(cmf::math::Time t) const "; +%feature("docstring") cmf_core::constantETpot::__getitem__ "def +__getitem__(self, index) "; -%feature("docstring") -cmf::upslope::ET::constantETpot::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +%feature("docstring") cmf_core::constantETpot::__iter__ "def +__iter__(self) "; -%feature("docstring") cmf::upslope::ET::constantETpot::get_layer "SoilLayer::ptr get_layer() const "; +%feature("docstring") cmf_core::constantETpot::__repr__ "def +__repr__(self) "; -%feature("docstring") cmf::upslope::ET::constantETpot::get_ptr "ptr -get_ptr() const "; +%feature("docstring") cmf_core::constantETpot::conc "def conc(self, +args, kwargs) -%feature("docstring") cmf::upslope::ET::constantETpot::get_target "flux_node::ptr get_target(const flux_node &inquirer) +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -Returns the other end of a connection than the asking end. "; +%feature("docstring") cmf_core::constantETpot::ETpot "def +ETpot(self, args, kwargs) -%feature("docstring") cmf::upslope::ET::constantETpot::get_target "flux_node::ptr get_target(int index) const +ETpot(stressedET self, Time t) -> real virtual real +ETpot(cmf::math::Time t) const "; -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +%feature("docstring") cmf_core::constantETpot::exchange_target "def +exchange_target(self, args, kwargs) -%feature("docstring") +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::constantETpot::get_layer "def +get_layer(self, args, kwargs) + +get_layer(stressedET self) -> cmf::upslope::SoilLayer::ptr +SoilLayer::ptr get_layer() const "; + +%feature("docstring") cmf_core::constantETpot::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::constantETpot::get_tracer_filter "def get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::constantETpot::GetETpot "def +GetETpot(self, args, kwargs) + +GetETpot(constantETpot self, Time t) -> real real +GetETpot(cmf::math::Time t) const "; + +%feature("docstring") cmf_core::constantETpot::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::constantETpot::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::constantETpot::q "def q(self, args, +kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::constantETpot::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::constantETpot::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::constantETpot::set_stressfunction "def set_stressfunction(self, args, kwargs) + +set_stressfunction(stressedET self, RootUptakeStessFunction +stressfunction) void set_stressfunction(const RootUptakeStessFunction +&stressfunction) Sets the stress function to limit water uptake. "; + +%feature("docstring") cmf_core::constantETpot::set_tracer_filter "def set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::constantETpot::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::constantETpot::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf_1_1upslope_1_1_e_t_1_1constant_e_tpot.xml +%feature("docstring") cmf::upslope::ET::constantETpot " + +A constant evapotranspiration. + +Uses a constant measured or elsewhere modelled ETpot. Actual +Evapotranspiration is calculated from rootdepth and actual matrix +potential in the layers using Tact. The value of ETpot can be changed +during runtime + +C++ includes: ET.h "; + +%feature("docstring") cmf::upslope::ET::constantETpot::constantETpot +"constantETpot(cmf::upslope::SoilLayer::ptr source, +cmf::water::flux_node::ptr ET_target, double constantETpot_value) "; + +%feature("docstring") cmf::upslope::ET::constantETpot::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") cmf::upslope::ET::constantETpot::ETpot "virtual real ETpot(cmf::math::Time t) const "; + +%feature("docstring") +cmf::upslope::ET::constantETpot::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf::upslope::ET::constantETpot::get_layer "SoilLayer::ptr get_layer() const "; + +%feature("docstring") cmf::upslope::ET::constantETpot::get_ptr "ptr +get_ptr() const "; + +%feature("docstring") cmf::upslope::ET::constantETpot::get_target "flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") cmf::upslope::ET::constantETpot::get_target "flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") cmf::upslope::ET::constantETpot::get_tracer_filter "real get_tracer_filter() @@ -2219,6 +4198,52 @@ cmf::atmosphere::Weather get_weather(cmf::math::Time t) const Returns weather, regardless of t. "; +// File: classcmf__core_1_1_constant_meteorology.xml +%feature("docstring") cmf_core::ConstantMeteorology " + +A primitive implementation of the Meteorology interface. Holds a +Weather record and returns it for any date C++ includes: +meteorology.h "; + +%feature("docstring") cmf_core::ConstantMeteorology::__init__ "def +__init__(self, args) + +__init__(cmf::atmosphere::ConstantMeteorology self) -> +ConstantMeteorology __init__(cmf::atmosphere::ConstantMeteorology +self, Weather w) -> ConstantMeteorology +__init__(cmf::atmosphere::ConstantMeteorology self, +ConstantMeteorology other) -> ConstantMeteorology +ConstantMeteorology(const cmf::atmosphere::ConstantMeteorology &other) +Copy constructor. "; + +%feature("docstring") cmf_core::ConstantMeteorology::__call__ "def +__call__(self, args, kwargs) + +__call__(Meteorology self, Time t) -> Weather "; + +%feature("docstring") cmf_core::ConstantMeteorology::copy "def +copy(self, args, kwargs) + +copy(ConstantMeteorology self) -> ConstantMeteorology +ConstantMeteorology* copy() const Creates a new instannce of the +ConstantMeteorology with the same weather. "; + +%feature("docstring") +cmf_core::ConstantMeteorology::get_instrument_height "def +get_instrument_height(self, args, kwargs) + +get_instrument_height(Meteorology self) -> real virtual real +get_instrument_height() const =0 Returns the height of the +instruments above canopy. "; + +%feature("docstring") cmf_core::ConstantMeteorology::get_weather "def get_weather(self, args, kwargs) + +get_weather(Meteorology self, Time t) -> Weather virtual +cmf::atmosphere::Weather get_weather(cmf::math::Time t) const =0 +Returns the Weather at time t. Pure virtual function. Must get +implemented by child functions. "; + + // File: classcmf_1_1atmosphere_1_1_constant_rain_source.xml %feature("docstring") cmf::atmosphere::ConstantRainSource " @@ -2351,6 +4376,287 @@ Without: A flux_connection that is excluded from the waterbalance (e.g. to prevent closed circuits) "; +// File: classcmf__core_1_1_constant_rain_source.xml +%feature("docstring") cmf_core::ConstantRainSource " + +A simple implementation of RainSource. Returns intensity for any time +step. C++ includes: precipitation.h "; + +%feature("docstring") cmf_core::ConstantRainSource::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::atmosphere::ConstantRainSource self, project _project, +point location, real _intensity) -> ConstantRainSource +ConstantRainSource(cmf::project &_project, cmf::geometry::point +location, real _intensity) Creates a new ConstantRainSource. Consider +using Cell::set_rainfall for internal creation of a constant rain +source, instead of direct use Parameters: ----------- _project: The +project the rain source is belonging to. location: The location of +the rain source _intensity: The constant rainfall intensity in +mm/day "; + +%feature("docstring") cmf_core::ConstantRainSource::__call__ "def +__call__(self, args, kwargs) + +__call__(RainSource self, Time t) -> real "; + +%feature("docstring") cmf_core::ConstantRainSource::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_node self, flux_node other) -> bool "; + +%feature("docstring") cmf_core::ConstantRainSource::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::ConstantRainSource::conc "def +conc(self, args, kwargs) + +conc(flux_node self, Time t, solute Solute) -> real virtual real +conc(cmf::math::Time t, const cmf::water::solute &Solute) const +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; + +%feature("docstring") cmf_core::ConstantRainSource::connected_nodes "def connected_nodes(self) "; + +%feature("docstring") cmf_core::ConstantRainSource::connection_to "def connection_to(self, args, kwargs) + +connection_to(flux_node self, flux_node target) -> flux_connection +cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) Returns the connection between this and target. "; + +%feature("docstring") cmf_core::ConstantRainSource::flux3d_to "def +flux3d_to(self, args, kwargs) + +flux3d_to(flux_node self, flux_node target, Time t) -> point +cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; + +%feature("docstring") cmf_core::ConstantRainSource::flux_to "def +flux_to(self, args, kwargs) + +flux_to(flux_node self, flux_node target, Time t) -> real real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; + +%feature("docstring") cmf_core::ConstantRainSource::fluxes "def +fluxes(self, t) "; + +%feature("docstring") cmf_core::ConstantRainSource::get_3d_flux "def +get_3d_flux(self, args, kwargs) + +get_3d_flux(flux_node self, Time t) -> point cmf::geometry::point +get_3d_flux(cmf::math::Time t) Returns the sum of all flux vectors. +"; + +%feature("docstring") cmf_core::ConstantRainSource::get_intensity "def get_intensity(self, args, kwargs) + +get_intensity(RainSource self, Time t) -> real virtual real +get_intensity(cmf::math::Time t) const =0 Returns the actual rainfall +intensity in mm/day. "; + +%feature("docstring") cmf_core::ConstantRainSource::is_empty "def +is_empty(self, args, kwargs) + +is_empty(flux_node self) -> double virtual double is_empty() const +Returns true if the node has no water. "; + +%feature("docstring") cmf_core::ConstantRainSource::is_storage "def +is_storage(self, args, kwargs) + +is_storage(flux_node self) -> bool virtual bool is_storage() const +true, if this is a waterstorage "; + +%feature("docstring") cmf_core::ConstantRainSource::RecalcFluxes "def RecalcFluxes(self, args, kwargs) + +RecalcFluxes(flux_node self, Time t) -> bool virtual bool +RecalcFluxes(cmf::math::Time t) Pure flux_nodes do not influence +fluxes, therefore no recalculation of fluxes is required by flux_node. +WaterStorage overrides this, since state changes require an update of +the fluxes "; + +%feature("docstring") cmf_core::ConstantRainSource::remove_connection +"def remove_connection(self, args, kwargs) + +remove_connection(flux_node self, cmf::water::flux_node::ptr To) -> +bool bool remove_connection(cmf::water::flux_node::ptr To) Remove +the connection. "; + +%feature("docstring") cmf_core::ConstantRainSource::set_conc "def +set_conc(self, args, kwargs) + +set_conc(ConstantRainSource self, solute Solute, real value) void +set_conc(const cmf::water::solute &Solute, real value) Sets the +concentration of a solute in the rainfall. "; + +%feature("docstring") cmf_core::ConstantRainSource::to_string "def +to_string(self, args, kwargs) + +to_string(flux_node self) -> std::string virtual std::string +to_string() const "; + +%feature("docstring") cmf_core::ConstantRainSource::waterbalance "def waterbalance(self, args, kwargs) + +waterbalance(flux_node self, Time t, flux_connection Without=None) -> +real real waterbalance(cmf::math::Time t, const flux_connection +*Without=0) const Returns the sum of all fluxes (positive and +negative) at time t. Single fluxes can be excluded from the +calculation Parameters: ----------- t: Time of the query Without: +A flux_connection that is excluded from the waterbalance (e.g. to +prevent closed circuits) "; + + +// File: classcmf__core_1_1constraint__kinematic__wave.xml +%feature("docstring") cmf_core::constraint_kinematic_wave " + +Calculates flux out of a storage as a linear function of its volume to +a power, constraint by the volume stored in the target storage. +Deprecated Will be replaced by ConstraintLinearStorageConnection, +without beta and gamma. .. math:: q = \\\\\\\\frac 1 {t_r} +{\\\\\\\\left(\\\\\\\\frac{V_{l} - V_{residual}}{V_0} +\\\\\\\\right)^\\\\\\\\beta} +\\\\\\\\left(\\\\\\\\frac{V_{r,max}-V_{r}}{V_{r,max}}\\\\\\\\right)^\\\\\\\\gamma +where: :math:`V_l` The actual volume stored by the left water storage +:math:`V_{residual} [m^3]` The volume of water not flowing out +(default = 0) :math:`V_0` The reference volume to scale the exponent +(default = 1m3/day) :math:`\\\\\\\\beta` A parameter to shape the +response curve. In case of :math:`\\\\\\\\beta \\\\\\\\neq 1`, +:math:`t_r` is not a residence time, but just a parameter. :math:`t_r +[days]` The residence time of the water in this storage in days +:math:`V_{r,max}` The capacity of the right water storage in m3 +:math:`V_{r}` The actual volume of the right water storage +:math:`\\\\\\\\gamma` A shape parameter for the target capacity +constriction C++ includes: simple_connections.h "; + +%feature("docstring") cmf_core::constraint_kinematic_wave::__init__ "def __init__(self, args, kwargs) + +__init__(cmf::water::constraint_kinematic_wave self, +cmf::water::WaterStorage::ptr source, cmf::water::WaterStorage::ptr +target, real residencetime=1.0, real exponent=1.0, real residual=0.0, +real V0=1.0, real Vrmax=1.0, real gamma=1.0) -> +constraint_kinematic_wave constraint_kinematic_wave(WaterStorage::ptr +source, WaterStorage::ptr target, real residencetime=1.0, real +exponent=1.0, real residual=0.0, real V0=1.0, real Vrmax=1.0, real +gamma=1.0) Creates a kinematic wave connection. .. math:: q += \\\\\\\\frac 1 {t_r} {\\\\\\\\left(\\\\\\\\frac{V - +V_{residual}}{V_0} \\\\\\\\right)^\\\\\\\\beta} Parameters: +----------- source: Water storage from which the water flows out. +Flux is a function of source.volume target: Target node (boundary +condition or storage). Does not influence the strength of the flow +residencetime: :math:`t_r [days]` The residence time of the water in +this storage exponent: :math:`\\\\\\\\beta [-]` An empirical +exponent to shape the flux function (default = 1 (linear function)) +residual: :math:`V_{residual} [m^3]` The volume of water not flowing +out (default = 0) V0: :math:`V_0` The reference volume to scale the +exponent Vrmax: :math:`V_{r,max}` Capacity of the target water +storage in m3 gamma: :math:`\\\\\\\\gamma` Target capacity +constriction curve shape "; + +%feature("docstring") +cmf_core::constraint_kinematic_wave::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::constraint_kinematic_wave::__eq__ "def __eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") +cmf_core::constraint_kinematic_wave::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::constraint_kinematic_wave::__iter__ "def __iter__(self) "; + +%feature("docstring") cmf_core::constraint_kinematic_wave::__repr__ "def __repr__(self) "; + +%feature("docstring") cmf_core::constraint_kinematic_wave::conc "def +conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") +cmf_core::constraint_kinematic_wave::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::constraint_kinematic_wave::get_target +"def get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") +cmf_core::constraint_kinematic_wave::get_tracer_filter "def +get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::constraint_kinematic_wave::kill_me "def kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::constraint_kinematic_wave::left_node +"def left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::constraint_kinematic_wave::q "def +q(self, args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::constraint_kinematic_wave::refresh "def refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::constraint_kinematic_wave::right_node +"def right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") +cmf_core::constraint_kinematic_wave::set_tracer_filter "def +set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf_core::constraint_kinematic_wave::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::constraint_kinematic_wave::to_string +"def to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + // File: classcmf_1_1water_1_1constraint__kinematic__wave.xml %feature("docstring") cmf::water::constraint_kinematic_wave " @@ -2518,72 +4824,233 @@ cmf::water::constraint_kinematic_wave::to_string "virtual std::string to_string() const "; -// File: classcmf_1_1water_1_1_constraint_linear_storage_connection.xml -%feature("docstring") cmf::water::ConstraintLinearStorageConnection " +// File: classcmf__core_1_1_constraint_linear_storage_connection.xml +%feature("docstring") cmf_core::ConstraintLinearStorageConnection " Calculates flux out of a storage as a linear function of its volume, -constraint by the volume stored in the target storage. +constraint by the volume stored in the target storage. .. math:: q += \\\\\\\\frac {1}{t_r} \\\\\\\\left({V_{l} - V_{l,min}}\\\\\\\\right) +\\\\\\\\cdot +\\\\\\\\left(\\\\\\\\frac{V_{r,max}-V_{r}}{V_{r,max}}\\\\\\\\right) +where: :math:`V_l` The actual volume stored by the left water storage +:math:`V_{l,min} [m^3]` The volume of water not flowing out (default = +0) :math:`\\\\\\\\beta` A parameter to shape the response curve. In +case of :math:`\\\\\\\\beta \\\\\\\\neq 1`, :math:`t_r` is not a +residence time, but just a parameter. :math:`t_r [days]` The +residence time of the water in this storage in days :math:`V_{r,max}` +The capacity of the right water storage in m3 :math:`V_{r}` The +actual volume of the right water storage :math:`\\\\\\\\gamma` A +shape parameter for the target capacity constriction C++ includes: +simple_connections.h "; + +%feature("docstring") +cmf_core::ConstraintLinearStorageConnection::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::water::ConstraintLinearStorageConnection self, +cmf::water::WaterStorage::ptr source, cmf::water::WaterStorage::ptr +target, real residencetime=1.0, real Vlmin=0.0, real Vrmax=1.0) -> +ConstraintLinearStorageConnection +ConstraintLinearStorageConnection(WaterStorage::ptr source, +WaterStorage::ptr target, real residencetime=1.0, real Vlmin=0.0, real +Vrmax=1.0) Creates a linear storage connection, constrained by the +fill level of the source .. math:: q = \\\\\\\\frac 1 {t_r} +{\\\\\\\\left(\\\\\\\\frac{V - V_{residual}}{V_0} +\\\\\\\\right)^\\\\\\\\beta} . Parameters: ----------- source: +Water storage from which the water flows out. Flux is a function of +source.volume target: Target node (boundary condition or storage). +Does not influence the strength of the flow residencetime: :math:`t_r +[days]` The residence time of the water in this storage Vlmin: +:math:`V_{l,min} [m^3]` The volume of water not flowing out (default = +0) Vrmax: :math:`V_{r,max}` Capacity of the target water storage in +m3 "; +%feature("docstring") +cmf_core::ConstraintLinearStorageConnection::__contains__ "def +__contains__(self, cmp) "; +%feature("docstring") +cmf_core::ConstraintLinearStorageConnection::__eq__ "def __eq__(self, +args, kwargs) -.. math:: +__eq__(flux_connection self, flux_connection other) -> bool "; - q = \\\\frac {1}{t_r} \\\\left({V_{l} - V_{l,min}}\\\\right) - \\\\cdot \\\\left(\\\\frac{V_{r,max}-V_{r}}{V_{r,max}}\\\\right) +%feature("docstring") +cmf_core::ConstraintLinearStorageConnection::__getitem__ "def +__getitem__(self, index) "; -where: :math:`V_l` The actual volume stored by the left water storage +%feature("docstring") +cmf_core::ConstraintLinearStorageConnection::__iter__ "def +__iter__(self) "; -:math:`V_{l,min} [m^3]` The volume of water not flowing out (default = 0) +%feature("docstring") +cmf_core::ConstraintLinearStorageConnection::__repr__ "def +__repr__(self) "; -:math:`\\\\beta` A parameter to shape the response curve. In case of -:math:`\\\\beta \\\\neq 1`, :math:`t_r` is not a residence time, but just a -parameter. +%feature("docstring") +cmf_core::ConstraintLinearStorageConnection::conc "def conc(self, +args, kwargs) -:math:`t_r [days]` The residence time of the water in this storage in days +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -:math:`V_{r,max}` The capacity of the right water storage in m3 +%feature("docstring") +cmf_core::ConstraintLinearStorageConnection::exchange_target "def +exchange_target(self, args, kwargs) -:math:`V_{r}` The actual volume of the right water storage +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -:math:`\\\\gamma` A shape parameter for the target capacity constriction +%feature("docstring") +cmf_core::ConstraintLinearStorageConnection::get_target "def +get_target(self, args) -C++ includes: simple_connections.h "; +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; %feature("docstring") -cmf::water::ConstraintLinearStorageConnection::ConstraintLinearStorageConnection -"ConstraintLinearStorageConnection(WaterStorage::ptr source, -WaterStorage::ptr target, real residencetime=1.0, real Vlmin=0.0, real -Vrmax=1.0) - -Creates a linear storage connection, constrained by the fill level of -the source +cmf_core::ConstraintLinearStorageConnection::get_tracer_filter "def +get_tracer_filter(self, args) -.. math:: +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; - q = \\\\frac 1 {t_r} {\\\\left(\\\\frac{V - - V_{residual}}{V_0} \\\\right)^\\\\beta} +%feature("docstring") +cmf_core::ConstraintLinearStorageConnection::kill_me "def +kill_me(self, args, kwargs) -. +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -Parameters: ------------ +%feature("docstring") +cmf_core::ConstraintLinearStorageConnection::left_node "def +left_node(self, args, kwargs) -source: Water storage from which the water flows out. Flux is a -function of source.volume +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -target: Target node (boundary condition or storage). Does not -influence the strength of the flow +%feature("docstring") cmf_core::ConstraintLinearStorageConnection::q +"def q(self, args, kwargs) -residencetime: :math:`t_r [days]` The residence time of the water in this -storage +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; -Vlmin: :math:`V_{l,min} [m^3]` The volume of water not flowing out -(default = 0) +%feature("docstring") +cmf_core::ConstraintLinearStorageConnection::refresh "def +refresh(self, args, kwargs) -Vrmax: :math:`V_{r,max}` Capacity of the target water storage in m3 "; +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; %feature("docstring") -cmf::water::ConstraintLinearStorageConnection::conc "real +cmf_core::ConstraintLinearStorageConnection::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") +cmf_core::ConstraintLinearStorageConnection::set_tracer_filter "def +set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf_core::ConstraintLinearStorageConnection::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") +cmf_core::ConstraintLinearStorageConnection::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf_1_1water_1_1_constraint_linear_storage_connection.xml +%feature("docstring") cmf::water::ConstraintLinearStorageConnection " + +Calculates flux out of a storage as a linear function of its volume, +constraint by the volume stored in the target storage. + + + +.. math:: + + q = \\\\frac {1}{t_r} \\\\left({V_{l} - V_{l,min}}\\\\right) + \\\\cdot \\\\left(\\\\frac{V_{r,max}-V_{r}}{V_{r,max}}\\\\right) + +where: :math:`V_l` The actual volume stored by the left water storage + +:math:`V_{l,min} [m^3]` The volume of water not flowing out (default = 0) + +:math:`\\\\beta` A parameter to shape the response curve. In case of +:math:`\\\\beta \\\\neq 1`, :math:`t_r` is not a residence time, but just a +parameter. + +:math:`t_r [days]` The residence time of the water in this storage in days + +:math:`V_{r,max}` The capacity of the right water storage in m3 + +:math:`V_{r}` The actual volume of the right water storage + +:math:`\\\\gamma` A shape parameter for the target capacity constriction + +C++ includes: simple_connections.h "; + +%feature("docstring") +cmf::water::ConstraintLinearStorageConnection::ConstraintLinearStorageConnection +"ConstraintLinearStorageConnection(WaterStorage::ptr source, +WaterStorage::ptr target, real residencetime=1.0, real Vlmin=0.0, real +Vrmax=1.0) + +Creates a linear storage connection, constrained by the fill level of +the source + +.. math:: + + q = \\\\frac 1 {t_r} {\\\\left(\\\\frac{V - + V_{residual}}{V_0} \\\\right)^\\\\beta} + +. + +Parameters: +----------- + +source: Water storage from which the water flows out. Flux is a +function of source.volume + +target: Target node (boundary condition or storage). Does not +influence the strength of the flow + +residencetime: :math:`t_r [days]` The residence time of the water in this +storage + +Vlmin: :math:`V_{l,min} [m^3]` The volume of water not flowing out +(default = 0) + +Vrmax: :math:`V_{r,max}` Capacity of the target water storage in m3 "; + +%feature("docstring") +cmf::water::ConstraintLinearStorageConnection::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns the concentration of the flux. @@ -2674,6 +5141,58 @@ cmf::water::ConstraintLinearStorageConnection::to_string "virtual std::string to_string() const "; +// File: classcmf__core_1_1_content_stress.xml +%feature("docstring") cmf_core::ContentStress " + +A simple water content based stress model based on Feddes (1978) +stress a is piecewise linear function based on water content if +:math:`\\\\\\\\theta>\\\\\\\\theta_d \\\\\\\\rightarrow ET = ET_{pot}` +if :math:`\\\\\\\\theta_d>\\\\\\\\theta > \\\\\\\\theta_{wilt} +\\\\\\\\rightarrow ET = \\\\\\\\frac{\\\\\\\\theta_d - +\\\\\\\\theta}{\\\\\\\\theta_d - \\\\\\\\theta_{wilt}} ET_{pot}` if +:math:`\\\\\\\\theta_{wilt}>\\\\\\\\theta \\\\\\\\rightarrow ET = 0.0` +The parameters :math:`\\\\\\\\theta_{d,w}` can be omitted (or set to a +negative value) to use default values derived from the layer +properties. The critical water content (where stress starts) is then +defined (conf. Feddes 1978) as the center between field capacity ( +:math:`\\\\\\\\theta_{fc}`) and the wilting point ( +:math:`\\\\\\\\theta_{wp}`). :math:`\\\\\\\\theta_w = +\\\\\\\\theta(pF=4.2)`: Water content at pF=4.2 :math:`\\\\\\\\theta_d += 1/2 (\\\\\\\\theta(pF=1.8) + \\\\\\\\theta(pF=4.2))` C++ includes: +waterstress.h "; + +%feature("docstring") cmf_core::ContentStress::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::ET::ContentStress self, real theta_d=-1, real +theta_w=-1) -> ContentStress ContentStress(real theta_d=-1, real +theta_w=-1) Creates a new ContentStress for critical water content +theta_d in vol Water/vol Soil and wilting point theta_w. "; + +%feature("docstring") cmf_core::ContentStress::copy "def copy(self, +args, kwargs) + +copy(ContentStress self) -> ContentStress +cmf::upslope::ET::ContentStress* copy() const Creates a new copy of +this wetness. "; + +%feature("docstring") cmf_core::ContentStress::Tact "def Tact(self, +args, kwargs) + +Tact(RootUptakeStessFunction self, stressedET connection, real Tpot) +-> real virtual real Tact(const stressedET *connection, real Tpot) +const =0 Calculates the water stress for a layer. Parameters: +----------- connection: The stressedET connection this stress +function belongs to Tpot: Potential Transpiration in mm/day (for the +full profile) Actual flux from layer in m3/day "; + +%feature("docstring") cmf_core::ContentStress::to_string "def +to_string(self, args, kwargs) + +to_string(RootUptakeStessFunction self) -> std::string virtual +std::string to_string() const =0 "; + + // File: classcmf_1_1upslope_1_1_e_t_1_1_content_stress.xml %feature("docstring") cmf::upslope::ET::ContentStress " @@ -2834,6 +5353,170 @@ typecode() const "; double V(double h) const "; +// File: classcmf__core_1_1_cross_section_reach.xml +%feature("docstring") cmf_core::CrossSectionReach " + +Structure for the description of reaches with a freely defined cross +section. Although double triangular cross section reach are rarely +met, a triangular reach does scale with its water load, and is +therefore preferable in case where nothing about IChannel geometry is +known C++ includes: cross_section_reach.h "; + +%feature("docstring") cmf_core::CrossSectionReach::__init__ "def +__init__(self, args) + +__init__(cmf::river::CrossSectionReach self, double l, +cmf::math::num_array x, cmf::math::num_array depth) -> +CrossSectionReach __init__(cmf::river::CrossSectionReach self, +CrossSectionReach copy) -> CrossSectionReach CrossSectionReach(const +CrossSectionReach ©) "; + +%feature("docstring") cmf_core::CrossSectionReach::A "def A(self, +args, kwargs) + +A(IVolumeHeightFunction self, double V) -> double virtual double +A(double V) const =0 Returns the area of the surface for a given +volume. "; + +%feature("docstring") cmf_core::CrossSectionReach::check_iterator "def check_iterator(self, args, kwargs) + +check_iterator(CrossSectionReach self, double h) void +check_iterator(double h) const "; + +%feature("docstring") cmf_core::CrossSectionReach::copy "def +copy(self, args, kwargs) + +copy(CrossSectionReach self) -> CrossSectionReach CrossSectionReach* +copy() const "; + +%feature("docstring") cmf_core::CrossSectionReach::get_channel_width +"def get_channel_width(self, args, kwargs) + +get_channel_width(IChannel self, double depth) -> double virtual +double get_channel_width(double depth) const =0 Calculates the flow +width from a given actual depth [m] using the actual IChannel +geometry. "; + +%feature("docstring") cmf_core::CrossSectionReach::get_depth "def +get_depth(self, args, kwargs) + +get_depth(IChannel self, double area) -> double virtual double +get_depth(double area) const =0 Calculates the actual depth of the +reach using the IChannel geometry. get_depth of the reach [m] +Parameters: ----------- area: Wetted area of a river cross section +[m2], can be obtained by V/l, where V is the stored volume and l is +the reach length "; + +%feature("docstring") +cmf_core::CrossSectionReach::get_flux_crossection "def +get_flux_crossection(self, args, kwargs) + +get_flux_crossection(IChannel self, double depth) -> double virtual +double get_flux_crossection(double depth) const =0 Calculates the +wetted area from a given depth using the IChannel geometry. In most +cases use get_flux_crossection=V/l, where V is the stored volume and l +is the reach length Wetted area of a river cross section [m2] +Parameters: ----------- depth: depth of the reach [m] "; + +%feature("docstring") cmf_core::CrossSectionReach::get_length "def +get_length(self, args, kwargs) + +get_length(IChannel self) -> double virtual double get_length() const +=0 Length of the reach. "; + +%feature("docstring") cmf_core::CrossSectionReach::get_nManning "def +get_nManning(self, args, kwargs) + +get_nManning(IChannel self) -> double virtual double get_nManning() +const =0 "; + +%feature("docstring") +cmf_core::CrossSectionReach::get_wetted_perimeter "def +get_wetted_perimeter(self, args, kwargs) + +get_wetted_perimeter(IChannel self, double depth) -> double virtual +double get_wetted_perimeter(double depth) const =0 Calculates the +wetted perimeter from a given actual depth [m] using the actual +IChannel geometry. "; + +%feature("docstring") cmf_core::CrossSectionReach::h "def h(self, +args, kwargs) + +h(IVolumeHeightFunction self, double V) -> double virtual double +h(double V) const =0 Returns the depth of a given volume. "; + +%feature("docstring") cmf_core::CrossSectionReach::q "def q(self, +args, kwargs) + +q(IVolumeHeightFunction self, double h, double slope) -> double +virtual double q(double h, double slope) const "; + +%feature("docstring") cmf_core::CrossSectionReach::qManning "def +qManning(self, args, kwargs) + +qManning(IChannel self, double A, double slope) -> double virtual +double qManning(double A, double slope) const Calculates the flow +rate from a given water volume in the reach .. math:: q_{Manning}&=& +A R^{\\\\\\\\frac 2 3} \\\\\\\\sqrt{\\\\\\\\frac {\\\\\\\\Delta_z} +n} \\\\\\\\\\\\\\\\ A &=& \\\\\\\\frac V l \\\\\\\\mbox{, +(Crosssectional area of the wetted crossection, Volume per +length)} \\\\\\\\\\\\\\\\ R &=& \\\\\\\\frac A {P(d)} \\\\\\\\\\\\\\\\ +P(d) &=& \\\\\\\\mbox{ the perimeter of the wetted crosssection, a +function of reach depth} \\\\\\\\\\\\\\\\ d(V) &=& \\\\\\\\mbox{ +the depth of the reach a function of the volume} \\\\\\\\\\\\\\\\ +\\\\\\\\Delta_z &=& \\\\\\\\frac{z_{max} - z_{min}}{l} +\\\\\\\\mbox{ Slope of the reach} . Flow rate [m3/s] Parameters: +----------- A: The area of the cross section [m2] slope: The slope +of the reach [m/m] "; + +%feature("docstring") cmf_core::CrossSectionReach::set_nManning "def +set_nManning(self, args, kwargs) + +set_nManning(IChannel self, double val) virtual void +set_nManning(double val)=0 "; + +%feature("docstring") cmf_core::CrossSectionReach::typecode "def +typecode(self, args, kwargs) + +typecode(IChannel self) -> char virtual char typecode() const =0 "; + +%feature("docstring") cmf_core::CrossSectionReach::V "def V(self, +args, kwargs) + +V(IVolumeHeightFunction self, double h) -> double virtual double +V(double h) const =0 "; + + +// File: classcmf__core_1_1cubicspline.xml +%feature("docstring") cmf_core::cubicspline " + +Interpolates points with a cubic spline interpolation. Code is +modified after:http://ganeshtiwaridotcomdotnp.blogspot.de/2009/12/c-c- +code- cubic- spline-interpolation.html C++ includes: spline.h "; + +%feature("docstring") cmf_core::cubicspline::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::math::cubicspline self, cmf::math::num_array const & x, +cmf::math::num_array const & y) -> cubicspline cubicspline(const +cmf::math::num_array &x, const cmf::math::num_array &y) "; + +%feature("docstring") cmf_core::cubicspline::__call__ "def +__call__(self, args, kwargs) + +__call__(cubicspline self, real x) -> real "; + +%feature("docstring") cmf_core::cubicspline::generate "def +generate(self, args, kwargs) + +generate(cubicspline self) void generate() "; + +%feature("docstring") cmf_core::cubicspline::size "def size(self, +args, kwargs) + +size(cubicspline self) -> size_t size_t size() const "; + + // File: classcmf_1_1math_1_1cubicspline.xml %feature("docstring") cmf::math::cubicspline " @@ -2855,52 +5538,222 @@ generate() "; const "; -// File: struct_c_v_band_prec_data_rec.xml -%feature("docstring") CVBandPrecDataRec ""; +// File: classcmf__core_1_1_c_vode_adams.xml +%feature("docstring") cmf_core::CVodeAdams " + +Explizit multistep solver using CVode. C++ includes: cvode3.h "; + +%feature("docstring") cmf_core::CVodeAdams::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::math::CVodeAdams self, StateVariableOwner states, real +epsilon=1e-9) -> CVodeAdams CVodeAdams(cmf::math::StateVariableOwner +&states, real epsilon=1e-9) "; + +%feature("docstring") cmf_core::CVodeAdams::__call__ "def +__call__(self, t, dt=None, reset=False) + +Advances the integration until `t` A shortcut to .integrate_until +Parameters ---------- t : cmf.Time The time step to advance to. If +t < current time, the solver will advance to self.t + t dt : +cmf.Time, optional The timestep for the integration. If not given +try to integrate in one step reset : bool, optional If True, the +solver will perform a reset before starting Returns ------- cmf.Time +The new time stamp "; + +%feature("docstring") cmf_core::CVodeAdams::__getitem__ "def +__getitem__(self, args, kwargs) + +__getitem__(Integrator self, long position) -> +cmf::math::StateVariable::ptr "; + +%feature("docstring") cmf_core::CVodeAdams::__len__ "def +__len__(self, args, kwargs) + +__len__(Integrator self) -> size_t "; + +%feature("docstring") cmf_core::CVodeAdams::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::CVodeAdams::add_single_state "def +add_single_state(self, args, kwargs) + +add_single_state(Integrator self, cmf::math::StateVariable::ptr state) +virtual void add_single_state(cmf::math::StateVariable::ptr state) +Adds a single state variable to the integrator. "; + +%feature("docstring") cmf_core::CVodeAdams::add_states "def +add_states(self, args, kwargs) + +add_states(Integrator self, StateVariableOwner stateOwner) virtual +void add_states(cmf::math::StateVariableOwner &stateOwner) Add state +variables from a StateVariableOwner. "; + +%feature("docstring") cmf_core::CVodeAdams::copy "def copy(self, +args, kwargs) + +copy(CVodeBase self) -> CVodeBase virtual Integrator* copy() const =0 +Polymorphic copy constructor. "; + +%feature("docstring") cmf_core::CVodeAdams::get_dt "def get_dt(self, +args, kwargs) + +get_dt(Integrator self) -> Time cmf::math::Time get_dt() const +Returns the last time step. "; + +%feature("docstring") cmf_core::CVodeAdams::get_dxdt "def +get_dxdt(self, args, kwargs) + +get_dxdt(Integrator self, Time time) -> cmf::math::num_array +cmf::math::num_array get_dxdt(Time time) const "; +%feature("docstring") cmf_core::CVodeAdams::get_error "def +get_error(self, args, kwargs) -// File: struct_c_v_b_b_d_prec_data_rec.xml -%feature("docstring") CVBBDPrecDataRec ""; +get_error(CVodeBase self) -> cmf::math::num_array "; +%feature("docstring") cmf_core::CVodeAdams::get_info "def +get_info(self, args, kwargs) -// File: struct_c_v_diag_mem_rec.xml -%feature("docstring") CVDiagMemRec ""; +get_info(CVodeBase self) -> CVodeInfo "; +%feature("docstring") cmf_core::CVodeAdams::get_jacobian "def +get_jacobian(self) "; -// File: struct_c_v_dls_mem_rec.xml -%feature("docstring") CVDlsMemRec ""; +%feature("docstring") cmf_core::CVodeAdams::get_state "def +get_state(self, args, kwargs) +get_state(Integrator self, ptrdiff_t position) -> real real +get_state(ptrdiff_t position) const Returns the statevariable at +position Simplifies the assessment of state variables. "; -// File: classcmf_1_1math_1_1_c_vode_integrator.xml -%feature("docstring") cmf::math::CVodeIntegrator " +%feature("docstring") cmf_core::CVodeAdams::get_states "def +get_states(self, args) -A wrapper class for the CVODE integrator from the SUNDIALS library. +get_states(Integrator self) -> cmf::math::num_array +get_states(Integrator self) -> StateVariableList StateVariableList +get_states() gets the state variables of the integrator "; -https://computation.llnl.gov/casc/sundials/main.html +%feature("docstring") cmf_core::CVodeAdams::get_t "def get_t(self, +args, kwargs) -C++ includes: cvodeintegrator.h "; +get_t(Integrator self) -> Time cmf::math::Time get_t() const Returns +the current model time. "; + +%feature("docstring") cmf_core::CVodeAdams::initialize "def +initialize(self, args, kwargs) + +initialize(CVodeBase self) -> int "; + +%feature("docstring") cmf_core::CVodeAdams::integrate "def +integrate(self, args, kwargs) + +integrate(Integrator self, Time t_max, Time dt) -> int virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt)=0 Integrates the +vector of state variables. Parameters: ----------- t_max: To stop +the model (if running in a model framework) at time steps of value +exchange e.g. full hours, the next value exchange time can be given +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; + +%feature("docstring") cmf_core::CVodeAdams::integrate_until "def +integrate_until(self, args, kwargs) + +integrate_until(Integrator self, Time t_max, Time dt, bool +reset=False) void integrate_until(cmf::math::Time t_max, +cmf::math::Time dt=Time(), bool reset=false) Integrates the vector of +state variables until t_max. Parameters: ----------- t_max: Time, +the solver should run to dt: Time step (may be omitted) reset: If +true, solver is reseted before integration starts "; + +%feature("docstring") cmf_core::CVodeAdams::reset "def reset(self, +args, kwargs) + +reset(Integrator self) virtual void reset() Resets any saved history +(for multistep methods) "; + +%feature("docstring") cmf_core::CVodeAdams::run "def run(self, +start=None, end=None, step=day *1, max_errors=0, reset=False) + +Returns an iterator over the timesteps start..end **Examples:** >>> +solver=cmf.CVodeIntegrator(...) >>> for t in solver.run(solver.t, +solver.t + cmf.week, cmf.h): >>> print(t, solver[0].state) or with +list comprehension >>> states = [solver[0].state for t in +solver.run(solver.t, solver.t + cmf.week, cmf.h)] Parameters +---------- start : cmf.Time, optional Start time for the solver +iteration end : cmf.Time, optional End time of the iteration step : +cmf.Time, optional Step size for the integration max_errors: int +Number of tolerated errors. If >0, up to these number of runtime +errors will be saved with their time and the integration proceeds +after a reset of the solver. Some systems operate with values close to +their physical limits and inifinite values in the integration can +easily occur. For these kind of systems set max_errors to eg. 10. A +larger number of errors should be eliminated usually. reset: bool If +True, the solver performs a `reset` at every time step Yields ------ +cmf.Time the actual timestep "; + +%feature("docstring") cmf_core::CVodeAdams::set_error_msg "def +set_error_msg(self, args, kwargs) + +set_error_msg(CVodeBase self, std::string error) "; + +%feature("docstring") cmf_core::CVodeAdams::set_state "def +set_state(self, args, kwargs) + +set_state(Integrator self, ptrdiff_t position, real newState) void +set_state(ptrdiff_t position, real newState) Simplifies the +assessment of state variables. "; + +%feature("docstring") cmf_core::CVodeAdams::set_t "def set_t(self, +args, kwargs) + +set_t(Integrator self, Time val) void set_t(cmf::math::Time val) Sets +the current model time. "; + +%feature("docstring") cmf_core::CVodeAdams::size "def size(self, +args, kwargs) + +size(Integrator self) -> size_t size_t size() const returns the +number of state variables "; + +%feature("docstring") cmf_core::CVodeAdams::to_string "def +to_string(self, args, kwargs) + +to_string(CVodeBase self) -> std::string "; + + +// File: classcmf_1_1math_1_1_c_vode_adams.xml +%feature("docstring") cmf::math::CVodeAdams " + +Explizit multistep solver using CVode. + +C++ includes: cvode.h "; /* Accuracy parameters */ /* model time */ -%feature("docstring") cmf::math::CVodeIntegrator::get_t "cmf::math::Time get_t() const +%feature("docstring") cmf::math::CVodeAdams::get_t "cmf::math::Time +get_t() const Returns the current model time. "; -%feature("docstring") cmf::math::CVodeIntegrator::set_t "void +%feature("docstring") cmf::math::CVodeAdams::set_t "void set_t(cmf::math::Time val) Sets the current model time. "; -%feature("docstring") cmf::math::CVodeIntegrator::get_dt "cmf::math::Time get_dt() const +%feature("docstring") cmf::math::CVodeAdams::get_dt "cmf::math::Time +get_dt() const Returns the last time step. "; /* Integrate */ -%feature("docstring") cmf::math::CVodeIntegrator::integrate_until "void integrate_until(cmf::math::Time t_max, cmf::math::Time dt=Time(), -bool reset=false) +%feature("docstring") cmf::math::CVodeAdams::integrate_until "void +integrate_until(cmf::math::Time t_max, cmf::math::Time dt=Time(), bool +reset=false) Integrates the vector of state variables until t_max. @@ -2913,59 +5766,36 @@ dt: Time step (may be omitted) reset: If true, solver is reseted before integration starts "; -%feature("docstring") cmf::math::CVodeIntegrator::CVodeIntegrator "CVodeIntegrator(real epsilon=1e-9, char _preconditioner='R') - -Create a new CVODE integrator. - -Parameters: ------------ - -epsilon: relative and absolute error tolerance - -_preconditioner: [R]ight, [L]eft, [B]oth side Krylov preconditioner -or [N]o preconditioner "; - -%feature("docstring") cmf::math::CVodeIntegrator::CVodeIntegrator "CVodeIntegrator(cmf::math::StateVariableOwner &states, real -epsilon=1e-9, char _preconditioner='R') - -Create a new CVODE integrator. - -Parameters: ------------ - -states: State variables to be added to the integrator - -epsilon: relative and absolute error tolerance - -_preconditioner: [R]ight, [L]eft, [B]oth side Krylov preconditioner -or [N]o preconditioner "; +%feature("docstring") cmf::math::CVodeAdams::CVodeAdams "CVodeAdams(cmf::math::StateVariableOwner &states, real epsilon=1e-9) +"; -%feature("docstring") cmf::math::CVodeIntegrator::CVodeIntegrator "CVodeIntegrator(const CVodeIntegrator &templ) +%feature("docstring") cmf::math::CVodeAdams::_get_jacobian "virtual +cmf::math::num_array _get_jacobian() const -copy constructor, creates a new CVODE integrator similiar to the -given, but without statevariables "; +Returns a continuous 1D array representing the Jacobian columns +concatenated. -%feature("docstring") cmf::math::CVodeIntegrator::~CVodeIntegrator "virtual ~CVodeIntegrator() "; +In Python, get_jacobian returns the Jacobian as a 2D array "; -%feature("docstring") cmf::math::CVodeIntegrator::add_single_state "virtual void add_single_state(cmf::math::StateVariable::ptr state) +%feature("docstring") cmf::math::CVodeAdams::add_single_state "virtual void add_single_state(cmf::math::StateVariable::ptr state) Adds a single state variable to the integrator. "; -%feature("docstring") cmf::math::CVodeIntegrator::add_states "virtual void add_states(cmf::math::StateVariableOwner &stateOwner) +%feature("docstring") cmf::math::CVodeAdams::add_states "virtual +void add_states(cmf::math::StateVariableOwner &stateOwner) Add state variables from a StateVariableOwner. "; -%feature("docstring") -cmf::math::CVodeIntegrator::add_values_to_states "void -add_values_to_states(const num_array &operands) +%feature("docstring") cmf::math::CVodeAdams::add_values_to_states "void add_values_to_states(const num_array &operands) Adds the values in operands to the current states. "; -%feature("docstring") cmf::math::CVodeIntegrator::copy "CVodeIntegrator* copy() const +%feature("docstring") cmf::math::CVodeAdams::copy "CVodeBase* copy() +const -Polymorphic copy constructor. "; +Returns a copy of the solver. "; -%feature("docstring") cmf::math::CVodeIntegrator::copy_dxdt "void +%feature("docstring") cmf::math::CVodeAdams::copy_dxdt "void copy_dxdt(Time time, num_array &destination, real factor=1) const Copies the derivatives at time step \"time\" to a numeric vector using @@ -2981,7 +5811,7 @@ destination: Vector to be overwritten by the results factor: A factor that is multiplied to the derivate (e.g. unit conversion or integration length) "; -%feature("docstring") cmf::math::CVodeIntegrator::copy_dxdt "void +%feature("docstring") cmf::math::CVodeAdams::copy_dxdt "void copy_dxdt(Time time, real *destination, real factor=1) const Copies the derivatives at time step \"time\" to an preallocated c @@ -2997,61 +5827,46 @@ destination: Allocated c array factor: A factor that is multiplied to the derivate (e.g. unit conversion or integration length) "; -%feature("docstring") cmf::math::CVodeIntegrator::copy_states "void +%feature("docstring") cmf::math::CVodeAdams::copy_states "void copy_states(num_array &destination) const Copies the states to a numeric vector using use_OpenMP. "; -%feature("docstring") cmf::math::CVodeIntegrator::copy_states "void +%feature("docstring") cmf::math::CVodeAdams::copy_states "void copy_states(real *destination) const "; -%feature("docstring") cmf::math::CVodeIntegrator::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; +%feature("docstring") cmf::math::CVodeAdams::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; -%feature("docstring") cmf::math::CVodeIntegrator::get_error "cmf::math::num_array get_error() const +%feature("docstring") cmf::math::CVodeAdams::get_error "cmf::math::num_array get_error() const Error vector of the integrator. "; -%feature("docstring") -cmf::math::CVodeIntegrator::get_nonlinear_iterations "int -get_nonlinear_iterations() const - -Returns the number of non-linear iterations performed. Calls -CVodeGetNumNonlinSolvIters. "; - -%feature("docstring") cmf::math::CVodeIntegrator::get_order "int -get_order() const - -Returns the last order of the solver used, may be smaller than -MaxOrder due to the number of steps already taken or to fullfill -stability limit. "; +%feature("docstring") cmf::math::CVodeAdams::get_info "CVodeInfo +get_info() const -%feature("docstring") cmf::math::CVodeIntegrator::get_rhsevals "int -get_rhsevals() const +Returns the current solver statistics. "; -Returns the number of evaluations of the right hand side of the ODE. -Calls CVodeGetNumRhsEvals. "; - -%feature("docstring") cmf::math::CVodeIntegrator::get_state "real +%feature("docstring") cmf::math::CVodeAdams::get_state "real get_state(ptrdiff_t position) const Returns the statevariable at position Simplifies the assessment of state variables. "; -%feature("docstring") cmf::math::CVodeIntegrator::get_states "cmf::math::num_array get_states() const "; +%feature("docstring") cmf::math::CVodeAdams::get_states "cmf::math::num_array get_states() const "; -%feature("docstring") cmf::math::CVodeIntegrator::get_states "StateVariableList get_states() +%feature("docstring") cmf::math::CVodeAdams::get_states "StateVariableList get_states() gets the state variables of the integrator "; -%feature("docstring") cmf::math::CVodeIntegrator::initialize "void +%feature("docstring") cmf::math::CVodeAdams::initialize "int initialize() -Initializes the solver. Do not add or remove state variables after -initialization. The solver is automatically intialized when -integrating. "; +Initialize the internal memory. + +Automatically called, when one starts to integrate "; -%feature("docstring") cmf::math::CVodeIntegrator::integrate "virtual -int integrate(cmf::math::Time t_max, cmf::math::Time dt) +%feature("docstring") cmf::math::CVodeAdams::integrate "virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt) Integrates the vector of state variables. @@ -3066,858 +5881,1023 @@ dt: Takes the proposed time step, and changes it into the effectively used time step according to the local stiffness of the problem and MaxTime "; -%feature("docstring") cmf::math::CVodeIntegrator::release "void -release() +%feature("docstring") cmf::math::CVodeAdams::reset "virtual void +reset() -Releases the internal solver. Call release before you add state -variables or to change properties. "; +Resets the history of the multispte solver and overwrites the internal +state cache. "; -%feature("docstring") cmf::math::CVodeIntegrator::reset "virtual -void reset() +%feature("docstring") cmf::math::CVodeAdams::set_error_msg "void +set_error_msg(std::string error) -Resets the multi-step integrator. External changes to the state -variables get recognized by the solver. Parameter changes of solver -are ignored. "; +Sets an error message. "; -%feature("docstring") cmf::math::CVodeIntegrator::set_state "void +%feature("docstring") cmf::math::CVodeAdams::set_state "void set_state(ptrdiff_t position, real newState) Simplifies the assessment of state variables. "; -%feature("docstring") cmf::math::CVodeIntegrator::set_states "void +%feature("docstring") cmf::math::CVodeAdams::set_states "void set_states(const num_array &newStates) Copies the new states to the actual states. "; -%feature("docstring") cmf::math::CVodeIntegrator::set_states "void +%feature("docstring") cmf::math::CVodeAdams::set_states "void set_states(real *newStates) "; -%feature("docstring") cmf::math::CVodeIntegrator::size "size_t -size() const +%feature("docstring") cmf::math::CVodeAdams::size "size_t size() +const returns the number of state variables "; +%feature("docstring") cmf::math::CVodeAdams::to_string "std::string +to_string() const -// File: struct_c_vode_mem_rec.xml -%feature("docstring") CVodeMemRec ""; +Returns a string representation of the solver. "; -// File: struct_c_v_spils_mem_rec.xml -%feature("docstring") CVSpilsMemRec ""; +// File: classcmf__core_1_1_c_vode_banded.xml +%feature("docstring") cmf_core::CVodeBanded " +implicit BDF CVode solver with a banded Jacobian approximation C++ +includes: cvode3.h "; -// File: classcmf_1_1upslope_1_1connections_1_1_darcy.xml -%feature("docstring") cmf::upslope::connections::Darcy " +%feature("docstring") cmf_core::CVodeBanded::__init__ "def +__init__(self, args, kwargs) -Calculates the lateral flow using the gravitational potential gradient -only. +__init__(cmf::math::CVodeBanded self, StateVariableOwner states, real +epsilon=1e-9, int w=5) -> CVodeBanded +CVodeBanded(cmf::math::StateVariableOwner &states, real epsilon=1e-9, +int w=5) "; +%feature("docstring") cmf_core::CVodeBanded::__call__ "def +__call__(self, t, dt=None, reset=False) +Advances the integration until `t` A shortcut to .integrate_until +Parameters ---------- t : cmf.Time The time step to advance to. If +t < current time, the solver will advance to self.t + t dt : +cmf.Time, optional The timestep for the integration. If not given +try to integrate in one step reset : bool, optional If True, the +solver will perform a reset before starting Returns ------- cmf.Time +The new time stamp "; -.. math:: +%feature("docstring") cmf_core::CVodeBanded::__getitem__ "def +__getitem__(self, args, kwargs) - q_{lat} = \\\\frac{\\\\Delta \\\\Psi_G}{\\\\|C_1-C_2\\\\|} - \\\\frac 12 (T(C_1)+T(C_2)) w +__getitem__(Integrator self, long position) -> +cmf::math::StateVariable::ptr "; -where :math:`\\\\Delta \\\\Psi_G` is -the gravitational potential difference +%feature("docstring") cmf_core::CVodeBanded::__len__ "def +__len__(self, args, kwargs) -:math:`\\\\|C_1-C_2\\\\|` is the distance from Cell 1 to Cell 2 +__len__(Integrator self) -> size_t "; -:math:`T(C)` is the transmissivity of cell C, calculated by -SoilType::Transmissivity +%feature("docstring") cmf_core::CVodeBanded::__repr__ "def +__repr__(self) "; -:math:`w` is the width of the connection of the cells +%feature("docstring") cmf_core::CVodeBanded::add_single_state "def +add_single_state(self, args, kwargs) -C++ includes: subsurfacefluxes.h "; +add_single_state(Integrator self, cmf::math::StateVariable::ptr state) +virtual void add_single_state(cmf::math::StateVariable::ptr state) +Adds a single state variable to the integrator. "; -%feature("docstring") cmf::upslope::connections::Darcy::Darcy "Darcy(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr -right, real FlowWidth, real Distance=0) "; +%feature("docstring") cmf_core::CVodeBanded::add_states "def +add_states(self, args, kwargs) -%feature("docstring") cmf::upslope::connections::Darcy::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +add_states(Integrator self, StateVariableOwner stateOwner) virtual +void add_states(cmf::math::StateVariableOwner &stateOwner) Add state +variables from a StateVariableOwner. "; -Returns the concentration of the flux. +%feature("docstring") cmf_core::CVodeBanded::copy "def copy(self, +args, kwargs) -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +copy(CVodeBase self) -> CVodeBase virtual Integrator* copy() const =0 +Polymorphic copy constructor. "; -%feature("docstring") -cmf::upslope::connections::Darcy::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +%feature("docstring") cmf_core::CVodeBanded::get_dt "def +get_dt(self, args, kwargs) -%feature("docstring") cmf::upslope::connections::Darcy::get_ptr "ptr -get_ptr() const "; +get_dt(Integrator self) -> Time cmf::math::Time get_dt() const +Returns the last time step. "; -%feature("docstring") cmf::upslope::connections::Darcy::get_target "flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") cmf_core::CVodeBanded::get_dxdt "def +get_dxdt(self, args, kwargs) -Returns the other end of a connection than the asking end. "; +get_dxdt(Integrator self, Time time) -> cmf::math::num_array +cmf::math::num_array get_dxdt(Time time) const "; -%feature("docstring") cmf::upslope::connections::Darcy::get_target "flux_node::ptr get_target(int index) const +%feature("docstring") cmf_core::CVodeBanded::get_error "def +get_error(self, args, kwargs) -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +get_error(CVodeBase self) -> cmf::math::num_array "; -%feature("docstring") -cmf::upslope::connections::Darcy::get_tracer_filter "real -get_tracer_filter() +%feature("docstring") cmf_core::CVodeBanded::get_info "def +get_info(self, args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. +get_info(CVodeBase self) -> CVodeInfo "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::CVodeBanded::get_jacobian "def +get_jacobian(self) "; -%feature("docstring") -cmf::upslope::connections::Darcy::get_tracer_filter "real -get_tracer_filter(solute S) +%feature("docstring") cmf_core::CVodeBanded::get_state "def +get_state(self, args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +get_state(Integrator self, ptrdiff_t position) -> real real +get_state(ptrdiff_t position) const Returns the statevariable at +position Simplifies the assessment of state variables. "; -%feature("docstring") cmf::upslope::connections::Darcy::kill_me "bool kill_me() +%feature("docstring") cmf_core::CVodeBanded::get_states "def +get_states(self, args) -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +get_states(Integrator self) -> cmf::math::num_array +get_states(Integrator self) -> StateVariableList StateVariableList +get_states() gets the state variables of the integrator "; -%feature("docstring") cmf::upslope::connections::Darcy::left_node "flux_node::ptr left_node() const +%feature("docstring") cmf_core::CVodeBanded::get_t "def get_t(self, +args, kwargs) -Returns the left node of this connection. "; +get_t(Integrator self) -> Time cmf::math::Time get_t() const Returns +the current model time. "; -%feature("docstring") cmf::upslope::connections::Darcy::q "real -q(const flux_node &inquirer, cmf::math::Time t) +%feature("docstring") cmf_core::CVodeBanded::initialize "def +initialize(self, args, kwargs) -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +initialize(CVodeBase self) -> int "; -%feature("docstring") cmf::upslope::connections::Darcy::refresh "void refresh(cmf::math::Time t) +%feature("docstring") cmf_core::CVodeBanded::integrate "def +integrate(self, args, kwargs) -Performes a new calculation of the flux. "; +integrate(Integrator self, Time t_max, Time dt) -> int virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt)=0 Integrates the +vector of state variables. Parameters: ----------- t_max: To stop +the model (if running in a model framework) at time steps of value +exchange e.g. full hours, the next value exchange time can be given +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; -%feature("docstring") cmf::upslope::connections::Darcy::right_node "flux_node::ptr right_node() const +%feature("docstring") cmf_core::CVodeBanded::integrate_until "def +integrate_until(self, args, kwargs) -returns the right node of this connection "; +integrate_until(Integrator self, Time t_max, Time dt, bool +reset=False) void integrate_until(cmf::math::Time t_max, +cmf::math::Time dt=Time(), bool reset=false) Integrates the vector of +state variables until t_max. Parameters: ----------- t_max: Time, +the solver should run to dt: Time step (may be omitted) reset: If +true, solver is reseted before integration starts "; -%feature("docstring") -cmf::upslope::connections::Darcy::set_tracer_filter "void -set_tracer_filter(real value) +%feature("docstring") cmf_core::CVodeBanded::reset "def reset(self, +args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. +reset(Integrator self) virtual void reset() Resets any saved history +(for multistep methods) "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::CVodeBanded::run "def run(self, +start=None, end=None, step=day *1, max_errors=0, reset=False) -%feature("docstring") -cmf::upslope::connections::Darcy::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; +Returns an iterator over the timesteps start..end **Examples:** >>> +solver=cmf.CVodeIntegrator(...) >>> for t in solver.run(solver.t, +solver.t + cmf.week, cmf.h): >>> print(t, solver[0].state) or with +list comprehension >>> states = [solver[0].state for t in +solver.run(solver.t, solver.t + cmf.week, cmf.h)] Parameters +---------- start : cmf.Time, optional Start time for the solver +iteration end : cmf.Time, optional End time of the iteration step : +cmf.Time, optional Step size for the integration max_errors: int +Number of tolerated errors. If >0, up to these number of runtime +errors will be saved with their time and the integration proceeds +after a reset of the solver. Some systems operate with values close to +their physical limits and inifinite values in the integration can +easily occur. For these kind of systems set max_errors to eg. 10. A +larger number of errors should be eliminated usually. reset: bool If +True, the solver performs a `reset` at every time step Yields ------ +cmf.Time the actual timestep "; -%feature("docstring") cmf::upslope::connections::Darcy::short_string -"virtual std::string short_string() const "; +%feature("docstring") cmf_core::CVodeBanded::set_error_msg "def +set_error_msg(self, args, kwargs) -%feature("docstring") cmf::upslope::connections::Darcy::to_string "virtual std::string to_string() const "; +set_error_msg(CVodeBase self, std::string error) "; +%feature("docstring") cmf_core::CVodeBanded::set_state "def +set_state(self, args, kwargs) -// File: classcmf_1_1upslope_1_1connections_1_1_darcy_kinematic.xml -%feature("docstring") cmf::upslope::connections::DarcyKinematic " +set_state(Integrator self, ptrdiff_t position, real newState) void +set_state(ptrdiff_t position, real newState) Simplifies the +assessment of state variables. "; -A simple kinemtic wave model for subsurface flux. +%feature("docstring") cmf_core::CVodeBanded::set_t "def set_t(self, +args, kwargs) +set_t(Integrator self, Time val) void set_t(cmf::math::Time val) Sets +the current model time. "; +%feature("docstring") cmf_core::CVodeBanded::size "def size(self, +args, kwargs) -.. math:: +size(Integrator self) -> size_t size_t size() const returns the +number of state variables "; - q = \\\\frac{\\\\Delta z_{surface}}{d} K(\\\\theta)_{source} - A_{cross} +%feature("docstring") cmf_core::CVodeBanded::to_string "def +to_string(self, args, kwargs) -C++ includes: subsurfacefluxes.h "; +to_string(CVodeBase self) -> std::string "; -%feature("docstring") -cmf::upslope::connections::DarcyKinematic::DarcyKinematic "DarcyKinematic(cmf::upslope::SoilLayer::ptr left, -cmf::water::flux_node::ptr right, real FlowWidth, real Distance=0) -Creates the connection. +// File: classcmf_1_1math_1_1_c_vode_banded.xml +%feature("docstring") cmf::math::CVodeBanded " -Parameters: ------------ +implicit BDF CVode solver with a banded Jacobian approximation -left: Left node of the connection (needs to be soil water storage) +C++ includes: cvode.h "; -right: Right node of the connection (can be any node) +/* Accuracy parameters */ -FlowWidth: the width of the connection - is multiplied by layer -thickness to get the interface area +/* model time */ -Distance: the length of the connection. If 0, the distance is -calculated from the position of the nodes "; +%feature("docstring") cmf::math::CVodeBanded::get_t "cmf::math::Time +get_t() const -%feature("docstring") cmf::upslope::connections::DarcyKinematic::conc -"real conc(cmf::math::Time t, const cmf::water::solute &_Solute) +Returns the current model time. "; -Returns the concentration of the flux. +%feature("docstring") cmf::math::CVodeBanded::set_t "void +set_t(cmf::math::Time val) -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +Sets the current model time. "; -%feature("docstring") -cmf::upslope::connections::DarcyKinematic::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +%feature("docstring") cmf::math::CVodeBanded::get_dt "cmf::math::Time get_dt() const -%feature("docstring") -cmf::upslope::connections::DarcyKinematic::get_ptr "ptr get_ptr() -const "; +Returns the last time step. "; -%feature("docstring") -cmf::upslope::connections::DarcyKinematic::get_target "flux_node::ptr -get_target(const flux_node &inquirer) +/* Integrate */ -Returns the other end of a connection than the asking end. "; +%feature("docstring") cmf::math::CVodeBanded::integrate_until "void +integrate_until(cmf::math::Time t_max, cmf::math::Time dt=Time(), bool +reset=false) -%feature("docstring") -cmf::upslope::connections::DarcyKinematic::get_target "flux_node::ptr -get_target(int index) const +Integrates the vector of state variables until t_max. -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +Parameters: +----------- -%feature("docstring") -cmf::upslope::connections::DarcyKinematic::get_tracer_filter "real -get_tracer_filter() +t_max: Time, the solver should run to -A value ranging from 0 to 1 to filter tracers out of the water flux. +dt: Time step (may be omitted) -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +reset: If true, solver is reseted before integration starts "; -%feature("docstring") -cmf::upslope::connections::DarcyKinematic::get_tracer_filter "real -get_tracer_filter(solute S) +%feature("docstring") cmf::math::CVodeBanded::CVodeBanded "CVodeBanded(cmf::math::StateVariableOwner &states, real epsilon=1e-9, +int w=5) "; -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +%feature("docstring") cmf::math::CVodeBanded::_get_jacobian "virtual +cmf::math::num_array _get_jacobian() const -%feature("docstring") -cmf::upslope::connections::DarcyKinematic::kill_me "bool kill_me() +Returns a continuous 1D array representing the Jacobian columns +concatenated. -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +In Python, get_jacobian returns the Jacobian as a 2D array "; -%feature("docstring") -cmf::upslope::connections::DarcyKinematic::left_node "flux_node::ptr -left_node() const +%feature("docstring") cmf::math::CVodeBanded::add_single_state "virtual void add_single_state(cmf::math::StateVariable::ptr state) -Returns the left node of this connection. "; +Adds a single state variable to the integrator. "; -%feature("docstring") cmf::upslope::connections::DarcyKinematic::q "real q(const flux_node &inquirer, cmf::math::Time t) +%feature("docstring") cmf::math::CVodeBanded::add_states "virtual +void add_states(cmf::math::StateVariableOwner &stateOwner) -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +Add state variables from a StateVariableOwner. "; -%feature("docstring") -cmf::upslope::connections::DarcyKinematic::refresh "void -refresh(cmf::math::Time t) +%feature("docstring") cmf::math::CVodeBanded::add_values_to_states "void add_values_to_states(const num_array &operands) -Performes a new calculation of the flux. "; +Adds the values in operands to the current states. "; -%feature("docstring") -cmf::upslope::connections::DarcyKinematic::right_node "flux_node::ptr -right_node() const +%feature("docstring") cmf::math::CVodeBanded::copy "CVodeBase* +copy() const -returns the right node of this connection "; +Returns a copy of the solver. "; -%feature("docstring") -cmf::upslope::connections::DarcyKinematic::set_tracer_filter "void -set_tracer_filter(real value) +%feature("docstring") cmf::math::CVodeBanded::copy_dxdt "void +copy_dxdt(Time time, num_array &destination, real factor=1) const -A value ranging from 0 to 1 to filter tracers out of the water flux. +Copies the derivatives at time step \"time\" to a numeric vector using +use_OpenMP. -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +Parameters: +----------- -%feature("docstring") -cmf::upslope::connections::DarcyKinematic::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; +time: Time at which the derivatives should be calculated -%feature("docstring") -cmf::upslope::connections::DarcyKinematic::short_string "virtual -std::string short_string() const "; +destination: Vector to be overwritten by the results -%feature("docstring") -cmf::upslope::connections::DarcyKinematic::to_string "virtual -std::string to_string() const "; +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; +%feature("docstring") cmf::math::CVodeBanded::copy_dxdt "void +copy_dxdt(Time time, real *destination, real factor=1) const -// File: structcmf_1_1math_1_1_date.xml -%feature("docstring") cmf::math::Date " +Copies the derivatives at time step \"time\" to an preallocated c +array. -An absolute time, not for calculation. Date and Time are -interchangable. +Parameters: +----------- -C++ includes: time.h "; +time: Time at which the derivatives should be calculated -%feature("docstring") cmf::math::Date::Date "Date(int _day, int -_month, int _year, int _hour=0, int _minute=0, int _second=0, int -_ms=0) +destination: Allocated c array -Creates a new date. "; +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; -%feature("docstring") cmf::math::Date::Date "Date(const Time &time) +%feature("docstring") cmf::math::CVodeBanded::copy_states "void +copy_states(num_array &destination) const -Creates a new date from time (based on the 31.12.1899, like in -Excel(TM)) "; +Copies the states to a numeric vector using use_OpenMP. "; -%feature("docstring") cmf::math::Date::DOY "double DOY() +%feature("docstring") cmf::math::CVodeBanded::copy_states "void +copy_states(real *destination) const "; -Returns the day of year. "; +%feature("docstring") cmf::math::CVodeBanded::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; -%feature("docstring") cmf::math::Date::to_string "std::string -to_string() +%feature("docstring") cmf::math::CVodeBanded::get_error "cmf::math::num_array get_error() const -Returns a string representing the date. "; +Error vector of the integrator. "; -%feature("docstring") cmf::math::Date::ToTime "Time ToTime() +%feature("docstring") cmf::math::CVodeBanded::get_info "CVodeInfo +get_info() const -Converts a date to Time (based on the 31.12.1899, like in Excel(TM) "; +Returns the current solver statistics. "; +%feature("docstring") cmf::math::CVodeBanded::get_state "real +get_state(ptrdiff_t position) const -// File: classcmf_1_1upslope_1_1connections_1_1_diffusive_macro_micro_exchange.xml -%feature("docstring") -cmf::upslope::connections::DiffusiveMacroMicroExchange " +Returns the statevariable at position Simplifies the assessment of +state variables. "; -A simple first order diffusive water exchange between MacroPore and -matrix ( SoilLayer) +%feature("docstring") cmf::math::CVodeBanded::get_states "cmf::math::num_array get_states() const "; +%feature("docstring") cmf::math::CVodeBanded::get_states "StateVariableList get_states() +gets the state variables of the integrator "; -.. math:: +%feature("docstring") cmf::math::CVodeBanded::initialize "int +initialize() - q = \\\\omega (W_{ma} - W_{mi,eff}) V_{soil} +Initialize the internal memory. -where: -:math:`\\\\omega` is the exchange rate in :math:`day^{-1}` +Automatically called, when one starts to integrate "; -:math:`W_{ma}` is the filled fraction of the macropore system [-] +%feature("docstring") cmf::math::CVodeBanded::integrate "virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt) -:math:`W_{mi,eff}` is the water filled pore space of the micropores above -the residual pF value [-], default 4.2 +Integrates the vector of state variables. -:math:`V_{soil} = A_{cell} d_{layer}` is the total volume of the soil layer -[ :math:`m^3`] +Parameters: +----------- -The residual micropore pF is used to determine a residual water -content of the micropores. Residual in this case means, that above -this pF value, water is not draining to the macro pores, even if they -are empty. Although the default value is at wilting point, lower pF -values are much more sensible, and should be rather lower than field -capacity (pF=1.8 - 2.5). However, since this equation is rather -conceptual than physical, this value can only be estimated or -calibrated. +t_max: To stop the model (if running in a model framework) at time +steps of value exchange e.g. full hours, the next value exchange time +can be given -cf. Simunek et al J. of Hydr. 2003 +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; -C++ includes: macropore.h "; +%feature("docstring") cmf::math::CVodeBanded::reset "virtual void +reset() -%feature("docstring") -cmf::upslope::connections::DiffusiveMacroMicroExchange::DiffusiveMacroMicroExchange -"DiffusiveMacroMicroExchange(cmf::upslope::MacroPore::ptr left, -cmf::upslope::SoilLayer::ptr right, real omega, real pFrmi=4.2) "; +Resets the history of the multispte solver and overwrites the internal +state cache. "; -%feature("docstring") -cmf::upslope::connections::DiffusiveMacroMicroExchange::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +%feature("docstring") cmf::math::CVodeBanded::set_error_msg "void +set_error_msg(std::string error) -Returns the concentration of the flux. +Sets an error message. "; -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +%feature("docstring") cmf::math::CVodeBanded::set_state "void +set_state(ptrdiff_t position, real newState) -%feature("docstring") -cmf::upslope::connections::DiffusiveMacroMicroExchange::exchange_target -"void exchange_target(flux_node::ptr oldtarget, flux_node::ptr -newTarget) "; +Simplifies the assessment of state variables. "; -%feature("docstring") -cmf::upslope::connections::DiffusiveMacroMicroExchange::get_ptr "ptr -get_ptr() const "; +%feature("docstring") cmf::math::CVodeBanded::set_states "void +set_states(const num_array &newStates) -%feature("docstring") -cmf::upslope::connections::DiffusiveMacroMicroExchange::get_target "flux_node::ptr get_target(const flux_node &inquirer) +Copies the new states to the actual states. "; -Returns the other end of a connection than the asking end. "; +%feature("docstring") cmf::math::CVodeBanded::set_states "void +set_states(real *newStates) "; -%feature("docstring") -cmf::upslope::connections::DiffusiveMacroMicroExchange::get_target "flux_node::ptr get_target(int index) const +%feature("docstring") cmf::math::CVodeBanded::size "size_t size() +const -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +returns the number of state variables "; -%feature("docstring") -cmf::upslope::connections::DiffusiveMacroMicroExchange::get_tracer_filter -"real get_tracer_filter() +%feature("docstring") cmf::math::CVodeBanded::to_string "std::string +to_string() const -A value ranging from 0 to 1 to filter tracers out of the water flux. +Returns a string representation of the solver. "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; -%feature("docstring") -cmf::upslope::connections::DiffusiveMacroMicroExchange::get_tracer_filter -"real get_tracer_filter(solute S) +// File: classcmf__core_1_1_c_vode_base.xml +%feature("docstring") cmf_core::CVodeBase " -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +Proxy of C++ cmf::math::CVodeBase class. "; -%feature("docstring") -cmf::upslope::connections::DiffusiveMacroMicroExchange::kill_me "bool -kill_me() +%feature("docstring") cmf_core::CVodeBase::__init__ "def +__init__(self, args, kwargs) "; -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +%feature("docstring") cmf_core::CVodeBase::__call__ "def +__call__(self, t, dt=None, reset=False) -%feature("docstring") -cmf::upslope::connections::DiffusiveMacroMicroExchange::left_node "flux_node::ptr left_node() const +Advances the integration until `t` A shortcut to .integrate_until +Parameters ---------- t : cmf.Time The time step to advance to. If +t < current time, the solver will advance to self.t + t dt : +cmf.Time, optional The timestep for the integration. If not given +try to integrate in one step reset : bool, optional If True, the +solver will perform a reset before starting Returns ------- cmf.Time +The new time stamp "; -Returns the left node of this connection. "; +%feature("docstring") cmf_core::CVodeBase::__getitem__ "def +__getitem__(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::DiffusiveMacroMicroExchange::q "real -q(const flux_node &inquirer, cmf::math::Time t) +__getitem__(Integrator self, long position) -> +cmf::math::StateVariable::ptr "; -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +%feature("docstring") cmf_core::CVodeBase::__len__ "def +__len__(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::DiffusiveMacroMicroExchange::refresh "void -refresh(cmf::math::Time t) +__len__(Integrator self) -> size_t "; -Performes a new calculation of the flux. "; +%feature("docstring") cmf_core::CVodeBase::__repr__ "def +__repr__(self) "; -%feature("docstring") -cmf::upslope::connections::DiffusiveMacroMicroExchange::right_node "flux_node::ptr right_node() const +%feature("docstring") cmf_core::CVodeBase::add_single_state "def +add_single_state(self, args, kwargs) -returns the right node of this connection "; +add_single_state(Integrator self, cmf::math::StateVariable::ptr state) +virtual void add_single_state(cmf::math::StateVariable::ptr state) +Adds a single state variable to the integrator. "; -%feature("docstring") -cmf::upslope::connections::DiffusiveMacroMicroExchange::set_tracer_filter -"void set_tracer_filter(real value) +%feature("docstring") cmf_core::CVodeBase::add_states "def +add_states(self, args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. +add_states(Integrator self, StateVariableOwner stateOwner) virtual +void add_states(cmf::math::StateVariableOwner &stateOwner) Add state +variables from a StateVariableOwner. "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::CVodeBase::copy "def copy(self, +args, kwargs) -%feature("docstring") -cmf::upslope::connections::DiffusiveMacroMicroExchange::set_tracer_filter -"void set_tracer_filter(solute S, real value) "; +copy(CVodeBase self) -> CVodeBase virtual Integrator* copy() const =0 +Polymorphic copy constructor. "; -%feature("docstring") -cmf::upslope::connections::DiffusiveMacroMicroExchange::short_string "virtual std::string short_string() const "; +%feature("docstring") cmf_core::CVodeBase::get_dt "def get_dt(self, +args, kwargs) -%feature("docstring") -cmf::upslope::connections::DiffusiveMacroMicroExchange::to_string "virtual std::string to_string() const "; +get_dt(Integrator self) -> Time cmf::math::Time get_dt() const +Returns the last time step. "; +%feature("docstring") cmf_core::CVodeBase::get_dxdt "def +get_dxdt(self, args, kwargs) -// File: classcmf_1_1upslope_1_1connections_1_1_diffusive_surface_runoff.xml -%feature("docstring") -cmf::upslope::connections::DiffusiveSurfaceRunoff " +get_dxdt(Integrator self, Time time) -> cmf::math::num_array +cmf::math::num_array get_dxdt(Time time) const "; -A connection to route water from a SurfaceWater storage to another -node following the gradient of the water level. +%feature("docstring") cmf_core::CVodeBase::get_error "def +get_error(self, args, kwargs) +get_error(CVodeBase self) -> cmf::math::num_array "; +%feature("docstring") cmf_core::CVodeBase::get_info "def +get_info(self, args, kwargs) -.. math:: +get_info(CVodeBase self) -> CVodeInfo "; - q_{runoff} = A_{cross} d_{eff}^{2/3} - \\\\frac{\\\\sqrt{S}}{n} +%feature("docstring") cmf_core::CVodeBase::get_jacobian "def +get_jacobian(self) "; -where: :math:`q_{runoff}` is the surface -runoff +%feature("docstring") cmf_core::CVodeBase::get_state "def +get_state(self, args, kwargs) -:math:`A_{cross}` is the wetted crossectional flux area, given as :math:`d_{eff} \\\\cdot w` +get_state(Integrator self, ptrdiff_t position) -> real real +get_state(ptrdiff_t position) const Returns the statevariable at +position Simplifies the assessment of state variables. "; -:math:`w` is the width of the shared boundary between the surface water -storage and the target node +%feature("docstring") cmf_core::CVodeBase::get_states "def +get_states(self, args) -:math:`d_{eff}` is the effective flow depth of the surface water.The -effective flow depth is defined as either the mean of the effective -depth of the left and the right node (when use_depthmax=false) or the -maximum of the efficitve depth. The effective depth for a surfacewater -is always defined as: +get_states(Integrator self) -> cmf::math::num_array +get_states(Integrator self) -> StateVariableList StateVariableList +get_states() gets the state variables of the integrator "; -.. math:: +%feature("docstring") cmf_core::CVodeBase::get_t "def get_t(self, +args, kwargs) - d_{eff} = \\\\begin{cases} - V/A-d_{puddle}\\\\ & V/A>d_{puddle} \\\\\\\\ 0.0 & V/A<=d_{puddle} - \\\\end{cases} +get_t(Integrator self) -> Time cmf::math::Time get_t() const Returns +the current model time. "; -The right node might be not a surfacewater. If the -right node is an OpenWaterStorage, then the effective depth is the -depth of the OWS above the cell height of the left surfacewater, given -by: +%feature("docstring") cmf_core::CVodeBase::initialize "def +initialize(self, args, kwargs) -.. math:: +initialize(CVodeBase self) -> int "; - d_{eff,ows} = \\\\Psi_{ows} - z_{cell} +%feature("docstring") cmf_core::CVodeBase::integrate "def +integrate(self, args, kwargs) -In case of -another node, the right node depth equals the effective depth of the -left node. +integrate(Integrator self, Time t_max, Time dt) -> int virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt)=0 Integrates the +vector of state variables. Parameters: ----------- t_max: To stop +the model (if running in a model framework) at time steps of value +exchange e.g. full hours, the next value exchange time can be given +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; -:math:`V` the volume of stored water in the surface in :math:`m^3` +%feature("docstring") cmf_core::CVodeBase::integrate_until "def +integrate_until(self, args, kwargs) -:math:`A` the area of the cell in :math:`m^2` +integrate_until(Integrator self, Time t_max, Time dt, bool +reset=False) void integrate_until(cmf::math::Time t_max, +cmf::math::Time dt=Time(), bool reset=false) Integrates the vector of +state variables until t_max. Parameters: ----------- t_max: Time, +the solver should run to dt: Time step (may be omitted) reset: If +true, solver is reseted before integration starts "; -:math:`d_{puddle}=V_{puddle}/A` the average depth of water in the surface -water needed to start run off +%feature("docstring") cmf_core::CVodeBase::reset "def reset(self, +args, kwargs) -:math:`S = \\\\|\\\\frac{\\\\Delta h\\\\|}{d}` the slope between -surfacewater center potential and the target node potential +reset(Integrator self) virtual void reset() Resets any saved history +(for multistep methods) "; -:math:`n` the manning roughness +%feature("docstring") cmf_core::CVodeBase::run "def run(self, +start=None, end=None, step=day *1, max_errors=0, reset=False) -The DiffusiveSurfaceRunoff can be used as a cell connecting flux as -in: This results in a connection of the surfacewater storage of each -cell with the surface water storages of its neighborssee +Returns an iterator over the timesteps start..end **Examples:** >>> +solver=cmf.CVodeIntegrator(...) >>> for t in solver.run(solver.t, +solver.t + cmf.week, cmf.h): >>> print(t, solver[0].state) or with +list comprehension >>> states = [solver[0].state for t in +solver.run(solver.t, solver.t + cmf.week, cmf.h)] Parameters +---------- start : cmf.Time, optional Start time for the solver +iteration end : cmf.Time, optional End time of the iteration step : +cmf.Time, optional Step size for the integration max_errors: int +Number of tolerated errors. If >0, up to these number of runtime +errors will be saved with their time and the integration proceeds +after a reset of the solver. Some systems operate with values close to +their physical limits and inifinite values in the integration can +easily occur. For these kind of systems set max_errors to eg. 10. A +larger number of errors should be eliminated usually. reset: bool If +True, the solver performs a `reset` at every time step Yields ------ +cmf.Time the actual timestep "; -C++ includes: surfacewater.h "; +%feature("docstring") cmf_core::CVodeBase::set_error_msg "def +set_error_msg(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::DiffusiveSurfaceRunoff::DiffusiveSurfaceRunoff -"DiffusiveSurfaceRunoff(cmf::upslope::SurfaceWater::ptr left, -cmf::water::flux_node::ptr right, real flowwidth, real distance=-1) "; +set_error_msg(CVodeBase self, std::string error) "; -%feature("docstring") -cmf::upslope::connections::DiffusiveSurfaceRunoff::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +%feature("docstring") cmf_core::CVodeBase::set_state "def +set_state(self, args, kwargs) -Returns the concentration of the flux. +set_state(Integrator self, ptrdiff_t position, real newState) void +set_state(ptrdiff_t position, real newState) Simplifies the +assessment of state variables. "; -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +%feature("docstring") cmf_core::CVodeBase::set_t "def set_t(self, +args, kwargs) -%feature("docstring") -cmf::upslope::connections::DiffusiveSurfaceRunoff::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr -newTarget) "; +set_t(Integrator self, Time val) void set_t(cmf::math::Time val) Sets +the current model time. "; -%feature("docstring") -cmf::upslope::connections::DiffusiveSurfaceRunoff::get_ptr "ptr -get_ptr() const "; +%feature("docstring") cmf_core::CVodeBase::size "def size(self, +args, kwargs) -%feature("docstring") -cmf::upslope::connections::DiffusiveSurfaceRunoff::get_target "flux_node::ptr get_target(const flux_node &inquirer) +size(Integrator self) -> size_t size_t size() const returns the +number of state variables "; -Returns the other end of a connection than the asking end. "; +%feature("docstring") cmf_core::CVodeBase::to_string "def +to_string(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::DiffusiveSurfaceRunoff::get_target "flux_node::ptr get_target(int index) const +to_string(CVodeBase self) -> std::string "; -With index 0, the left node is returned, with index 1 the right node -of the connection. "; -%feature("docstring") -cmf::upslope::connections::DiffusiveSurfaceRunoff::get_tracer_filter "real get_tracer_filter() +// File: classcmf_1_1math_1_1_c_vode_base.xml +%feature("docstring") cmf::math::CVodeBase " -A value ranging from 0 to 1 to filter tracers out of the water flux. +Abstract base class for different modes of the CVode solver. -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +Initantiate one of the child classes to gain different modes of the +CVode solver -%feature("docstring") -cmf::upslope::connections::DiffusiveSurfaceRunoff::get_tracer_filter "real get_tracer_filter(solute S) +C++ includes: cvode.h "; -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +/* Accuracy parameters */ -%feature("docstring") -cmf::upslope::connections::DiffusiveSurfaceRunoff::kill_me "bool -kill_me() +/* model time */ -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +%feature("docstring") cmf::math::CVodeBase::get_t "cmf::math::Time +get_t() const -%feature("docstring") -cmf::upslope::connections::DiffusiveSurfaceRunoff::left_node "flux_node::ptr left_node() const +Returns the current model time. "; -Returns the left node of this connection. "; +%feature("docstring") cmf::math::CVodeBase::set_t "void +set_t(cmf::math::Time val) -%feature("docstring") -cmf::upslope::connections::DiffusiveSurfaceRunoff::q "real q(const -flux_node &inquirer, cmf::math::Time t) +Sets the current model time. "; -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +%feature("docstring") cmf::math::CVodeBase::get_dt "cmf::math::Time +get_dt() const -%feature("docstring") -cmf::upslope::connections::DiffusiveSurfaceRunoff::refresh "void -refresh(cmf::math::Time t) +Returns the last time step. "; -Performes a new calculation of the flux. "; +/* Integrate */ -%feature("docstring") -cmf::upslope::connections::DiffusiveSurfaceRunoff::right_node "flux_node::ptr right_node() const +%feature("docstring") cmf::math::CVodeBase::integrate_until "void +integrate_until(cmf::math::Time t_max, cmf::math::Time dt=Time(), bool +reset=false) -returns the right node of this connection "; +Integrates the vector of state variables until t_max. -%feature("docstring") -cmf::upslope::connections::DiffusiveSurfaceRunoff::set_tracer_filter "void set_tracer_filter(real value) +Parameters: +----------- -A value ranging from 0 to 1 to filter tracers out of the water flux. +t_max: Time, the solver should run to -1.0 is no filter and 0.0 means no solute is crossing this connection +dt: Time step (may be omitted) + +reset: If true, solver is reseted before integration starts "; + +%feature("docstring") cmf::math::CVodeBase::~CVodeBase "~CVodeBase() "; -%feature("docstring") -cmf::upslope::connections::DiffusiveSurfaceRunoff::set_tracer_filter "void set_tracer_filter(solute S, real value) "; +%feature("docstring") cmf::math::CVodeBase::_get_jacobian "virtual +cmf::math::num_array _get_jacobian() const -%feature("docstring") -cmf::upslope::connections::DiffusiveSurfaceRunoff::short_string "virtual std::string short_string() const "; +Returns a continuous 1D array representing the Jacobian columns +concatenated. -%feature("docstring") -cmf::upslope::connections::DiffusiveSurfaceRunoff::to_string "virtual -std::string to_string() const "; +In Python, get_jacobian returns the Jacobian as a 2D array "; +%feature("docstring") cmf::math::CVodeBase::add_single_state "virtual void add_single_state(cmf::math::StateVariable::ptr state) -// File: classcmf_1_1water_1_1_dirichlet_boundary.xml -%feature("docstring") cmf::water::DirichletBoundary " +Adds a single state variable to the integrator. "; -Dirichlet (constant head) boundary condition. +%feature("docstring") cmf::math::CVodeBase::add_states "virtual void +add_states(cmf::math::StateVariableOwner &stateOwner) -This boundary condition can be used either as a pure sink boundary -condition or as a conditional source / sink boundary condition. The -constant head of the boundary condition is interpreted and handled by -the connections of the boundary condition. Not head aware connections, -should not be used, since they are ignoring the constant head. +Add state variables from a StateVariableOwner. "; -C++ includes: boundary_condition.h "; +%feature("docstring") cmf::math::CVodeBase::add_values_to_states "void add_values_to_states(const num_array &operands) -%feature("docstring") -cmf::water::DirichletBoundary::DirichletBoundary "DirichletBoundary(cmf::project &_p, real potential, -cmf::geometry::point Location=cmf::geometry::point()) "; +Adds the values in operands to the current states. "; -%feature("docstring") cmf::water::DirichletBoundary::conc "virtual -real conc(cmf::math::Time t, const cmf::water::solute &_Solute) const +%feature("docstring") cmf::math::CVodeBase::copy "CVodeBase* copy() +const -Returns the water quality of the flux_node, if it is not overridden -this is the mix of the incoming fluxes. "; +Returns a copy of the solver. "; -%feature("docstring") cmf::water::DirichletBoundary::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node -&target) +%feature("docstring") cmf::math::CVodeBase::copy_dxdt "void +copy_dxdt(Time time, num_array &destination, real factor=1) const -Returns the connection between this and target. "; +Copies the derivatives at time step \"time\" to a numeric vector using +use_OpenMP. -%feature("docstring") cmf::water::DirichletBoundary::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, -cmf::math::Time t) "; +Parameters: +----------- -%feature("docstring") cmf::water::DirichletBoundary::flux_to "real -flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +time: Time at which the derivatives should be calculated -Returns the actual flux between this and target (positive sign means -\"from this into target\") "; +destination: Vector to be overwritten by the results -%feature("docstring") cmf::water::DirichletBoundary::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; -Returns the sum of all flux vectors. "; +%feature("docstring") cmf::math::CVodeBase::copy_dxdt "void +copy_dxdt(Time time, real *destination, real factor=1) const -%feature("docstring") cmf::water::DirichletBoundary::get_connections -"cmf::water::connection_list get_connections() const "; +Copies the derivatives at time step \"time\" to an preallocated c +array. -%feature("docstring") cmf::water::DirichletBoundary::get_potential "real get_potential() const +Parameters: +----------- -Returns the water potential of the node in m waterhead. +time: Time at which the derivatives should be calculated -The base class water storage always returns the height of the location -"; +destination: Allocated c array -%feature("docstring") cmf::water::DirichletBoundary::get_project "cmf::project& get_project() const +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; -Returns the project, this node is part of. "; +%feature("docstring") cmf::math::CVodeBase::copy_states "void +copy_states(num_array &destination) const -%feature("docstring") cmf::water::DirichletBoundary::is_empty "double is_empty() const +Copies the states to a numeric vector using use_OpenMP. "; -Returns true if the node has no water. "; +%feature("docstring") cmf::math::CVodeBase::copy_states "void +copy_states(real *destination) const "; -%feature("docstring") cmf::water::DirichletBoundary::is_storage "virtual bool is_storage() const +%feature("docstring") cmf::math::CVodeBase::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; -true, if this is a waterstorage "; +%feature("docstring") cmf::math::CVodeBase::get_error "cmf::math::num_array get_error() const -%feature("docstring") cmf::water::DirichletBoundary::RecalcFluxes "bool RecalcFluxes(cmf::math::Time t) const "; +Error vector of the integrator. "; -%feature("docstring") cmf::water::DirichletBoundary::RecalcFluxes "virtual bool RecalcFluxes(cmf::math::Time t) +%feature("docstring") cmf::math::CVodeBase::get_info "CVodeInfo +get_info() const -Pure flux_nodes do not influence fluxes, therefore no recalculation of -fluxes is required by flux_node. +Returns the current solver statistics. "; -WaterStorage overrides this, since state changes require an update of -the fluxes "; +%feature("docstring") cmf::math::CVodeBase::get_state "real +get_state(ptrdiff_t position) const -%feature("docstring") -cmf::water::DirichletBoundary::remove_connection "bool -remove_connection(cmf::water::flux_node::ptr To) +Returns the statevariable at position Simplifies the assessment of +state variables. "; -Remove the connection. "; +%feature("docstring") cmf::math::CVodeBase::get_states "cmf::math::num_array get_states() const "; -%feature("docstring") cmf::water::DirichletBoundary::set_conc "virtual void set_conc(const cmf::water::solute &_Solute, double value) -"; +%feature("docstring") cmf::math::CVodeBase::get_states "StateVariableList get_states() -%feature("docstring") cmf::water::DirichletBoundary::set_potential "void set_potential(real new_potential) +gets the state variables of the integrator "; -Sets the potential of this flux node. "; +%feature("docstring") cmf::math::CVodeBase::initialize "int +initialize() -%feature("docstring") cmf::water::DirichletBoundary::to_string "virtual std::string to_string() const "; +Initialize the internal memory. -%feature("docstring") cmf::water::DirichletBoundary::waterbalance "real waterbalance(cmf::math::Time t, const flux_connection *Without=0) -const +Automatically called, when one starts to integrate "; -Returns the sum of all fluxes (positive and negative) at time t. +%feature("docstring") cmf::math::CVodeBase::integrate "virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt) -Single fluxes can be excluded from the calculation +Integrates the vector of state variables. Parameters: ----------- -t: Time of the query +t_max: To stop the model (if running in a model framework) at time +steps of value exchange e.g. full hours, the next value exchange time +can be given -Without: A flux_connection that is excluded from the waterbalance -(e.g. to prevent closed circuits) "; +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; +%feature("docstring") cmf::math::CVodeBase::reset "virtual void +reset() -// File: classcmf_1_1upslope_1_1connections_1_1_energy_budget_snow_melt.xml -%feature("docstring") cmf::upslope::connections::EnergyBudgetSnowMelt -" +Resets the history of the multispte solver and overwrites the internal +state cache. "; -Calculates snow melt using the surface energy budget method. +%feature("docstring") cmf::math::CVodeBase::set_error_msg "void +set_error_msg(std::string error) -C++ includes: surfacefluxes.h "; +Sets an error message. "; -%feature("docstring") -cmf::upslope::connections::EnergyBudgetSnowMelt::EnergyBudgetSnowMelt -"EnergyBudgetSnowMelt(cmf::water::WaterStorage::ptr snow, -cmf::water::flux_node::ptr surface_water, cmf::upslope::Cell &cell) "; +%feature("docstring") cmf::math::CVodeBase::set_state "void +set_state(ptrdiff_t position, real newState) -%feature("docstring") -cmf::upslope::connections::EnergyBudgetSnowMelt::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +Simplifies the assessment of state variables. "; -Returns the concentration of the flux. +%feature("docstring") cmf::math::CVodeBase::set_states "void +set_states(const num_array &newStates) -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +Copies the new states to the actual states. "; -%feature("docstring") -cmf::upslope::connections::EnergyBudgetSnowMelt::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr -newTarget) "; +%feature("docstring") cmf::math::CVodeBase::set_states "void +set_states(real *newStates) "; -%feature("docstring") -cmf::upslope::connections::EnergyBudgetSnowMelt::get_ptr "ptr -get_ptr() const "; +%feature("docstring") cmf::math::CVodeBase::size "size_t size() +const -%feature("docstring") -cmf::upslope::connections::EnergyBudgetSnowMelt::get_target "flux_node::ptr get_target(const flux_node &inquirer) +returns the number of state variables "; -Returns the other end of a connection than the asking end. "; +%feature("docstring") cmf::math::CVodeBase::to_string "virtual +std::string to_string() const =0 -%feature("docstring") -cmf::upslope::connections::EnergyBudgetSnowMelt::get_target "flux_node::ptr get_target(int index) const +Returns a string representation of the solver. "; -With index 0, the left node is returned, with index 1 the right node -of the connection. "; -%feature("docstring") -cmf::upslope::connections::EnergyBudgetSnowMelt::get_tracer_filter "real get_tracer_filter() +// File: classcmf__core_1_1_c_vode_dense.xml +%feature("docstring") cmf_core::CVodeDense " -A value ranging from 0 to 1 to filter tracers out of the water flux. +implicit BDF CVode solver with full Jacobian approximation Use this +solver for small but stiff systems (<20 state variables) The solver +calculates for each step the full Jacobian matrix of the system using +a difference quotient approximation of the real Jacobian C++ +includes: cvode3.h "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::CVodeDense::__init__ "def +__init__(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::EnergyBudgetSnowMelt::get_tracer_filter "real get_tracer_filter(solute S) +__init__(cmf::math::CVodeDense self, StateVariableOwner states, real +epsilon=1e-9) -> CVodeDense CVodeDense(cmf::math::StateVariableOwner +&states, real epsilon=1e-9) Creates a new implicit dense CVode +solver. "; -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +%feature("docstring") cmf_core::CVodeDense::__call__ "def +__call__(self, t, dt=None, reset=False) -%feature("docstring") -cmf::upslope::connections::EnergyBudgetSnowMelt::kill_me "bool -kill_me() +Advances the integration until `t` A shortcut to .integrate_until +Parameters ---------- t : cmf.Time The time step to advance to. If +t < current time, the solver will advance to self.t + t dt : +cmf.Time, optional The timestep for the integration. If not given +try to integrate in one step reset : bool, optional If True, the +solver will perform a reset before starting Returns ------- cmf.Time +The new time stamp "; -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +%feature("docstring") cmf_core::CVodeDense::__getitem__ "def +__getitem__(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::EnergyBudgetSnowMelt::left_node "flux_node::ptr left_node() const +__getitem__(Integrator self, long position) -> +cmf::math::StateVariable::ptr "; -Returns the left node of this connection. "; +%feature("docstring") cmf_core::CVodeDense::__len__ "def +__len__(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::EnergyBudgetSnowMelt::q "real q(const -flux_node &inquirer, cmf::math::Time t) +__len__(Integrator self) -> size_t "; -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +%feature("docstring") cmf_core::CVodeDense::__repr__ "def +__repr__(self) "; -%feature("docstring") -cmf::upslope::connections::EnergyBudgetSnowMelt::refresh "void -refresh(cmf::math::Time t) +%feature("docstring") cmf_core::CVodeDense::add_single_state "def +add_single_state(self, args, kwargs) -Performes a new calculation of the flux. "; +add_single_state(Integrator self, cmf::math::StateVariable::ptr state) +virtual void add_single_state(cmf::math::StateVariable::ptr state) +Adds a single state variable to the integrator. "; -%feature("docstring") -cmf::upslope::connections::EnergyBudgetSnowMelt::right_node "flux_node::ptr right_node() const +%feature("docstring") cmf_core::CVodeDense::add_states "def +add_states(self, args, kwargs) -returns the right node of this connection "; +add_states(Integrator self, StateVariableOwner stateOwner) virtual +void add_states(cmf::math::StateVariableOwner &stateOwner) Add state +variables from a StateVariableOwner. "; -%feature("docstring") -cmf::upslope::connections::EnergyBudgetSnowMelt::set_tracer_filter "void set_tracer_filter(real value) +%feature("docstring") cmf_core::CVodeDense::copy "def copy(self, +args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. +copy(CVodeBase self) -> CVodeBase virtual Integrator* copy() const =0 +Polymorphic copy constructor. "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::CVodeDense::get_dt "def get_dt(self, +args, kwargs) -%feature("docstring") -cmf::upslope::connections::EnergyBudgetSnowMelt::set_tracer_filter "void set_tracer_filter(solute S, real value) "; +get_dt(Integrator self) -> Time cmf::math::Time get_dt() const +Returns the last time step. "; -%feature("docstring") -cmf::upslope::connections::EnergyBudgetSnowMelt::short_string "virtual std::string short_string() const "; +%feature("docstring") cmf_core::CVodeDense::get_dxdt "def +get_dxdt(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::EnergyBudgetSnowMelt::to_string "virtual -std::string to_string() const "; +get_dxdt(Integrator self, Time time) -> cmf::math::num_array +cmf::math::num_array get_dxdt(Time time) const "; +%feature("docstring") cmf_core::CVodeDense::get_error "def +get_error(self, args, kwargs) -// File: classcmf_1_1math_1_1_explicit_euler__fixed.xml -%feature("docstring") cmf::math::ExplicitEuler_fixed " +get_error(CVodeBase self) -> cmf::math::num_array "; -An explicit Euler integrator, with a fixed time step. +%feature("docstring") cmf_core::CVodeDense::get_info "def +get_info(self, args, kwargs) -C++ includes: explicit_euler.h "; +get_info(CVodeBase self) -> CVodeInfo "; + +%feature("docstring") cmf_core::CVodeDense::get_jacobian "def +get_jacobian(self) "; + +%feature("docstring") cmf_core::CVodeDense::get_state "def +get_state(self, args, kwargs) + +get_state(Integrator self, ptrdiff_t position) -> real real +get_state(ptrdiff_t position) const Returns the statevariable at +position Simplifies the assessment of state variables. "; + +%feature("docstring") cmf_core::CVodeDense::get_states "def +get_states(self, args) + +get_states(Integrator self) -> cmf::math::num_array +get_states(Integrator self) -> StateVariableList StateVariableList +get_states() gets the state variables of the integrator "; + +%feature("docstring") cmf_core::CVodeDense::get_t "def get_t(self, +args, kwargs) + +get_t(Integrator self) -> Time cmf::math::Time get_t() const Returns +the current model time. "; + +%feature("docstring") cmf_core::CVodeDense::initialize "def +initialize(self, args, kwargs) + +initialize(CVodeBase self) -> int "; + +%feature("docstring") cmf_core::CVodeDense::integrate "def +integrate(self, args, kwargs) + +integrate(Integrator self, Time t_max, Time dt) -> int virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt)=0 Integrates the +vector of state variables. Parameters: ----------- t_max: To stop +the model (if running in a model framework) at time steps of value +exchange e.g. full hours, the next value exchange time can be given +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; + +%feature("docstring") cmf_core::CVodeDense::integrate_until "def +integrate_until(self, args, kwargs) + +integrate_until(Integrator self, Time t_max, Time dt, bool +reset=False) void integrate_until(cmf::math::Time t_max, +cmf::math::Time dt=Time(), bool reset=false) Integrates the vector of +state variables until t_max. Parameters: ----------- t_max: Time, +the solver should run to dt: Time step (may be omitted) reset: If +true, solver is reseted before integration starts "; + +%feature("docstring") cmf_core::CVodeDense::reset "def reset(self, +args, kwargs) + +reset(Integrator self) virtual void reset() Resets any saved history +(for multistep methods) "; + +%feature("docstring") cmf_core::CVodeDense::run "def run(self, +start=None, end=None, step=day *1, max_errors=0, reset=False) + +Returns an iterator over the timesteps start..end **Examples:** >>> +solver=cmf.CVodeIntegrator(...) >>> for t in solver.run(solver.t, +solver.t + cmf.week, cmf.h): >>> print(t, solver[0].state) or with +list comprehension >>> states = [solver[0].state for t in +solver.run(solver.t, solver.t + cmf.week, cmf.h)] Parameters +---------- start : cmf.Time, optional Start time for the solver +iteration end : cmf.Time, optional End time of the iteration step : +cmf.Time, optional Step size for the integration max_errors: int +Number of tolerated errors. If >0, up to these number of runtime +errors will be saved with their time and the integration proceeds +after a reset of the solver. Some systems operate with values close to +their physical limits and inifinite values in the integration can +easily occur. For these kind of systems set max_errors to eg. 10. A +larger number of errors should be eliminated usually. reset: bool If +True, the solver performs a `reset` at every time step Yields ------ +cmf.Time the actual timestep "; + +%feature("docstring") cmf_core::CVodeDense::set_error_msg "def +set_error_msg(self, args, kwargs) + +set_error_msg(CVodeBase self, std::string error) "; + +%feature("docstring") cmf_core::CVodeDense::set_state "def +set_state(self, args, kwargs) + +set_state(Integrator self, ptrdiff_t position, real newState) void +set_state(ptrdiff_t position, real newState) Simplifies the +assessment of state variables. "; + +%feature("docstring") cmf_core::CVodeDense::set_t "def set_t(self, +args, kwargs) + +set_t(Integrator self, Time val) void set_t(cmf::math::Time val) Sets +the current model time. "; + +%feature("docstring") cmf_core::CVodeDense::size "def size(self, +args, kwargs) + +size(Integrator self) -> size_t size_t size() const returns the +number of state variables "; + +%feature("docstring") cmf_core::CVodeDense::to_string "def +to_string(self, args, kwargs) + +to_string(CVodeBase self) -> std::string "; + + +// File: classcmf_1_1math_1_1_c_vode_dense.xml +%feature("docstring") cmf::math::CVodeDense " + +implicit BDF CVode solver with full Jacobian approximation + +Use this solver for small but stiff systems (<20 state variables) + +The solver calculates for each step the full Jacobian matrix of the +system using a difference quotient approximation of the real Jacobian + +C++ includes: cvode.h "; /* Accuracy parameters */ /* model time */ -%feature("docstring") cmf::math::ExplicitEuler_fixed::get_t "cmf::math::Time get_t() const +%feature("docstring") cmf::math::CVodeDense::get_t "cmf::math::Time +get_t() const Returns the current model time. "; -%feature("docstring") cmf::math::ExplicitEuler_fixed::set_t "void +%feature("docstring") cmf::math::CVodeDense::set_t "void set_t(cmf::math::Time val) Sets the current model time. "; -%feature("docstring") cmf::math::ExplicitEuler_fixed::get_dt "cmf::math::Time get_dt() const +%feature("docstring") cmf::math::CVodeDense::get_dt "cmf::math::Time +get_dt() const Returns the last time step. "; -%feature("docstring") cmf::math::ExplicitEuler_fixed::reset "virtual -void reset() - -Resets any saved history (for multistep methods) "; - /* Integrate */ -%feature("docstring") cmf::math::ExplicitEuler_fixed::integrate_until -"void integrate_until(cmf::math::Time t_max, cmf::math::Time -dt=Time(), bool reset=false) +%feature("docstring") cmf::math::CVodeDense::integrate_until "void +integrate_until(cmf::math::Time t_max, cmf::math::Time dt=Time(), bool +reset=false) Integrates the vector of state variables until t_max. @@ -3930,55 +6910,38 @@ dt: Time step (may be omitted) reset: If true, solver is reseted before integration starts "; -%feature("docstring") -cmf::math::ExplicitEuler_fixed::ExplicitEuler_fixed "ExplicitEuler_fixed(StateVariableOwner &states) - -Constructs a new ExplicitEuler_fixed from a pointer to a vector of -state variables. - -The Integrator becomes the owner of states - -Parameters: ------------ - -states: Statevariables of the system "; - -%feature("docstring") -cmf::math::ExplicitEuler_fixed::ExplicitEuler_fixed "ExplicitEuler_fixed() +%feature("docstring") cmf::math::CVodeDense::CVodeDense "CVodeDense(cmf::math::StateVariableOwner &states, real epsilon=1e-9) -Constructs a new ExplicitEuler_fixed. "; +Creates a new implicit dense CVode solver. "; -%feature("docstring") -cmf::math::ExplicitEuler_fixed::ExplicitEuler_fixed "ExplicitEuler_fixed(const Integrator ©) +%feature("docstring") cmf::math::CVodeDense::_get_jacobian "virtual +cmf::math::num_array _get_jacobian() const -copy constructor "; +Returns a continuous 1D array representing the Jacobian columns +concatenated. -%feature("docstring") -cmf::math::ExplicitEuler_fixed::~ExplicitEuler_fixed "virtual -~ExplicitEuler_fixed() "; +In Python, get_jacobian returns the Jacobian as a 2D array "; -%feature("docstring") -cmf::math::ExplicitEuler_fixed::add_single_state "virtual void -add_single_state(cmf::math::StateVariable::ptr state) +%feature("docstring") cmf::math::CVodeDense::add_single_state "virtual void add_single_state(cmf::math::StateVariable::ptr state) Adds a single state variable to the integrator. "; -%feature("docstring") cmf::math::ExplicitEuler_fixed::add_states "void add_states(cmf::math::StateVariableOwner &stateOwner) +%feature("docstring") cmf::math::CVodeDense::add_states "virtual +void add_states(cmf::math::StateVariableOwner &stateOwner) Add state variables from a StateVariableOwner. "; -%feature("docstring") -cmf::math::ExplicitEuler_fixed::add_values_to_states "void -add_values_to_states(const num_array &operands) +%feature("docstring") cmf::math::CVodeDense::add_values_to_states "void add_values_to_states(const num_array &operands) Adds the values in operands to the current states. "; -%feature("docstring") cmf::math::ExplicitEuler_fixed::copy "virtual -Integrator* copy() const +%feature("docstring") cmf::math::CVodeDense::copy "CVodeBase* copy() +const -Polymorphic copy constructor. "; +Returns a copy of the solver. "; -%feature("docstring") cmf::math::ExplicitEuler_fixed::copy_dxdt "void copy_dxdt(Time time, num_array &destination, real factor=1) const +%feature("docstring") cmf::math::CVodeDense::copy_dxdt "void +copy_dxdt(Time time, num_array &destination, real factor=1) const Copies the derivatives at time step \"time\" to a numeric vector using use_OpenMP. @@ -3993,7 +6956,8 @@ destination: Vector to be overwritten by the results factor: A factor that is multiplied to the derivate (e.g. unit conversion or integration length) "; -%feature("docstring") cmf::math::ExplicitEuler_fixed::copy_dxdt "void copy_dxdt(Time time, real *destination, real factor=1) const +%feature("docstring") cmf::math::CVodeDense::copy_dxdt "void +copy_dxdt(Time time, real *destination, real factor=1) const Copies the derivatives at time step \"time\" to an preallocated c array. @@ -4008,1318 +6972,1438 @@ destination: Allocated c array factor: A factor that is multiplied to the derivate (e.g. unit conversion or integration length) "; -%feature("docstring") cmf::math::ExplicitEuler_fixed::copy_states "void copy_states(num_array &destination) const +%feature("docstring") cmf::math::CVodeDense::copy_states "void +copy_states(num_array &destination) const Copies the states to a numeric vector using use_OpenMP. "; -%feature("docstring") cmf::math::ExplicitEuler_fixed::copy_states "void copy_states(real *destination) const "; +%feature("docstring") cmf::math::CVodeDense::copy_states "void +copy_states(real *destination) const "; -%feature("docstring") cmf::math::ExplicitEuler_fixed::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; +%feature("docstring") cmf::math::CVodeDense::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; -%feature("docstring") cmf::math::ExplicitEuler_fixed::get_state "real get_state(ptrdiff_t position) const +%feature("docstring") cmf::math::CVodeDense::get_error "cmf::math::num_array get_error() const + +Error vector of the integrator. "; + +%feature("docstring") cmf::math::CVodeDense::get_info "CVodeInfo +get_info() const + +Returns the current solver statistics. "; + +%feature("docstring") cmf::math::CVodeDense::get_state "real +get_state(ptrdiff_t position) const Returns the statevariable at position Simplifies the assessment of state variables. "; -%feature("docstring") cmf::math::ExplicitEuler_fixed::get_states "cmf::math::num_array get_states() const "; +%feature("docstring") cmf::math::CVodeDense::get_states "cmf::math::num_array get_states() const "; -%feature("docstring") cmf::math::ExplicitEuler_fixed::get_states "StateVariableList get_states() +%feature("docstring") cmf::math::CVodeDense::get_states "StateVariableList get_states() gets the state variables of the integrator "; -%feature("docstring") cmf::math::ExplicitEuler_fixed::integrate "int -integrate(cmf::math::Time MaxTime, cmf::math::Time TimeStep) +%feature("docstring") cmf::math::CVodeDense::initialize "int +initialize() + +Initialize the internal memory. + +Automatically called, when one starts to integrate "; + +%feature("docstring") cmf::math::CVodeDense::integrate "virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt) Integrates the vector of state variables. Parameters: ----------- -MaxTime: (ignored) To stop the model (if running in a model -framework) at time steps of value exchange e.g. full hours, the next -value exchange time can be given +t_max: To stop the model (if running in a model framework) at time +steps of value exchange e.g. full hours, the next value exchange time +can be given -TimeStep: Takes the proposed time step "; +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; -%feature("docstring") cmf::math::ExplicitEuler_fixed::set_state "void set_state(ptrdiff_t position, real newState) +%feature("docstring") cmf::math::CVodeDense::reset "virtual void +reset() + +Resets the history of the multispte solver and overwrites the internal +state cache. "; + +%feature("docstring") cmf::math::CVodeDense::set_error_msg "void +set_error_msg(std::string error) + +Sets an error message. "; + +%feature("docstring") cmf::math::CVodeDense::set_state "void +set_state(ptrdiff_t position, real newState) Simplifies the assessment of state variables. "; -%feature("docstring") cmf::math::ExplicitEuler_fixed::set_states "void set_states(const num_array &newStates) +%feature("docstring") cmf::math::CVodeDense::set_states "void +set_states(const num_array &newStates) Copies the new states to the actual states. "; -%feature("docstring") cmf::math::ExplicitEuler_fixed::set_states "void set_states(real *newStates) "; +%feature("docstring") cmf::math::CVodeDense::set_states "void +set_states(real *newStates) "; -%feature("docstring") cmf::math::ExplicitEuler_fixed::size "size_t -size() const +%feature("docstring") cmf::math::CVodeDense::size "size_t size() +const returns the number of state variables "; +%feature("docstring") cmf::math::CVodeDense::to_string "std::string +to_string() const -// File: classcmf_1_1water_1_1_exponential_decline_connection.xml -%feature("docstring") cmf::water::ExponentialDeclineConnection " +Returns a string representation of the solver. "; -A conceptual TOPmodel inspired connection. +// File: classcmf__core_1_1_c_vode_diag.xml +%feature("docstring") cmf_core::CVodeDiag " +implicit BDF CVode solver with a one line diagonal Jacobian +approximation C++ includes: cvode3.h "; -.. math:: +%feature("docstring") cmf_core::CVodeDiag::__init__ "def +__init__(self, args, kwargs) - q = Q_0 \\\\cdot e^{(V-V_0)/m} +__init__(cmf::math::CVodeDiag self, StateVariableOwner states, real +epsilon=1e-9) -> CVodeDiag CVodeDiag(cmf::math::StateVariableOwner +&states, real epsilon=1e-9) "; -C++ includes: simple_connections.h "; +%feature("docstring") cmf_core::CVodeDiag::__call__ "def +__call__(self, t, dt=None, reset=False) -%feature("docstring") -cmf::water::ExponentialDeclineConnection::ExponentialDeclineConnection -"ExponentialDeclineConnection(WaterStorage::ptr source, -flux_node::ptr target, real Q0, real V0, real m) +Advances the integration until `t` A shortcut to .integrate_until +Parameters ---------- t : cmf.Time The time step to advance to. If +t < current time, the solver will advance to self.t + t dt : +cmf.Time, optional The timestep for the integration. If not given +try to integrate in one step reset : bool, optional If True, the +solver will perform a reset before starting Returns ------- cmf.Time +The new time stamp "; -creates the exponential decline connection "; +%feature("docstring") cmf_core::CVodeDiag::__getitem__ "def +__getitem__(self, args, kwargs) -%feature("docstring") cmf::water::ExponentialDeclineConnection::conc -"real conc(cmf::math::Time t, const cmf::water::solute &_Solute) +__getitem__(Integrator self, long position) -> +cmf::math::StateVariable::ptr "; -Returns the concentration of the flux. +%feature("docstring") cmf_core::CVodeDiag::__len__ "def +__len__(self, args, kwargs) -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +__len__(Integrator self) -> size_t "; -%feature("docstring") -cmf::water::ExponentialDeclineConnection::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +%feature("docstring") cmf_core::CVodeDiag::__repr__ "def +__repr__(self) "; -%feature("docstring") -cmf::water::ExponentialDeclineConnection::get_ptr "ptr get_ptr() -const "; +%feature("docstring") cmf_core::CVodeDiag::add_single_state "def +add_single_state(self, args, kwargs) -%feature("docstring") -cmf::water::ExponentialDeclineConnection::get_target "flux_node::ptr -get_target(const flux_node &inquirer) +add_single_state(Integrator self, cmf::math::StateVariable::ptr state) +virtual void add_single_state(cmf::math::StateVariable::ptr state) +Adds a single state variable to the integrator. "; -Returns the other end of a connection than the asking end. "; +%feature("docstring") cmf_core::CVodeDiag::add_states "def +add_states(self, args, kwargs) -%feature("docstring") -cmf::water::ExponentialDeclineConnection::get_target "flux_node::ptr -get_target(int index) const +add_states(Integrator self, StateVariableOwner stateOwner) virtual +void add_states(cmf::math::StateVariableOwner &stateOwner) Add state +variables from a StateVariableOwner. "; -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +%feature("docstring") cmf_core::CVodeDiag::copy "def copy(self, +args, kwargs) -%feature("docstring") -cmf::water::ExponentialDeclineConnection::get_tracer_filter "real -get_tracer_filter() +copy(CVodeBase self) -> CVodeBase virtual Integrator* copy() const =0 +Polymorphic copy constructor. "; -A value ranging from 0 to 1 to filter tracers out of the water flux. +%feature("docstring") cmf_core::CVodeDiag::get_dt "def get_dt(self, +args, kwargs) -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +get_dt(Integrator self) -> Time cmf::math::Time get_dt() const +Returns the last time step. "; -%feature("docstring") -cmf::water::ExponentialDeclineConnection::get_tracer_filter "real -get_tracer_filter(solute S) +%feature("docstring") cmf_core::CVodeDiag::get_dxdt "def +get_dxdt(self, args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +get_dxdt(Integrator self, Time time) -> cmf::math::num_array +cmf::math::num_array get_dxdt(Time time) const "; -%feature("docstring") -cmf::water::ExponentialDeclineConnection::kill_me "bool kill_me() +%feature("docstring") cmf_core::CVodeDiag::get_error "def +get_error(self, args, kwargs) -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +get_error(CVodeBase self) -> cmf::math::num_array "; -%feature("docstring") -cmf::water::ExponentialDeclineConnection::left_node "flux_node::ptr -left_node() const +%feature("docstring") cmf_core::CVodeDiag::get_info "def +get_info(self, args, kwargs) -Returns the left node of this connection. "; +get_info(CVodeBase self) -> CVodeInfo "; -%feature("docstring") cmf::water::ExponentialDeclineConnection::q "real q(const flux_node &inquirer, cmf::math::Time t) +%feature("docstring") cmf_core::CVodeDiag::get_jacobian "def +get_jacobian(self) "; -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +%feature("docstring") cmf_core::CVodeDiag::get_state "def +get_state(self, args, kwargs) -%feature("docstring") -cmf::water::ExponentialDeclineConnection::refresh "void -refresh(cmf::math::Time t) +get_state(Integrator self, ptrdiff_t position) -> real real +get_state(ptrdiff_t position) const Returns the statevariable at +position Simplifies the assessment of state variables. "; -Performes a new calculation of the flux. "; +%feature("docstring") cmf_core::CVodeDiag::get_states "def +get_states(self, args) -%feature("docstring") -cmf::water::ExponentialDeclineConnection::right_node "flux_node::ptr -right_node() const +get_states(Integrator self) -> cmf::math::num_array +get_states(Integrator self) -> StateVariableList StateVariableList +get_states() gets the state variables of the integrator "; -returns the right node of this connection "; +%feature("docstring") cmf_core::CVodeDiag::get_t "def get_t(self, +args, kwargs) -%feature("docstring") -cmf::water::ExponentialDeclineConnection::set_tracer_filter "void -set_tracer_filter(real value) +get_t(Integrator self) -> Time cmf::math::Time get_t() const Returns +the current model time. "; -A value ranging from 0 to 1 to filter tracers out of the water flux. +%feature("docstring") cmf_core::CVodeDiag::initialize "def +initialize(self, args, kwargs) -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +initialize(CVodeBase self) -> int "; -%feature("docstring") -cmf::water::ExponentialDeclineConnection::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; +%feature("docstring") cmf_core::CVodeDiag::integrate "def +integrate(self, args, kwargs) -%feature("docstring") -cmf::water::ExponentialDeclineConnection::short_string "virtual -std::string short_string() const "; +integrate(Integrator self, Time t_max, Time dt) -> int virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt)=0 Integrates the +vector of state variables. Parameters: ----------- t_max: To stop +the model (if running in a model framework) at time steps of value +exchange e.g. full hours, the next value exchange time can be given +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; -%feature("docstring") -cmf::water::ExponentialDeclineConnection::to_string "virtual -std::string to_string() const "; +%feature("docstring") cmf_core::CVodeDiag::integrate_until "def +integrate_until(self, args, kwargs) +integrate_until(Integrator self, Time t_max, Time dt, bool +reset=False) void integrate_until(cmf::math::Time t_max, +cmf::math::Time dt=Time(), bool reset=false) Integrates the vector of +state variables until t_max. Parameters: ----------- t_max: Time, +the solver should run to dt: Time step (may be omitted) reset: If +true, solver is reseted before integration starts "; -// File: classcmf_1_1water_1_1external__control__connection.xml -%feature("docstring") cmf::water::external_control_connection " +%feature("docstring") cmf_core::CVodeDiag::reset "def reset(self, +args, kwargs) -Flux from one node to another, controlled by the user or an external -program, by changing the flux constant. +reset(Integrator self) virtual void reset() Resets any saved history +(for multistep methods) "; -It is easy to create negative volumes in water storages with this -connection, which can be hazard to the solver, since most connections -rely on a positive volume in a storage. Handle with care! +%feature("docstring") cmf_core::CVodeDiag::run "def run(self, +start=None, end=None, step=day *1, max_errors=0, reset=False) -C++ includes: simple_connections.h "; +Returns an iterator over the timesteps start..end **Examples:** >>> +solver=cmf.CVodeIntegrator(...) >>> for t in solver.run(solver.t, +solver.t + cmf.week, cmf.h): >>> print(t, solver[0].state) or with +list comprehension >>> states = [solver[0].state for t in +solver.run(solver.t, solver.t + cmf.week, cmf.h)] Parameters +---------- start : cmf.Time, optional Start time for the solver +iteration end : cmf.Time, optional End time of the iteration step : +cmf.Time, optional Step size for the integration max_errors: int +Number of tolerated errors. If >0, up to these number of runtime +errors will be saved with their time and the integration proceeds +after a reset of the solver. Some systems operate with values close to +their physical limits and inifinite values in the integration can +easily occur. For these kind of systems set max_errors to eg. 10. A +larger number of errors should be eliminated usually. reset: bool If +True, the solver performs a `reset` at every time step Yields ------ +cmf.Time the actual timestep "; -%feature("docstring") -cmf::water::external_control_connection::external_control_connection "external_control_connection(flux_node::ptr source, flux_node::ptr -target, real flux_value=0) "; +%feature("docstring") cmf_core::CVodeDiag::set_error_msg "def +set_error_msg(self, args, kwargs) -%feature("docstring") cmf::water::external_control_connection::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) +set_error_msg(CVodeBase self, std::string error) "; -Returns the concentration of the flux. +%feature("docstring") cmf_core::CVodeDiag::set_state "def +set_state(self, args, kwargs) -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +set_state(Integrator self, ptrdiff_t position, real newState) void +set_state(ptrdiff_t position, real newState) Simplifies the +assessment of state variables. "; -%feature("docstring") -cmf::water::external_control_connection::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +%feature("docstring") cmf_core::CVodeDiag::set_t "def set_t(self, +args, kwargs) -%feature("docstring") -cmf::water::external_control_connection::get_ptr "ptr get_ptr() const -"; +set_t(Integrator self, Time val) void set_t(cmf::math::Time val) Sets +the current model time. "; -%feature("docstring") -cmf::water::external_control_connection::get_target "flux_node::ptr -get_target(const flux_node &inquirer) +%feature("docstring") cmf_core::CVodeDiag::size "def size(self, +args, kwargs) -Returns the other end of a connection than the asking end. "; +size(Integrator self) -> size_t size_t size() const returns the +number of state variables "; -%feature("docstring") -cmf::water::external_control_connection::get_target "flux_node::ptr -get_target(int index) const +%feature("docstring") cmf_core::CVodeDiag::to_string "def +to_string(self, args, kwargs) -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +to_string(CVodeBase self) -> std::string "; -%feature("docstring") -cmf::water::external_control_connection::get_tracer_filter "real -get_tracer_filter() -A value ranging from 0 to 1 to filter tracers out of the water flux. +// File: classcmf_1_1math_1_1_c_vode_diag.xml +%feature("docstring") cmf::math::CVodeDiag " -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +implicit BDF CVode solver with a one line diagonal Jacobian +approximation -%feature("docstring") -cmf::water::external_control_connection::get_tracer_filter "real -get_tracer_filter(solute S) +C++ includes: cvode.h "; -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +/* Accuracy parameters */ -%feature("docstring") -cmf::water::external_control_connection::kill_me "bool kill_me() +/* model time */ -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +%feature("docstring") cmf::math::CVodeDiag::get_t "cmf::math::Time +get_t() const -%feature("docstring") -cmf::water::external_control_connection::left_node "flux_node::ptr -left_node() const +Returns the current model time. "; -Returns the left node of this connection. "; +%feature("docstring") cmf::math::CVodeDiag::set_t "void +set_t(cmf::math::Time val) -%feature("docstring") cmf::water::external_control_connection::q "real q(const flux_node &inquirer, cmf::math::Time t) +Sets the current model time. "; -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +%feature("docstring") cmf::math::CVodeDiag::get_dt "cmf::math::Time +get_dt() const -%feature("docstring") -cmf::water::external_control_connection::refresh "void -refresh(cmf::math::Time t) +Returns the last time step. "; -Performes a new calculation of the flux. "; +/* Integrate */ -%feature("docstring") -cmf::water::external_control_connection::right_node "flux_node::ptr -right_node() const +%feature("docstring") cmf::math::CVodeDiag::integrate_until "void +integrate_until(cmf::math::Time t_max, cmf::math::Time dt=Time(), bool +reset=false) -returns the right node of this connection "; +Integrates the vector of state variables until t_max. -%feature("docstring") -cmf::water::external_control_connection::set_tracer_filter "void -set_tracer_filter(real value) +Parameters: +----------- -A value ranging from 0 to 1 to filter tracers out of the water flux. +t_max: Time, the solver should run to -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +dt: Time step (may be omitted) -%feature("docstring") -cmf::water::external_control_connection::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; +reset: If true, solver is reseted before integration starts "; -%feature("docstring") -cmf::water::external_control_connection::short_string "virtual -std::string short_string() const "; +%feature("docstring") cmf::math::CVodeDiag::CVodeDiag "CVodeDiag(cmf::math::StateVariableOwner &states, real epsilon=1e-9) "; -%feature("docstring") -cmf::water::external_control_connection::to_string "virtual -std::string to_string() const "; +%feature("docstring") cmf::math::CVodeDiag::_get_jacobian "virtual +cmf::math::num_array _get_jacobian() const +Returns a continuous 1D array representing the Jacobian columns +concatenated. -// File: classcmf_1_1fit__retention__curve_1_1_fit_brooks_corey.xml -%feature("docstring") cmf::fit_retention_curve::FitBrooksCorey ""; +In Python, get_jacobian returns the Jacobian as a 2D array "; -%feature("docstring") -cmf::fit_retention_curve::FitBrooksCorey::__init__ "def -__init__(self, theta, pF, verbose=False) "; +%feature("docstring") cmf::math::CVodeDiag::add_single_state "virtual void add_single_state(cmf::math::StateVariable::ptr state) -%feature("docstring") -cmf::fit_retention_curve::FitBrooksCorey::__call__ "def -__call__(self, count=1) "; +Adds a single state variable to the integrator. "; -%feature("docstring") -cmf::fit_retention_curve::FitBrooksCorey::create_rc "def -create_rc(self, params) "; +%feature("docstring") cmf::math::CVodeDiag::add_states "virtual void +add_states(cmf::math::StateVariableOwner &stateOwner) -%feature("docstring") -cmf::fit_retention_curve::FitBrooksCorey::get_error "def -get_error(self, params) "; +Add state variables from a StateVariableOwner. "; +%feature("docstring") cmf::math::CVodeDiag::add_values_to_states "void add_values_to_states(const num_array &operands) -// File: classcmf_1_1fit__retention__curve_1_1_fit_retention_curve.xml -%feature("docstring") cmf::fit_retention_curve::FitRetentionCurve ""; +Adds the values in operands to the current states. "; -%feature("docstring") -cmf::fit_retention_curve::FitRetentionCurve::__init__ "def -__init__(self, rc_class, theta, pF, verbose=False) "; +%feature("docstring") cmf::math::CVodeDiag::copy "CVodeBase* copy() +const -%feature("docstring") -cmf::fit_retention_curve::FitRetentionCurve::__call__ "def -__call__(self, count=1) "; +Returns a copy of the solver. "; -%feature("docstring") -cmf::fit_retention_curve::FitRetentionCurve::create_rc "def -create_rc(self, params) "; +%feature("docstring") cmf::math::CVodeDiag::copy_dxdt "void +copy_dxdt(Time time, num_array &destination, real factor=1) const -%feature("docstring") -cmf::fit_retention_curve::FitRetentionCurve::get_error "def -get_error(self, params) "; +Copies the derivatives at time step \"time\" to a numeric vector using +use_OpenMP. +Parameters: +----------- -// File: classcmf_1_1fit__retention__curve_1_1_fit_van_genuchten_mualem.xml -%feature("docstring") cmf::fit_retention_curve::FitVanGenuchtenMualem -""; +time: Time at which the derivatives should be calculated -%feature("docstring") -cmf::fit_retention_curve::FitVanGenuchtenMualem::__init__ "def -__init__(self, theta, pF, fit_theta_r=False, fit_m=False, -verbose=False) "; +destination: Vector to be overwritten by the results -%feature("docstring") -cmf::fit_retention_curve::FitVanGenuchtenMualem::__call__ "def -__call__(self, count=1) "; +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; -%feature("docstring") -cmf::fit_retention_curve::FitVanGenuchtenMualem::create_rc "def -create_rc(self, params) "; +%feature("docstring") cmf::math::CVodeDiag::copy_dxdt "void +copy_dxdt(Time time, real *destination, real factor=1) const -%feature("docstring") -cmf::fit_retention_curve::FitVanGenuchtenMualem::get_error "def -get_error(self, params) "; +Copies the derivatives at time step \"time\" to an preallocated c +array. +Parameters: +----------- -// File: classcmf_1_1water_1_1flux__connection.xml -%feature("docstring") cmf::water::flux_connection " +time: Time at which the derivatives should be calculated -The connections in cmf hold the processes for the calculation of -fluxes between water storages and model boundaries. +destination: Allocated c array -Todo Elaborate on this Represents a connection between flux_nodes, -where water fluxes occur. +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; -C++ includes: flux_connection.h "; +%feature("docstring") cmf::math::CVodeDiag::copy_states "void +copy_states(num_array &destination) const -%feature("docstring") cmf::water::flux_connection::flux_connection "flux_connection(flux_node::ptr left, flux_node::ptr right, std::string -_type) +Copies the states to a numeric vector using use_OpenMP. "; -Creates a flux connection between the flux_node left and right. +%feature("docstring") cmf::math::CVodeDiag::copy_states "void +copy_states(real *destination) const "; -Parameters: ------------ +%feature("docstring") cmf::math::CVodeDiag::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; -left: flux_node on the one side of the connection +%feature("docstring") cmf::math::CVodeDiag::get_error "cmf::math::num_array get_error() const -right: flux_node on the other side of the connection +Error vector of the integrator. "; -_type: Type of the flux connection "; +%feature("docstring") cmf::math::CVodeDiag::get_info "CVodeInfo +get_info() const -%feature("docstring") cmf::water::flux_connection::~flux_connection "virtual ~flux_connection() "; +Returns the current solver statistics. "; -%feature("docstring") cmf::water::flux_connection::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +%feature("docstring") cmf::math::CVodeDiag::get_state "real +get_state(ptrdiff_t position) const -Returns the concentration of the flux. +Returns the statevariable at position Simplifies the assessment of +state variables. "; -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +%feature("docstring") cmf::math::CVodeDiag::get_states "cmf::math::num_array get_states() const "; -%feature("docstring") cmf::water::flux_connection::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr -newTarget) "; +%feature("docstring") cmf::math::CVodeDiag::get_states "StateVariableList get_states() -%feature("docstring") cmf::water::flux_connection::get_ptr "ptr -get_ptr() const "; +gets the state variables of the integrator "; -%feature("docstring") cmf::water::flux_connection::get_target "flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") cmf::math::CVodeDiag::initialize "int +initialize() -Returns the other end of a connection than the asking end. "; +Initialize the internal memory. -%feature("docstring") cmf::water::flux_connection::get_target "flux_node::ptr get_target(int index) const +Automatically called, when one starts to integrate "; -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +%feature("docstring") cmf::math::CVodeDiag::integrate "virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt) -%feature("docstring") cmf::water::flux_connection::get_tracer_filter -"real get_tracer_filter() +Integrates the vector of state variables. -A value ranging from 0 to 1 to filter tracers out of the water flux. +Parameters: +----------- -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +t_max: To stop the model (if running in a model framework) at time +steps of value exchange e.g. full hours, the next value exchange time +can be given -%feature("docstring") cmf::water::flux_connection::get_tracer_filter -"real get_tracer_filter(solute S) +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +%feature("docstring") cmf::math::CVodeDiag::reset "virtual void +reset() -%feature("docstring") cmf::water::flux_connection::kill_me "bool -kill_me() +Resets the history of the multispte solver and overwrites the internal +state cache. "; -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +%feature("docstring") cmf::math::CVodeDiag::set_error_msg "void +set_error_msg(std::string error) -%feature("docstring") cmf::water::flux_connection::left_node "flux_node::ptr left_node() const +Sets an error message. "; -Returns the left node of this connection. "; +%feature("docstring") cmf::math::CVodeDiag::set_state "void +set_state(ptrdiff_t position, real newState) -%feature("docstring") cmf::water::flux_connection::q "real q(const -flux_node &inquirer, cmf::math::Time t) +Simplifies the assessment of state variables. "; -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +%feature("docstring") cmf::math::CVodeDiag::set_states "void +set_states(const num_array &newStates) -%feature("docstring") cmf::water::flux_connection::refresh "void -refresh(cmf::math::Time t) +Copies the new states to the actual states. "; -Performes a new calculation of the flux. "; +%feature("docstring") cmf::math::CVodeDiag::set_states "void +set_states(real *newStates) "; -%feature("docstring") cmf::water::flux_connection::right_node "flux_node::ptr right_node() const +%feature("docstring") cmf::math::CVodeDiag::size "size_t size() +const -returns the right node of this connection "; +returns the number of state variables "; -%feature("docstring") cmf::water::flux_connection::set_tracer_filter -"void set_tracer_filter(real value) +%feature("docstring") cmf::math::CVodeDiag::to_string "std::string +to_string() const -A value ranging from 0 to 1 to filter tracers out of the water flux. +Returns a string representation of the solver. "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; -%feature("docstring") cmf::water::flux_connection::set_tracer_filter -"void set_tracer_filter(solute S, real value) "; +// File: classcmf__core_1_1_c_vode_info.xml +%feature("docstring") cmf_core::CVodeInfo " -%feature("docstring") cmf::water::flux_connection::short_string "virtual std::string short_string() const "; +Reports the current state of a CVode solver. C++ includes: cvode3.h +"; -%feature("docstring") cmf::water::flux_connection::to_string "virtual std::string to_string() const "; +%feature("docstring") cmf_core::CVodeInfo::__init__ "def +__init__(self, args, kwargs) +__init__(cmf::math::CVodeInfo self) -> CVodeInfo "; -// File: classcmf_1_1water_1_1flux__integrator.xml -%feature("docstring") cmf::water::flux_integrator " +%feature("docstring") cmf_core::CVodeInfo::to_string "def +to_string(self, args, kwargs) -The flux_integrator is an integratable for precise output of average -fluxes over time. +to_string(CVodeInfo self) -> std::string std::string to_string() +const "; -It can be added to solver (any cmf::math::Integrator), which is then -calling the integrate method at each substep. -C++ includes: flux_connection.h "; +// File: structcmf_1_1math_1_1_c_vode_info.xml +%feature("docstring") cmf::math::CVodeInfo " -%feature("docstring") cmf::water::flux_integrator::flux_integrator "flux_integrator(cmf::water::flux_connection &connection) +Reports the current state of a CVode solver. -Creates a flux_integrator from an connection. "; +C++ includes: cvode.h "; -%feature("docstring") cmf::water::flux_integrator::flux_integrator "flux_integrator(cmf::water::flux_node::ptr left, -cmf::water::flux_node::ptr right) +%feature("docstring") cmf::math::CVodeInfo::to_string "std::string +to_string() const "; -Creates a flux_integrator from the endpoints of a connection. Throws -if there is no connection between the endpoints. "; -%feature("docstring") cmf::water::flux_integrator::avg "double avg() -const +// File: classcmf__core_1_1_c_vode_k_l_u.xml +%feature("docstring") cmf_core::CVodeKLU " -Returns the average flux of the integration time in m3/day. "; +Proxy of C++ cmf::math::CVodeKLU class. "; -%feature("docstring") cmf::water::flux_integrator::connection "flux_connection::ptr connection() const +%feature("docstring") cmf_core::CVodeKLU::__init__ "def +__init__(self, args, kwargs) -Returns the flux_connection. "; +__init__(cmf::math::CVodeKLU self, StateVariableOwner states, real +epsilon=1e-9) -> CVodeKLU CVodeKLU(cmf::math::StateVariableOwner +&states, real epsilon=1e-9) "; -%feature("docstring") cmf::water::flux_integrator::integrate "void -integrate(cmf::math::Time until) +%feature("docstring") cmf_core::CVodeKLU::__call__ "def +__call__(self, t, dt=None, reset=False) -Integrates the flux a timestep further. Note: until is an absolute -time. If until is before t0, the integration is initilized again. "; +Advances the integration until `t` A shortcut to .integrate_until +Parameters ---------- t : cmf.Time The time step to advance to. If +t < current time, the solver will advance to self.t + t dt : +cmf.Time, optional The timestep for the integration. If not given +try to integrate in one step reset : bool, optional If True, the +solver will perform a reset before starting Returns ------- cmf.Time +The new time stamp "; -%feature("docstring") cmf::water::flux_integrator::integration_t "cmf::math::Time integration_t() const +%feature("docstring") cmf_core::CVodeKLU::__getitem__ "def +__getitem__(self, args, kwargs) -Returns the duration of the integration. "; +__getitem__(Integrator self, long position) -> +cmf::math::StateVariable::ptr "; -%feature("docstring") cmf::water::flux_integrator::reset "void -reset(cmf::math::Time t) +%feature("docstring") cmf_core::CVodeKLU::__len__ "def __len__(self, +args, kwargs) -Initializes the integration. "; +__len__(Integrator self) -> size_t "; -%feature("docstring") cmf::water::flux_integrator::sum "double sum() -const +%feature("docstring") cmf_core::CVodeKLU::__repr__ "def +__repr__(self) "; -Returns the amount of water along this connection in the integration -time in m3. "; +%feature("docstring") cmf_core::CVodeKLU::add_single_state "def +add_single_state(self, args, kwargs) -%feature("docstring") cmf::water::flux_integrator::t0 "cmf::math::Time t0() const +add_single_state(Integrator self, cmf::math::StateVariable::ptr state) +virtual void add_single_state(cmf::math::StateVariable::ptr state) +Adds a single state variable to the integrator. "; -Returns the start time of the integration. "; +%feature("docstring") cmf_core::CVodeKLU::add_states "def +add_states(self, args, kwargs) +add_states(Integrator self, StateVariableOwner stateOwner) virtual +void add_states(cmf::math::StateVariableOwner &stateOwner) Add state +variables from a StateVariableOwner. "; -// File: classcmf_1_1water_1_1flux__node.xml -%feature("docstring") cmf::water::flux_node " +%feature("docstring") cmf_core::CVodeKLU::copy "def copy(self, args, +kwargs) -Base class for everything that can be connected by fluxes. +copy(CVodeBase self) -> CVodeBase virtual Integrator* copy() const =0 +Polymorphic copy constructor. "; -Flux nodes can be WaterStorages, flux end points, sinks, sources and -bridges to other model domains (e.g. Ponded water to river system). -The base class can be used where a simple routing, potentially with -mixing, is needed. +%feature("docstring") cmf_core::CVodeKLU::get_dt "def get_dt(self, +args, kwargs) -C++ includes: flux_node.h "; +get_dt(Integrator self) -> Time cmf::math::Time get_dt() const +Returns the last time step. "; -%feature("docstring") cmf::water::flux_node::flux_node "flux_node(cmf::project &_project, cmf::geometry::point -location=cmf::geometry::point()) "; +%feature("docstring") cmf_core::CVodeKLU::get_dxdt "def +get_dxdt(self, args, kwargs) -%feature("docstring") cmf::water::flux_node::~flux_node "virtual -~flux_node() +get_dxdt(Integrator self, Time time) -> cmf::math::num_array +cmf::math::num_array get_dxdt(Time time) const "; -The destructor deletes all connections. "; +%feature("docstring") cmf_core::CVodeKLU::get_error "def +get_error(self, args, kwargs) -%feature("docstring") cmf::water::flux_node::conc "virtual real -conc(cmf::math::Time t, const cmf::water::solute &Solute) const +get_error(CVodeBase self) -> cmf::math::num_array "; -Returns the water quality of the flux_node, if it is not overridden -this is the mix of the incoming fluxes. "; +%feature("docstring") cmf_core::CVodeKLU::get_info "def +get_info(self, args, kwargs) -%feature("docstring") cmf::water::flux_node::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node -&target) +get_info(CVodeBase self) -> CVodeInfo "; -Returns the connection between this and target. "; +%feature("docstring") cmf_core::CVodeKLU::get_jacobian "def +get_jacobian(self) "; -%feature("docstring") cmf::water::flux_node::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, -cmf::math::Time t) "; +%feature("docstring") cmf_core::CVodeKLU::get_state "def +get_state(self, args, kwargs) -%feature("docstring") cmf::water::flux_node::flux_to "real -flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +get_state(Integrator self, ptrdiff_t position) -> real real +get_state(ptrdiff_t position) const Returns the statevariable at +position Simplifies the assessment of state variables. "; -Returns the actual flux between this and target (positive sign means -\"from this into target\") "; +%feature("docstring") cmf_core::CVodeKLU::get_states "def +get_states(self, args) -%feature("docstring") cmf::water::flux_node::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) +get_states(Integrator self) -> cmf::math::num_array +get_states(Integrator self) -> StateVariableList StateVariableList +get_states() gets the state variables of the integrator "; -Returns the sum of all flux vectors. "; +%feature("docstring") cmf_core::CVodeKLU::get_t "def get_t(self, +args, kwargs) -%feature("docstring") cmf::water::flux_node::get_connections "cmf::water::connection_list get_connections() const "; +get_t(Integrator self) -> Time cmf::math::Time get_t() const Returns +the current model time. "; -%feature("docstring") cmf::water::flux_node::get_potential "virtual -real get_potential() const +%feature("docstring") cmf_core::CVodeKLU::initialize "def +initialize(self, args, kwargs) -Returns the water potential of the node in m waterhead. +initialize(CVodeBase self) -> int "; -The base class water storage always returns the height of the location -"; +%feature("docstring") cmf_core::CVodeKLU::integrate "def +integrate(self, args, kwargs) -%feature("docstring") cmf::water::flux_node::get_project "cmf::project& get_project() const +integrate(Integrator self, Time t_max, Time dt) -> int virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt)=0 Integrates the +vector of state variables. Parameters: ----------- t_max: To stop +the model (if running in a model framework) at time steps of value +exchange e.g. full hours, the next value exchange time can be given +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; -Returns the project, this node is part of. "; +%feature("docstring") cmf_core::CVodeKLU::integrate_until "def +integrate_until(self, args, kwargs) -%feature("docstring") cmf::water::flux_node::is_empty "virtual -double is_empty() const +integrate_until(Integrator self, Time t_max, Time dt, bool +reset=False) void integrate_until(cmf::math::Time t_max, +cmf::math::Time dt=Time(), bool reset=false) Integrates the vector of +state variables until t_max. Parameters: ----------- t_max: Time, +the solver should run to dt: Time step (may be omitted) reset: If +true, solver is reseted before integration starts "; -Returns true if the node has no water. "; +%feature("docstring") cmf_core::CVodeKLU::reset "def reset(self, +args, kwargs) -%feature("docstring") cmf::water::flux_node::is_storage "virtual -bool is_storage() const +reset(Integrator self) virtual void reset() Resets any saved history +(for multistep methods) "; -true, if this is a waterstorage "; +%feature("docstring") cmf_core::CVodeKLU::run "def run(self, +start=None, end=None, step=day *1, max_errors=0, reset=False) -%feature("docstring") cmf::water::flux_node::RecalcFluxes "virtual -bool RecalcFluxes(cmf::math::Time t) +Returns an iterator over the timesteps start..end **Examples:** >>> +solver=cmf.CVodeIntegrator(...) >>> for t in solver.run(solver.t, +solver.t + cmf.week, cmf.h): >>> print(t, solver[0].state) or with +list comprehension >>> states = [solver[0].state for t in +solver.run(solver.t, solver.t + cmf.week, cmf.h)] Parameters +---------- start : cmf.Time, optional Start time for the solver +iteration end : cmf.Time, optional End time of the iteration step : +cmf.Time, optional Step size for the integration max_errors: int +Number of tolerated errors. If >0, up to these number of runtime +errors will be saved with their time and the integration proceeds +after a reset of the solver. Some systems operate with values close to +their physical limits and inifinite values in the integration can +easily occur. For these kind of systems set max_errors to eg. 10. A +larger number of errors should be eliminated usually. reset: bool If +True, the solver performs a `reset` at every time step Yields ------ +cmf.Time the actual timestep "; -Pure flux_nodes do not influence fluxes, therefore no recalculation of -fluxes is required by flux_node. +%feature("docstring") cmf_core::CVodeKLU::set_error_msg "def +set_error_msg(self, args, kwargs) -WaterStorage overrides this, since state changes require an update of -the fluxes "; +set_error_msg(CVodeBase self, std::string error) "; -%feature("docstring") cmf::water::flux_node::remove_connection "bool -remove_connection(cmf::water::flux_node::ptr To) +%feature("docstring") cmf_core::CVodeKLU::set_state "def +set_state(self, args, kwargs) -Remove the connection. "; +set_state(Integrator self, ptrdiff_t position, real newState) void +set_state(ptrdiff_t position, real newState) Simplifies the +assessment of state variables. "; -%feature("docstring") cmf::water::flux_node::set_potential "virtual -void set_potential(real new_potential) +%feature("docstring") cmf_core::CVodeKLU::set_t "def set_t(self, +args, kwargs) -Sets the potential of this flux node. "; +set_t(Integrator self, Time val) void set_t(cmf::math::Time val) Sets +the current model time. "; -%feature("docstring") cmf::water::flux_node::to_string "virtual -std::string to_string() const "; +%feature("docstring") cmf_core::CVodeKLU::size "def size(self, args, +kwargs) -%feature("docstring") cmf::water::flux_node::waterbalance "real -waterbalance(cmf::math::Time t, const flux_connection *Without=0) -const +size(Integrator self) -> size_t size_t size() const returns the +number of state variables "; -Returns the sum of all fluxes (positive and negative) at time t. +%feature("docstring") cmf_core::CVodeKLU::to_string "def +to_string(self, args, kwargs) -Single fluxes can be excluded from the calculation +to_string(CVodeBase self) -> std::string "; -Parameters: ------------ -t: Time of the query +// File: classcmf_1_1math_1_1_c_vode_k_l_u.xml +%feature("docstring") cmf::math::CVodeKLU ""; -Without: A flux_connection that is excluded from the waterbalance -(e.g. to prevent closed circuits) "; +/* model time */ +%feature("docstring") cmf::math::CVodeKLU::get_t "cmf::math::Time +get_t() const -// File: classcmf_1_1draw_1_1cellmap_1_1_flux_map.xml -%feature("docstring") cmf::draw::cellmap::FluxMap " +Returns the current model time. "; -Draws for each cell an arrow indicating the direction and velocity of -flow through the cell (in horizontal direction). Uses plt.quiver The -FluxMap can be updated by calling it with the new timestep Usage: >>> -import cmf >>> p = cmf.project() >>> solver = cmf.RKFIntegrator(p, -1e-9) >>> fm = FluxMap(p, cmf.Time()) >>> for t in -solver.run(solver.t, solver.t + cmf.day * 30, cmf.h): ... fm(t) "; +%feature("docstring") cmf::math::CVodeKLU::set_t "void +set_t(cmf::math::Time val) -%feature("docstring") cmf::draw::cellmap::FluxMap::__init__ "def -__init__(self, cells, t, kwargs) +Sets the current model time. "; -Creates a new flux map :param cells: The cells to be used :param t: -The current time step :param kwargs: Keyword arguments for plt.quiver -"; +%feature("docstring") cmf::math::CVodeKLU::get_dt "cmf::math::Time +get_dt() const -%feature("docstring") cmf::draw::cellmap::FluxMap::__call__ "def -__call__(self, t=None) "; +Returns the last time step. "; +/* Integrate */ -// File: classcmf_1_1upslope_1_1connections_1_1_free_drainage_percolation.xml -%feature("docstring") -cmf::upslope::connections::FreeDrainagePercolation " +%feature("docstring") cmf::math::CVodeKLU::integrate_until "void +integrate_until(cmf::math::Time t_max, cmf::math::Time dt=Time(), bool +reset=false) -Calculates a free drainage (unit gradient) from a layer to somewhere -else. +Integrates the vector of state variables until t_max. +Parameters: +----------- +t_max: Time, the solver should run to -.. math:: +dt: Time step (may be omitted) - q = K(\\\\theta) A +reset: If true, solver is reseted before integration starts "; -where: :math:`q` Flux from the layer to the -other side of the connection in :math:`m^3/day` +/* Accuracy parameters */ -:math:`K(\\\\theta)` Actual conductivity in :math:`m/day` depending on the water -content of the layer :math:`\\\\theta` +%feature("docstring") cmf::math::CVodeKLU::CVodeKLU "CVodeKLU(cmf::math::StateVariableOwner &states, real epsilon=1e-9) "; -:math:`A` Cell area in :math:`m^2` +%feature("docstring") cmf::math::CVodeKLU::_get_jacobian "virtual +cmf::math::num_array _get_jacobian() const "; -C++ includes: Percolation.h "; +%feature("docstring") cmf::math::CVodeKLU::add_single_state "virtual +void add_single_state(cmf::math::StateVariable::ptr state) -%feature("docstring") -cmf::upslope::connections::FreeDrainagePercolation::FreeDrainagePercolation -"FreeDrainagePercolation(cmf::upslope::SoilLayer::ptr left, -cmf::water::flux_node::ptr right) "; +Adds a single state variable to the integrator. "; -%feature("docstring") -cmf::upslope::connections::FreeDrainagePercolation::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +%feature("docstring") cmf::math::CVodeKLU::add_states "virtual void +add_states(cmf::math::StateVariableOwner &stateOwner) -Returns the concentration of the flux. +Add state variables from a StateVariableOwner. "; -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +%feature("docstring") cmf::math::CVodeKLU::add_values_to_states "void add_values_to_states(const num_array &operands) -%feature("docstring") -cmf::upslope::connections::FreeDrainagePercolation::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr -newTarget) "; +Adds the values in operands to the current states. "; -%feature("docstring") -cmf::upslope::connections::FreeDrainagePercolation::get_ptr "ptr -get_ptr() const "; +%feature("docstring") cmf::math::CVodeKLU::copy "CVodeBase* copy() +const -%feature("docstring") -cmf::upslope::connections::FreeDrainagePercolation::get_target "flux_node::ptr get_target(const flux_node &inquirer) +Returns a copy of the solver. "; -Returns the other end of a connection than the asking end. "; +%feature("docstring") cmf::math::CVodeKLU::copy_dxdt "void +copy_dxdt(Time time, num_array &destination, real factor=1) const -%feature("docstring") -cmf::upslope::connections::FreeDrainagePercolation::get_target "flux_node::ptr get_target(int index) const +Copies the derivatives at time step \"time\" to a numeric vector using +use_OpenMP. -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +Parameters: +----------- -%feature("docstring") -cmf::upslope::connections::FreeDrainagePercolation::get_tracer_filter -"real get_tracer_filter() +time: Time at which the derivatives should be calculated -A value ranging from 0 to 1 to filter tracers out of the water flux. +destination: Vector to be overwritten by the results -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; -%feature("docstring") -cmf::upslope::connections::FreeDrainagePercolation::get_tracer_filter -"real get_tracer_filter(solute S) +%feature("docstring") cmf::math::CVodeKLU::copy_dxdt "void +copy_dxdt(Time time, real *destination, real factor=1) const -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +Copies the derivatives at time step \"time\" to an preallocated c +array. -%feature("docstring") -cmf::upslope::connections::FreeDrainagePercolation::kill_me "bool -kill_me() +Parameters: +----------- -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +time: Time at which the derivatives should be calculated -%feature("docstring") -cmf::upslope::connections::FreeDrainagePercolation::left_node "flux_node::ptr left_node() const +destination: Allocated c array -Returns the left node of this connection. "; +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; -%feature("docstring") -cmf::upslope::connections::FreeDrainagePercolation::q "real q(const -flux_node &inquirer, cmf::math::Time t) +%feature("docstring") cmf::math::CVodeKLU::copy_states "void +copy_states(num_array &destination) const -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +Copies the states to a numeric vector using use_OpenMP. "; -%feature("docstring") -cmf::upslope::connections::FreeDrainagePercolation::refresh "void -refresh(cmf::math::Time t) +%feature("docstring") cmf::math::CVodeKLU::copy_states "void +copy_states(real *destination) const "; -Performes a new calculation of the flux. "; +%feature("docstring") cmf::math::CVodeKLU::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; -%feature("docstring") -cmf::upslope::connections::FreeDrainagePercolation::right_node "flux_node::ptr right_node() const +%feature("docstring") cmf::math::CVodeKLU::get_error "cmf::math::num_array get_error() const -returns the right node of this connection "; +Error vector of the integrator. "; -%feature("docstring") -cmf::upslope::connections::FreeDrainagePercolation::set_tracer_filter -"void set_tracer_filter(real value) +%feature("docstring") cmf::math::CVodeKLU::get_info "CVodeInfo +get_info() const -A value ranging from 0 to 1 to filter tracers out of the water flux. +Returns the current solver statistics. "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf::math::CVodeKLU::get_state "real +get_state(ptrdiff_t position) const -%feature("docstring") -cmf::upslope::connections::FreeDrainagePercolation::set_tracer_filter -"void set_tracer_filter(solute S, real value) "; +Returns the statevariable at position Simplifies the assessment of +state variables. "; -%feature("docstring") -cmf::upslope::connections::FreeDrainagePercolation::short_string "virtual std::string short_string() const "; +%feature("docstring") cmf::math::CVodeKLU::get_states "cmf::math::num_array get_states() const "; -%feature("docstring") -cmf::upslope::connections::FreeDrainagePercolation::to_string "virtual std::string to_string() const "; +%feature("docstring") cmf::math::CVodeKLU::get_states "StateVariableList get_states() +gets the state variables of the integrator "; -// File: classcmf_1_1water_1_1_freundlich_adsorbtion.xml -%feature("docstring") cmf::water::FreundlichAdsorbtion " +%feature("docstring") cmf::math::CVodeKLU::initialize "int +initialize() -This class calculates the adsorption equilibrium between sorbat and -sorbent using the Freundlich isotherme. +Initialize the internal memory. -Freundlich isotherme: +Automatically called, when one starts to integrate "; +%feature("docstring") cmf::math::CVodeKLU::integrate "virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt) +Integrates the vector of state variables. -.. math:: +Parameters: +----------- - \\\\frac{x_{ad}}{m} = K c^n +t_max: To stop the model (if running in a model framework) at time +steps of value exchange e.g. full hours, the next value exchange time +can be given -where :math:`x_{ad} = x_{tot} - x_{free}` is the adsorbed tracer mass :math:`x_{tot}` is the total tracer -mass +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; -:math:`x_{free}` is the dissolved tracer mass +%feature("docstring") cmf::math::CVodeKLU::reset "virtual void +reset() -:math:`m` is the mass of the sorbent in the same unit as the tracer mass +Resets the history of the multispte solver and overwrites the internal +state cache. "; -:math:`K` is the Freundlich sorption coefficient +%feature("docstring") cmf::math::CVodeKLU::set_error_msg "void +set_error_msg(std::string error) -:math:`c = \\\\frac{x_{free}}{V}` is the concentration of the tracer in -tracer mass per m3 +Sets an error message. "; -:math:`n` is the Freundlich exponent +%feature("docstring") cmf::math::CVodeKLU::set_state "void +set_state(ptrdiff_t position, real newState) -CMF stores in a solute storage the total mass of a tracer and needs to -calculate the free tracer mass. The eq. above can not be rearanged to -get :math:`x_{free}` from :math:`x_{tot}`. Instead, the value is iterated -usingregula falsi. If n is near to 1, using LinearAdsorption will -speed up your calculations.Todo Check if an analytical solution is -available The simplest physically based adsorption model by Langmuir ( -LangmuirAdsorption) has also a analytical solution and is hence -calculated faster then Freundlich. +Simplifies the assessment of state variables. "; -C++ includes: adsorption.h "; +%feature("docstring") cmf::math::CVodeKLU::set_states "void +set_states(const num_array &newStates) -%feature("docstring") -cmf::water::FreundlichAdsorbtion::FreundlichAdsorbtion "FreundlichAdsorbtion(real K, real n, real m, real epsilon=1e-12, int -maxiter=100) +Copies the new states to the actual states. "; -Parameters: ------------ +%feature("docstring") cmf::math::CVodeKLU::set_states "void +set_states(real *newStates) "; -K: n: Freundlich coefficents +%feature("docstring") cmf::math::CVodeKLU::size "size_t size() const -m: Mass of sorbent in units of tracer +returns the number of state variables "; -epsilon: Tolerance of regula falsi iteration for the calculation of -dissolved tracer from total trace, default = 1e-12 +%feature("docstring") cmf::math::CVodeKLU::to_string "std::string +to_string() const "; -maxiter: Maximum number of iterations, default = 100 "; -%feature("docstring") -cmf::water::FreundlichAdsorbtion::FreundlichAdsorbtion "FreundlichAdsorbtion(const FreundlichAdsorbtion &other) "; +// File: classcmf__core_1_1_c_vode_krylov.xml +%feature("docstring") cmf_core::CVodeKrylov " -%feature("docstring") -cmf::water::FreundlichAdsorbtion::~FreundlichAdsorbtion "virtual -~FreundlichAdsorbtion() "; +implicit BDF CVode solver with a Krylov preconditioner C++ includes: +cvode3.h "; -%feature("docstring") cmf::water::FreundlichAdsorbtion::copy "FreundlichAdsorbtion* copy(real m=-1) const +%feature("docstring") cmf_core::CVodeKrylov::__init__ "def +__init__(self, args, kwargs) -returns a copy of the Adsorption object. +__init__(cmf::math::CVodeKrylov self, StateVariableOwner states, real +epsilon=1e-9, int w=5, char p) -> CVodeKrylov +CVodeKrylov(cmf::math::StateVariableOwner &states, real epsilon=1e-9, +int w=5, char p='L') "; -If the adsorption is depending on the sorbent mass, you can give a -positive value for the sorbent mass m. If the value is not given or -negative, m is used from the original object. "; +%feature("docstring") cmf_core::CVodeKrylov::__call__ "def +__call__(self, t, dt=None, reset=False) -%feature("docstring") cmf::water::FreundlichAdsorbtion::freesolute "real freesolute(real xt, real V) const +Advances the integration until `t` A shortcut to .integrate_until +Parameters ---------- t : cmf.Time The time step to advance to. If +t < current time, the solver will advance to self.t + t dt : +cmf.Time, optional The timestep for the integration. If not given +try to integrate in one step reset : bool, optional If True, the +solver will perform a reset before starting Returns ------- cmf.Time +The new time stamp "; -Returns the mass of dissolved tracer as a function of the total tracer -mass in the solute storage and the water volume. +%feature("docstring") cmf_core::CVodeKrylov::__getitem__ "def +__getitem__(self, args, kwargs) -Parameters: ------------ +__getitem__(Integrator self, long position) -> +cmf::math::StateVariable::ptr "; -xt: :math:`x_t` the total tracer mass in the storage +%feature("docstring") cmf_core::CVodeKrylov::__len__ "def +__len__(self, args, kwargs) -V: :math:`V m^3` the water volume in the storage +__len__(Integrator self) -> size_t "; -:math:`x_f` the dissolved mass of the tracer "; +%feature("docstring") cmf_core::CVodeKrylov::__repr__ "def +__repr__(self) "; -%feature("docstring") cmf::water::FreundlichAdsorbtion::totalsolute "real totalsolute(real xf, real V) const +%feature("docstring") cmf_core::CVodeKrylov::add_single_state "def +add_single_state(self, args, kwargs) -Returns the total mass of the tracer from the dissolved concetration -in tracer unit/m3. +add_single_state(Integrator self, cmf::math::StateVariable::ptr state) +virtual void add_single_state(cmf::math::StateVariable::ptr state) +Adds a single state variable to the integrator. "; -Parameters: ------------ +%feature("docstring") cmf_core::CVodeKrylov::add_states "def +add_states(self, args, kwargs) -xf: :math:`x_f` the dissolved tracer mass in the storage +add_states(Integrator self, StateVariableOwner stateOwner) virtual +void add_states(cmf::math::StateVariableOwner &stateOwner) Add state +variables from a StateVariableOwner. "; -V: :math:`V m^3` the water volume in the storage +%feature("docstring") cmf_core::CVodeKrylov::copy "def copy(self, +args, kwargs) -:math:`x_t` the total mass of the tracer "; +copy(CVodeBase self) -> CVodeBase virtual Integrator* copy() const =0 +Polymorphic copy constructor. "; +%feature("docstring") cmf_core::CVodeKrylov::get_dt "def +get_dt(self, args, kwargs) -// File: classcmf_1_1water_1_1generic__gradient__connection.xml -%feature("docstring") cmf::water::generic_gradient_connection " +get_dt(Integrator self) -> Time cmf::math::Time get_dt() const +Returns the last time step. "; -A generic node-to-node gradient based connection. +%feature("docstring") cmf_core::CVodeKrylov::get_dxdt "def +get_dxdt(self, args, kwargs) -This connection is similar to the Darcy-connection, but there are no -restrictions concerning the type of nodes. However, the left side -needs to be a water storage +get_dxdt(Integrator self, Time time) -> cmf::math::num_array +cmf::math::num_array get_dxdt(Time time) const "; -.. math:: +%feature("docstring") cmf_core::CVodeKrylov::get_error "def +get_error(self, args, kwargs) - q = K A - \\\\frac{\\\\Psi_{l}-\\\\Psi_{r}}{d} +get_error(CVodeBase self) -> cmf::math::num_array "; -where: :math:`q`: the resulting -flux in :math:`m^3/day` +%feature("docstring") cmf_core::CVodeKrylov::get_info "def +get_info(self, args, kwargs) -:math:`K`: the conductivity of the connection +get_info(CVodeBase self) -> CVodeInfo "; -:math:`A`: the area of the connection cross section +%feature("docstring") cmf_core::CVodeKrylov::get_jacobian "def +get_jacobian(self) "; -:math:`\\\\Psi`: The hydraulic head of the (l)eft, resp. (r)ight node of the -connection +%feature("docstring") cmf_core::CVodeKrylov::get_state "def +get_state(self, args, kwargs) -:math:`d`: The topographic length of the connection in m +get_state(Integrator self, ptrdiff_t position) -> real real +get_state(ptrdiff_t position) const Returns the statevariable at +position Simplifies the assessment of state variables. "; -C++ includes: simple_connections.h "; +%feature("docstring") cmf_core::CVodeKrylov::get_states "def +get_states(self, args) -%feature("docstring") -cmf::water::generic_gradient_connection::generic_gradient_connection "generic_gradient_connection(cmf::water::WaterStorage::ptr left, -cmf::water::WaterStorage::ptr right, real K, real d=1.0, real A=1.0) +get_states(Integrator self) -> cmf::math::num_array +get_states(Integrator self) -> StateVariableList StateVariableList +get_states() gets the state variables of the integrator "; -Creates a generic gradient based flux, if enough water is present in -the source. +%feature("docstring") cmf_core::CVodeKrylov::get_t "def get_t(self, +args, kwargs) -Parameters: ------------ +get_t(Integrator self) -> Time cmf::math::Time get_t() const Returns +the current model time. "; -left: The left node of the connection +%feature("docstring") cmf_core::CVodeKrylov::initialize "def +initialize(self, args, kwargs) -right: The right node of the connection +initialize(CVodeBase self) -> int "; -K: the conductivity of the connection in m/day +%feature("docstring") cmf_core::CVodeKrylov::integrate "def +integrate(self, args, kwargs) -d: the topographic lenght of the connection in m +integrate(Integrator self, Time t_max, Time dt) -> int virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt)=0 Integrates the +vector of state variables. Parameters: ----------- t_max: To stop +the model (if running in a model framework) at time steps of value +exchange e.g. full hours, the next value exchange time can be given +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; -A: the area of the connection cross section in m2 "; +%feature("docstring") cmf_core::CVodeKrylov::integrate_until "def +integrate_until(self, args, kwargs) -%feature("docstring") cmf::water::generic_gradient_connection::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) +integrate_until(Integrator self, Time t_max, Time dt, bool +reset=False) void integrate_until(cmf::math::Time t_max, +cmf::math::Time dt=Time(), bool reset=false) Integrates the vector of +state variables until t_max. Parameters: ----------- t_max: Time, +the solver should run to dt: Time step (may be omitted) reset: If +true, solver is reseted before integration starts "; -Returns the concentration of the flux. +%feature("docstring") cmf_core::CVodeKrylov::reset "def reset(self, +args, kwargs) -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +reset(Integrator self) virtual void reset() Resets any saved history +(for multistep methods) "; -%feature("docstring") -cmf::water::generic_gradient_connection::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +%feature("docstring") cmf_core::CVodeKrylov::run "def run(self, +start=None, end=None, step=day *1, max_errors=0, reset=False) -%feature("docstring") -cmf::water::generic_gradient_connection::get_ptr "ptr get_ptr() const -"; +Returns an iterator over the timesteps start..end **Examples:** >>> +solver=cmf.CVodeIntegrator(...) >>> for t in solver.run(solver.t, +solver.t + cmf.week, cmf.h): >>> print(t, solver[0].state) or with +list comprehension >>> states = [solver[0].state for t in +solver.run(solver.t, solver.t + cmf.week, cmf.h)] Parameters +---------- start : cmf.Time, optional Start time for the solver +iteration end : cmf.Time, optional End time of the iteration step : +cmf.Time, optional Step size for the integration max_errors: int +Number of tolerated errors. If >0, up to these number of runtime +errors will be saved with their time and the integration proceeds +after a reset of the solver. Some systems operate with values close to +their physical limits and inifinite values in the integration can +easily occur. For these kind of systems set max_errors to eg. 10. A +larger number of errors should be eliminated usually. reset: bool If +True, the solver performs a `reset` at every time step Yields ------ +cmf.Time the actual timestep "; -%feature("docstring") -cmf::water::generic_gradient_connection::get_target "flux_node::ptr -get_target(const flux_node &inquirer) +%feature("docstring") cmf_core::CVodeKrylov::set_error_msg "def +set_error_msg(self, args, kwargs) -Returns the other end of a connection than the asking end. "; +set_error_msg(CVodeBase self, std::string error) "; -%feature("docstring") -cmf::water::generic_gradient_connection::get_target "flux_node::ptr -get_target(int index) const +%feature("docstring") cmf_core::CVodeKrylov::set_state "def +set_state(self, args, kwargs) -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +set_state(Integrator self, ptrdiff_t position, real newState) void +set_state(ptrdiff_t position, real newState) Simplifies the +assessment of state variables. "; -%feature("docstring") -cmf::water::generic_gradient_connection::get_tracer_filter "real -get_tracer_filter() +%feature("docstring") cmf_core::CVodeKrylov::set_t "def set_t(self, +args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. +set_t(Integrator self, Time val) void set_t(cmf::math::Time val) Sets +the current model time. "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::CVodeKrylov::size "def size(self, +args, kwargs) -%feature("docstring") -cmf::water::generic_gradient_connection::get_tracer_filter "real -get_tracer_filter(solute S) +size(Integrator self) -> size_t size_t size() const returns the +number of state variables "; -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +%feature("docstring") cmf_core::CVodeKrylov::to_string "def +to_string(self, args, kwargs) -%feature("docstring") -cmf::water::generic_gradient_connection::kill_me "bool kill_me() +to_string(CVodeBase self) -> std::string "; -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; -%feature("docstring") -cmf::water::generic_gradient_connection::left_node "flux_node::ptr -left_node() const +// File: classcmf_1_1math_1_1_c_vode_krylov.xml +%feature("docstring") cmf::math::CVodeKrylov " -Returns the left node of this connection. "; +implicit BDF CVode solver with a Krylov preconditioner -%feature("docstring") cmf::water::generic_gradient_connection::q "real q(const flux_node &inquirer, cmf::math::Time t) +C++ includes: cvode.h "; -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +/* Accuracy parameters */ -%feature("docstring") -cmf::water::generic_gradient_connection::refresh "void -refresh(cmf::math::Time t) +/* model time */ -Performes a new calculation of the flux. "; +%feature("docstring") cmf::math::CVodeKrylov::get_t "cmf::math::Time +get_t() const -%feature("docstring") -cmf::water::generic_gradient_connection::right_node "flux_node::ptr -right_node() const +Returns the current model time. "; -returns the right node of this connection "; +%feature("docstring") cmf::math::CVodeKrylov::set_t "void +set_t(cmf::math::Time val) -%feature("docstring") -cmf::water::generic_gradient_connection::set_tracer_filter "void -set_tracer_filter(real value) +Sets the current model time. "; -A value ranging from 0 to 1 to filter tracers out of the water flux. +%feature("docstring") cmf::math::CVodeKrylov::get_dt "cmf::math::Time get_dt() const -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +Returns the last time step. "; -%feature("docstring") -cmf::water::generic_gradient_connection::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; +/* Integrate */ -%feature("docstring") -cmf::water::generic_gradient_connection::short_string "virtual -std::string short_string() const "; +%feature("docstring") cmf::math::CVodeKrylov::integrate_until "void +integrate_until(cmf::math::Time t_max, cmf::math::Time dt=Time(), bool +reset=false) -%feature("docstring") -cmf::water::generic_gradient_connection::to_string "virtual -std::string to_string() const "; +Integrates the vector of state variables until t_max. +Parameters: +----------- -// File: classcmf_1_1upslope_1_1connections_1_1_gradient_macro_flow.xml -%feature("docstring") cmf::upslope::connections::GradientMacroFlow " +t_max: Time, the solver should run to -Gradient based flux from macro pore to macro pore. +dt: Time step (may be omitted) -Deprecated The MacroPore model is still very experimental and not -stable. Only for tryouts! +reset: If true, solver is reseted before integration starts "; +%feature("docstring") cmf::math::CVodeKrylov::CVodeKrylov "CVodeKrylov(cmf::math::StateVariableOwner &states, real epsilon=1e-9, +int w=5, char p='L') "; +%feature("docstring") cmf::math::CVodeKrylov::_get_jacobian "virtual +cmf::math::num_array _get_jacobian() const -.. math:: +Returns a continuous 1D array representing the Jacobian columns +concatenated. - q = K(\\\\theta) \\\\frac{\\\\Delta \\\\Psi}{\\\\Delta z} +In Python, get_jacobian returns the Jacobian as a 2D array "; -C++ includes: macropore.h "; +%feature("docstring") cmf::math::CVodeKrylov::add_single_state "virtual void add_single_state(cmf::math::StateVariable::ptr state) -%feature("docstring") -cmf::upslope::connections::GradientMacroFlow::GradientMacroFlow "GradientMacroFlow(cmf::upslope::MacroPore::ptr left, -cmf::water::flux_node::ptr right) "; +Adds a single state variable to the integrator. "; -%feature("docstring") -cmf::upslope::connections::GradientMacroFlow::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +%feature("docstring") cmf::math::CVodeKrylov::add_states "virtual +void add_states(cmf::math::StateVariableOwner &stateOwner) -Returns the concentration of the flux. +Add state variables from a StateVariableOwner. "; -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +%feature("docstring") cmf::math::CVodeKrylov::add_values_to_states "void add_values_to_states(const num_array &operands) -%feature("docstring") -cmf::upslope::connections::GradientMacroFlow::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +Adds the values in operands to the current states. "; -%feature("docstring") -cmf::upslope::connections::GradientMacroFlow::get_ptr "ptr get_ptr() -const "; +%feature("docstring") cmf::math::CVodeKrylov::copy "CVodeBase* +copy() const -%feature("docstring") -cmf::upslope::connections::GradientMacroFlow::get_target "flux_node::ptr get_target(const flux_node &inquirer) +Returns a copy of the solver. "; -Returns the other end of a connection than the asking end. "; +%feature("docstring") cmf::math::CVodeKrylov::copy_dxdt "void +copy_dxdt(Time time, num_array &destination, real factor=1) const -%feature("docstring") -cmf::upslope::connections::GradientMacroFlow::get_target "flux_node::ptr get_target(int index) const +Copies the derivatives at time step \"time\" to a numeric vector using +use_OpenMP. -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +Parameters: +----------- -%feature("docstring") -cmf::upslope::connections::GradientMacroFlow::get_tracer_filter "real -get_tracer_filter() +time: Time at which the derivatives should be calculated -A value ranging from 0 to 1 to filter tracers out of the water flux. +destination: Vector to be overwritten by the results -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; -%feature("docstring") -cmf::upslope::connections::GradientMacroFlow::get_tracer_filter "real -get_tracer_filter(solute S) +%feature("docstring") cmf::math::CVodeKrylov::copy_dxdt "void +copy_dxdt(Time time, real *destination, real factor=1) const -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +Copies the derivatives at time step \"time\" to an preallocated c +array. -%feature("docstring") -cmf::upslope::connections::GradientMacroFlow::kill_me "bool kill_me() +Parameters: +----------- -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +time: Time at which the derivatives should be calculated -%feature("docstring") -cmf::upslope::connections::GradientMacroFlow::left_node "flux_node::ptr left_node() const +destination: Allocated c array -Returns the left node of this connection. "; +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; -%feature("docstring") cmf::upslope::connections::GradientMacroFlow::q -"real q(const flux_node &inquirer, cmf::math::Time t) +%feature("docstring") cmf::math::CVodeKrylov::copy_states "void +copy_states(num_array &destination) const -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +Copies the states to a numeric vector using use_OpenMP. "; -%feature("docstring") -cmf::upslope::connections::GradientMacroFlow::refresh "void -refresh(cmf::math::Time t) +%feature("docstring") cmf::math::CVodeKrylov::copy_states "void +copy_states(real *destination) const "; -Performes a new calculation of the flux. "; +%feature("docstring") cmf::math::CVodeKrylov::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; -%feature("docstring") -cmf::upslope::connections::GradientMacroFlow::right_node "flux_node::ptr right_node() const +%feature("docstring") cmf::math::CVodeKrylov::get_error "cmf::math::num_array get_error() const -returns the right node of this connection "; +Error vector of the integrator. "; -%feature("docstring") -cmf::upslope::connections::GradientMacroFlow::set_tracer_filter "void -set_tracer_filter(real value) +%feature("docstring") cmf::math::CVodeKrylov::get_info "CVodeInfo +get_info() const -A value ranging from 0 to 1 to filter tracers out of the water flux. +Returns the current solver statistics. "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf::math::CVodeKrylov::get_state "real +get_state(ptrdiff_t position) const -%feature("docstring") -cmf::upslope::connections::GradientMacroFlow::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; +Returns the statevariable at position Simplifies the assessment of +state variables. "; -%feature("docstring") -cmf::upslope::connections::GradientMacroFlow::short_string "virtual -std::string short_string() const "; +%feature("docstring") cmf::math::CVodeKrylov::get_states "cmf::math::num_array get_states() const "; -%feature("docstring") -cmf::upslope::connections::GradientMacroFlow::to_string "virtual -std::string to_string() const "; +%feature("docstring") cmf::math::CVodeKrylov::get_states "StateVariableList get_states() +gets the state variables of the integrator "; -// File: classcmf_1_1upslope_1_1connections_1_1_gradient_macro_micro_exchange.xml -%feature("docstring") -cmf::upslope::connections::GradientMacroMicroExchange " +%feature("docstring") cmf::math::CVodeKrylov::initialize "int +initialize() -A gradient based exchange term between macropores and micropores, -using a fixed (air-) potential for macropores. +Initialize the internal memory. +Automatically called, when one starts to integrate "; +%feature("docstring") cmf::math::CVodeKrylov::integrate "virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt) -.. math:: +Integrates the vector of state variables. - q = K \\\\frac{\\\\Delta\\\\Psi}{d/2} A +Parameters: +----------- -where: :math:`K` The -conductivity of the aggregate boundary +t_max: To stop the model (if running in a model framework) at time +steps of value exchange e.g. full hours, the next value exchange time +can be given -:math:`\\\\Delta\\\\Psi` The potential difference. Using the air potential -as the constant potential for the macro pores, you get: -:math:`\\\\Delta\\\\Psi = \\\\Psi_M(\\\\theta_{micro})` +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; -:math:`d` the mean aggregate size in m +%feature("docstring") cmf::math::CVodeKrylov::reset "virtual void +reset() -:math:`A` the crosssection area, given as the flow width ( -cmf::upslope::MacroPore::get_flowwidth) times layer thickness +Resets the history of the multispte solver and overwrites the internal +state cache. "; -C++ includes: macropore.h "; +%feature("docstring") cmf::math::CVodeKrylov::set_error_msg "void +set_error_msg(std::string error) -%feature("docstring") -cmf::upslope::connections::GradientMacroMicroExchange::GradientMacroMicroExchange -"GradientMacroMicroExchange(cmf::upslope::SoilLayer::ptr left, -cmf::upslope::MacroPore::ptr right) "; +Sets an error message. "; -%feature("docstring") -cmf::upslope::connections::GradientMacroMicroExchange::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +%feature("docstring") cmf::math::CVodeKrylov::set_state "void +set_state(ptrdiff_t position, real newState) -Returns the concentration of the flux. +Simplifies the assessment of state variables. "; -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +%feature("docstring") cmf::math::CVodeKrylov::set_states "void +set_states(const num_array &newStates) -%feature("docstring") -cmf::upslope::connections::GradientMacroMicroExchange::exchange_target -"void exchange_target(flux_node::ptr oldtarget, flux_node::ptr -newTarget) "; +Copies the new states to the actual states. "; -%feature("docstring") -cmf::upslope::connections::GradientMacroMicroExchange::get_ptr "ptr -get_ptr() const "; +%feature("docstring") cmf::math::CVodeKrylov::set_states "void +set_states(real *newStates) "; -%feature("docstring") -cmf::upslope::connections::GradientMacroMicroExchange::get_target "flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") cmf::math::CVodeKrylov::size "size_t size() +const -Returns the other end of a connection than the asking end. "; +returns the number of state variables "; -%feature("docstring") -cmf::upslope::connections::GradientMacroMicroExchange::get_target "flux_node::ptr get_target(int index) const +%feature("docstring") cmf::math::CVodeKrylov::to_string "std::string +to_string() const -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +Returns a string representation of the solver. "; -%feature("docstring") -cmf::upslope::connections::GradientMacroMicroExchange::get_tracer_filter -"real get_tracer_filter() -A value ranging from 0 to 1 to filter tracers out of the water flux. +// File: classcmf__core_1_1_c_vode_options.xml +%feature("docstring") cmf_core::CVodeOptions " -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +A set of options for all CVode3 solver. Negative numbers indicate +that this option stays on the default value. For the meaning of the +options see CVODE-UD, section 4.5.6 See Hindmarsh, A., Serban, R. and +Reynolds, D.: User Documentation for cvode v3.1.0, 2017, UCRL- +SM-208108 Usage example: >>>solver = CVodeDens(p, 1e-9) +>>>solver.options.max_order = 2 C++ includes: cvode3.h "; -%feature("docstring") -cmf::upslope::connections::GradientMacroMicroExchange::get_tracer_filter -"real get_tracer_filter(solute S) +%feature("docstring") cmf_core::CVodeOptions::__init__ "def +__init__(self, args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. +__init__(cmf::math::CVodeOptions self) -> CVodeOptions CVodeOptions() "; -%feature("docstring") -cmf::upslope::connections::GradientMacroMicroExchange::kill_me "bool -kill_me() -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +// File: structcmf_1_1math_1_1_c_vode_options.xml +%feature("docstring") cmf::math::CVodeOptions " -%feature("docstring") -cmf::upslope::connections::GradientMacroMicroExchange::left_node "flux_node::ptr left_node() const +A set of options for all CVode3 solver. -Returns the left node of this connection. "; +Negative numbers indicate that this option stays on the default value. +For the meaning of the options see CVODE-UD, section 4.5.6 -%feature("docstring") -cmf::upslope::connections::GradientMacroMicroExchange::q "real -q(const flux_node &inquirer, cmf::math::Time t) +See Hindmarsh, A., Serban, R. and Reynolds, D.: User Documentation for +cvode v3.1.0, 2017, UCRL-SM-208108 -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +Usage example: >>>solver = CVodeDens(p, 1e-9) +>>>solver.options.max_order = 2 -%feature("docstring") -cmf::upslope::connections::GradientMacroMicroExchange::refresh "void -refresh(cmf::math::Time t) +C++ includes: cvode.h "; -Performes a new calculation of the flux. "; +%feature("docstring") cmf::math::CVodeOptions::CVodeOptions "CVodeOptions() "; -%feature("docstring") -cmf::upslope::connections::GradientMacroMicroExchange::right_node "flux_node::ptr right_node() const -returns the right node of this connection "; +// File: classcmf__core_1_1_darcy.xml +%feature("docstring") cmf_core::Darcy " -%feature("docstring") -cmf::upslope::connections::GradientMacroMicroExchange::set_tracer_filter -"void set_tracer_filter(real value) +Calculates the lateral flow using the gravitational potential gradient +only. .. math:: q_{lat} = \\\\\\\\frac{\\\\\\\\Delta +\\\\\\\\Psi_G}{\\\\\\\\|C_1-C_2\\\\\\\\|} \\\\\\\\frac 12 +(T(C_1)+T(C_2)) w where :math:`\\\\\\\\Delta \\\\\\\\Psi_G` is the +gravitational potential difference :math:`\\\\\\\\|C_1-C_2\\\\\\\\|` +is the distance from Cell 1 to Cell 2 :math:`T(C)` is the +transmissivity of cell C, calculated by SoilType::Transmissivity +:math:`w` is the width of the connection of the cells C++ includes: +subsurfacefluxes.h "; + +%feature("docstring") cmf_core::Darcy::__init__ "def __init__(self, +args, kwargs) + +__init__(cmf::upslope::connections::Darcy self, +cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right, +real FlowWidth, real Distance=0) -> Darcy +Darcy(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr +right, real FlowWidth, real Distance=0) "; -A value ranging from 0 to 1 to filter tracers out of the water flux. +%feature("docstring") cmf_core::Darcy::__contains__ "def +__contains__(self, cmp) "; -1.0 is no filter and 0.0 means no solute is crossing this connection +%feature("docstring") cmf_core::Darcy::__eq__ "def __eq__(self, +args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::Darcy::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::Darcy::__iter__ "def __iter__(self) "; -%feature("docstring") -cmf::upslope::connections::GradientMacroMicroExchange::set_tracer_filter -"void set_tracer_filter(solute S, real value) "; +%feature("docstring") cmf_core::Darcy::__repr__ "def __repr__(self) +"; -%feature("docstring") -cmf::upslope::connections::GradientMacroMicroExchange::short_string "virtual std::string short_string() const "; +%feature("docstring") cmf_core::Darcy::conc "def conc(self, args, +kwargs) -%feature("docstring") -cmf::upslope::connections::GradientMacroMicroExchange::to_string "virtual std::string to_string() const "; +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; +%feature("docstring") cmf_core::Darcy::exchange_target "def +exchange_target(self, args, kwargs) -// File: classcmf_1_1upslope_1_1connections_1_1_green_ampt_infiltration.xml -%feature("docstring") cmf::upslope::connections::GreenAmptInfiltration -" +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -Connects the surfacewater and the most upper layer using a Green-Ampt -equation like infiltration. +%feature("docstring") cmf_core::Darcy::get_target "def +get_target(self, args) -The Green-Ampt formula is given as: +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -.. math:: +%feature("docstring") cmf_core::Darcy::get_tracer_filter "def +get_tracer_filter(self, args) - q(t) = -K_s \\\\frac{dh}{dz} - A +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -where: :math:`q(t)` is the infiltration rate in m3/day +%feature("docstring") cmf_core::Darcy::kill_me "def kill_me(self, +args, kwargs) -:math:`K_s` is the saturated conductivity in m/day +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -:math:`\\\\frac{dh}{dz}` is the hydraulic gradient in the wetting front +%feature("docstring") cmf_core::Darcy::left_node "def +left_node(self, args, kwargs) -:math:`A` is the surface area of the cell +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -The gradient in the wetting front is calculated as: +%feature("docstring") cmf_core::Darcy::q "def q(self, args, kwargs) +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; -.. math:: +%feature("docstring") cmf_core::Darcy::refresh "def refresh(self, +args, kwargs) - \\\\frac{dh}{dz} = \\\\frac{h_f - h_0}{Z_f} = - \\\\frac{|\\\\Psi_f| + Z_f}{Z_f} +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; -where: :math:`h_f` is the hydraulic -head at the bottom of the wetting front in m +%feature("docstring") cmf_core::Darcy::right_node "def +right_node(self, args, kwargs) -:math:`h_0` is the hydraulic head at the surface in m +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; -:math:`Z_f` is the length of the wetting front in m +%feature("docstring") cmf_core::Darcy::set_tracer_filter "def +set_tracer_filter(self, args) -Since :math:`Z_f` is unknown, the depth of the wetting front can be -approximated by: +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; -.. math:: +%feature("docstring") cmf_core::Darcy::short_string "def +short_string(self, args, kwargs) - Z_f = \\\\frac{F}{\\\\theta_s - - \\\\theta_i} +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -with: :math:`F` the accumulated volume per area of -infiltrated water +%feature("docstring") cmf_core::Darcy::to_string "def +to_string(self, args, kwargs) -:math:`\\\\theta_s, \\\\theta_i` the volumetric water content at saturation -resp. at start of the infiltration +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -If the surface water is modeled by a distinct water storage, the -actual infiltration is given as the product of the potential -infiltration with the coverage of the surface water -cmf::upslope::Cell::surface_water_coverage -.. math:: +// File: classcmf_1_1upslope_1_1connections_1_1_darcy.xml +%feature("docstring") cmf::upslope::connections::Darcy " + +Calculates the lateral flow using the gravitational potential gradient +only. - q_{act} = q_{max} - \\\\frac{A_{water}}{A_{cell}} -If the surface water is no storage on its own, but just a water -distribution node, the actual infiltration is the minimum of the -potential infiltration and the current inflow (rain, snow melt) to the -surface .. math:: - q_{act} = \\\\min\\\\left(q_{max}, - \\\\sum{q_{in,surfacewater}}\\\\right) + q_{lat} = \\\\frac{\\\\Delta \\\\Psi_G}{\\\\|C_1-C_2\\\\|} + \\\\frac 12 (T(C_1)+T(C_2)) w -C++ includes: infiltration.h "; +where :math:`\\\\Delta \\\\Psi_G` is +the gravitational potential difference -%feature("docstring") -cmf::upslope::connections::GreenAmptInfiltration::GreenAmptInfiltration -"GreenAmptInfiltration(cmf::upslope::SoilLayer::ptr soilwater, -cmf::water::flux_node::ptr surfacewater) "; +:math:`\\\\|C_1-C_2\\\\|` is the distance from Cell 1 to Cell 2 -%feature("docstring") -cmf::upslope::connections::GreenAmptInfiltration::conc "real +:math:`T(C)` is the transmissivity of cell C, calculated by +SoilType::Transmissivity + +:math:`w` is the width of the connection of the cells + +C++ includes: subsurfacefluxes.h "; + +%feature("docstring") cmf::upslope::connections::Darcy::Darcy "Darcy(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr +right, real FlowWidth, real Distance=0) "; + +%feature("docstring") cmf::upslope::connections::Darcy::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns the concentration of the flux. @@ -5328,26 +8412,24 @@ If not overridden, it returns the concentration of the source of the flux (direction depending) "; %feature("docstring") -cmf::upslope::connections::GreenAmptInfiltration::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr -newTarget) "; +cmf::upslope::connections::Darcy::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") -cmf::upslope::connections::GreenAmptInfiltration::get_ptr "ptr +%feature("docstring") cmf::upslope::connections::Darcy::get_ptr "ptr get_ptr() const "; -%feature("docstring") -cmf::upslope::connections::GreenAmptInfiltration::get_target "flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") cmf::upslope::connections::Darcy::get_target "flux_node::ptr get_target(const flux_node &inquirer) Returns the other end of a connection than the asking end. "; -%feature("docstring") -cmf::upslope::connections::GreenAmptInfiltration::get_target "flux_node::ptr get_target(int index) const +%feature("docstring") cmf::upslope::connections::Darcy::get_target "flux_node::ptr get_target(int index) const With index 0, the left node is returned, with index 1 the right node of the connection. "; %feature("docstring") -cmf::upslope::connections::GreenAmptInfiltration::get_tracer_filter "real get_tracer_filter() +cmf::upslope::connections::Darcy::get_tracer_filter "real +get_tracer_filter() A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -5355,43 +8437,38 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::connections::GreenAmptInfiltration::get_tracer_filter "real get_tracer_filter(solute S) +cmf::upslope::connections::Darcy::get_tracer_filter "real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter tracers out of the water flux. "; -%feature("docstring") -cmf::upslope::connections::GreenAmptInfiltration::kill_me "bool -kill_me() +%feature("docstring") cmf::upslope::connections::Darcy::kill_me "bool kill_me() Deregisters this connection from its nodes. Returns true if only one reference is left. "; -%feature("docstring") -cmf::upslope::connections::GreenAmptInfiltration::left_node "flux_node::ptr left_node() const +%feature("docstring") cmf::upslope::connections::Darcy::left_node "flux_node::ptr left_node() const Returns the left node of this connection. "; -%feature("docstring") -cmf::upslope::connections::GreenAmptInfiltration::q "real q(const -flux_node &inquirer, cmf::math::Time t) +%feature("docstring") cmf::upslope::connections::Darcy::q "real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current flux through a connection. Negative signs mean out of the inquirer, positive are inflows to the inquirer. "; -%feature("docstring") -cmf::upslope::connections::GreenAmptInfiltration::refresh "void -refresh(cmf::math::Time t) +%feature("docstring") cmf::upslope::connections::Darcy::refresh "void refresh(cmf::math::Time t) Performes a new calculation of the flux. "; -%feature("docstring") -cmf::upslope::connections::GreenAmptInfiltration::right_node "flux_node::ptr right_node() const +%feature("docstring") cmf::upslope::connections::Darcy::right_node "flux_node::ptr right_node() const returns the right node of this connection "; %feature("docstring") -cmf::upslope::connections::GreenAmptInfiltration::set_tracer_filter "void set_tracer_filter(real value) +cmf::upslope::connections::Darcy::set_tracer_filter "void +set_tracer_filter(real value) A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -5399,93 +8476,203 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::connections::GreenAmptInfiltration::set_tracer_filter "void set_tracer_filter(solute S, real value) "; +cmf::upslope::connections::Darcy::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; -%feature("docstring") -cmf::upslope::connections::GreenAmptInfiltration::short_string "virtual std::string short_string() const "; +%feature("docstring") cmf::upslope::connections::Darcy::short_string +"virtual std::string short_string() const "; -%feature("docstring") -cmf::upslope::connections::GreenAmptInfiltration::to_string "virtual -std::string to_string() const "; +%feature("docstring") cmf::upslope::connections::Darcy::to_string "virtual std::string to_string() const "; -// File: classcmf_1_1upslope_1_1_e_t_1_1_hargreave_e_t.xml -%feature("docstring") cmf::upslope::ET::HargreaveET " +// File: classcmf__core_1_1_darcy_kinematic.xml +%feature("docstring") cmf_core::DarcyKinematic " -Calculates the Evapotranspiration using Hargreave's equation. +A simple kinemtic wave model for subsurface flux. .. math:: q += \\\\\\\\frac{\\\\\\\\Delta z_{surface}}{d} K(\\\\\\\\theta)_{source} +A_{cross} C++ includes: subsurfacefluxes.h "; +%feature("docstring") cmf_core::DarcyKinematic::__init__ "def +__init__(self, args, kwargs) +__init__(cmf::upslope::connections::DarcyKinematic self, +cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right, +real FlowWidth, real Distance=0) -> DarcyKinematic +DarcyKinematic(cmf::upslope::SoilLayer::ptr left, +cmf::water::flux_node::ptr right, real FlowWidth, real Distance=0) +Creates the connection. Parameters: ----------- left: Left node of +the connection (needs to be soil water storage) right: Right node of +the connection (can be any node) FlowWidth: the width of the +connection - is multiplied by layer thickness to get the interface +area Distance: the length of the connection. If 0, the distance is +calculated from the position of the nodes "; -.. math:: +%feature("docstring") cmf_core::DarcyKinematic::__contains__ "def +__contains__(self, cmp) "; - ET_{rc} = 0.0135 K_T\\\\ s_0 \\\\sqrt{\\\\Delta T} (T + - 17.8) +%feature("docstring") cmf_core::DarcyKinematic::__eq__ "def +__eq__(self, args, kwargs) -where: :math:`ET_{rc}` the reference crop evapotranspiration -in mm/day +__eq__(flux_connection self, flux_connection other) -> bool "; -:math:`K_T = 0.00185{\\\\Delta T}^2 - 0.0433 \\\\Delta T + 0.4023` -Continentality factor as given in the reference +%feature("docstring") cmf_core::DarcyKinematic::__getitem__ "def +__getitem__(self, index) "; -:math:`\\\\Delta T = |T_{max} - T_{min}|[K]` Daily temperature range +%feature("docstring") cmf_core::DarcyKinematic::__iter__ "def +__iter__(self) "; -:math:`T [^\\\\circ C]` daily mean temperature +%feature("docstring") cmf_core::DarcyKinematic::__repr__ "def +__repr__(self) "; -:math:`s_0 = 15.392 d_r \\\\left(\\\\omega_s\\\\sin(\\\\Phi) \\\\sin{\\\\gamma} + \\\\cos{\\\\Phi}\\\\cos{\\\\gamma} * \\\\sin(\\\\omega_s)\\\\right)` the extraterrestrial solar radiation -in mm/day +%feature("docstring") cmf_core::DarcyKinematic::conc "def conc(self, +args, kwargs) -:math:`d_r = 1 + 0.0033 \\\\cos(DOY\\\\frac{2 \\\\pi}{365})` relative -distance between earth and sun +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -:math:`\\\\omega_s = \\\\arccos(-\\\\tan{\\\\Phi} \\\\tan{\\\\gamma})` -sunset hour angle (radians) +%feature("docstring") cmf_core::DarcyKinematic::exchange_target "def +exchange_target(self, args, kwargs) -:math:`\\\\gamma = 0.4039 \\\\sin(DOY\\\\frac{2 \\\\pi}{365} - 1.405)` -solar declination (radians) +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -:math:`\\\\Phi` geographic latitude (radians) +%feature("docstring") cmf_core::DarcyKinematic::get_target "def +get_target(self, args) -See: SAMANI, Zohrab.Estimating solar radiation and evapotranspiration -using minimum climatological data. Journal of Irrigation and Drainage -Engineering, 2000, 126. Jg., Nr. 4, S. 265-267. Crop specific -potential evapotranspiration is scaled by LAI: :math:`ET_{pot} = ET_{rc} \\\\frac{LAI}{2.88}`. +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -C++ includes: ET.h "; +%feature("docstring") cmf_core::DarcyKinematic::get_tracer_filter "def get_tracer_filter(self, args) -%feature("docstring") cmf::upslope::ET::HargreaveET::HargreaveET "HargreaveET(cmf::upslope::SoilLayer::ptr source, -cmf::water::flux_node::ptr ET_target, real latitude=51.0) "; +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -%feature("docstring") cmf::upslope::ET::HargreaveET::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +%feature("docstring") cmf_core::DarcyKinematic::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::DarcyKinematic::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::DarcyKinematic::q "def q(self, args, +kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::DarcyKinematic::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::DarcyKinematic::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::DarcyKinematic::set_tracer_filter "def set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::DarcyKinematic::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::DarcyKinematic::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf_1_1upslope_1_1connections_1_1_darcy_kinematic.xml +%feature("docstring") cmf::upslope::connections::DarcyKinematic " + +A simple kinemtic wave model for subsurface flux. + + + +.. math:: + + q = \\\\frac{\\\\Delta z_{surface}}{d} K(\\\\theta)_{source} + A_{cross} + +C++ includes: subsurfacefluxes.h "; + +%feature("docstring") +cmf::upslope::connections::DarcyKinematic::DarcyKinematic "DarcyKinematic(cmf::upslope::SoilLayer::ptr left, +cmf::water::flux_node::ptr right, real FlowWidth, real Distance=0) + +Creates the connection. + +Parameters: +----------- + +left: Left node of the connection (needs to be soil water storage) + +right: Right node of the connection (can be any node) + +FlowWidth: the width of the connection - is multiplied by layer +thickness to get the interface area + +Distance: the length of the connection. If 0, the distance is +calculated from the position of the nodes "; + +%feature("docstring") cmf::upslope::connections::DarcyKinematic::conc +"real conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns the concentration of the flux. If not overridden, it returns the concentration of the source of the flux (direction depending) "; -%feature("docstring") cmf::upslope::ET::HargreaveET::ETpot "real -ETpot(cmf::math::Time t) const "; - -%feature("docstring") cmf::upslope::ET::HargreaveET::exchange_target -"void exchange_target(flux_node::ptr oldtarget, flux_node::ptr -newTarget) "; - -%feature("docstring") cmf::upslope::ET::HargreaveET::get_layer "SoilLayer::ptr get_layer() const "; +%feature("docstring") +cmf::upslope::connections::DarcyKinematic::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") cmf::upslope::ET::HargreaveET::get_ptr "ptr -get_ptr() const "; +%feature("docstring") +cmf::upslope::connections::DarcyKinematic::get_ptr "ptr get_ptr() +const "; -%feature("docstring") cmf::upslope::ET::HargreaveET::get_target "flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") +cmf::upslope::connections::DarcyKinematic::get_target "flux_node::ptr +get_target(const flux_node &inquirer) Returns the other end of a connection than the asking end. "; -%feature("docstring") cmf::upslope::ET::HargreaveET::get_target "flux_node::ptr get_target(int index) const +%feature("docstring") +cmf::upslope::connections::DarcyKinematic::get_target "flux_node::ptr +get_target(int index) const With index 0, the left node is returned, with index 1 the right node of the connection. "; %feature("docstring") -cmf::upslope::ET::HargreaveET::get_tracer_filter "real +cmf::upslope::connections::DarcyKinematic::get_tracer_filter "real get_tracer_filter() A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -5494,45 +8681,43 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::ET::HargreaveET::get_tracer_filter "real +cmf::upslope::connections::DarcyKinematic::get_tracer_filter "real get_tracer_filter(solute S) A value ranging from 0 to 1 to filter tracers out of the water flux. "; -%feature("docstring") cmf::upslope::ET::HargreaveET::kill_me "bool -kill_me() +%feature("docstring") +cmf::upslope::connections::DarcyKinematic::kill_me "bool kill_me() Deregisters this connection from its nodes. Returns true if only one reference is left. "; -%feature("docstring") cmf::upslope::ET::HargreaveET::left_node "flux_node::ptr left_node() const +%feature("docstring") +cmf::upslope::connections::DarcyKinematic::left_node "flux_node::ptr +left_node() const Returns the left node of this connection. "; -%feature("docstring") cmf::upslope::ET::HargreaveET::q "real q(const -flux_node &inquirer, cmf::math::Time t) +%feature("docstring") cmf::upslope::connections::DarcyKinematic::q "real q(const flux_node &inquirer, cmf::math::Time t) Returns the current flux through a connection. Negative signs mean out of the inquirer, positive are inflows to the inquirer. "; -%feature("docstring") cmf::upslope::ET::HargreaveET::refresh "void +%feature("docstring") +cmf::upslope::connections::DarcyKinematic::refresh "void refresh(cmf::math::Time t) Performes a new calculation of the flux. "; -%feature("docstring") cmf::upslope::ET::HargreaveET::right_node "flux_node::ptr right_node() const - -returns the right node of this connection "; - %feature("docstring") -cmf::upslope::ET::HargreaveET::set_stressfunction "void -set_stressfunction(const RootUptakeStessFunction &stressfunction) +cmf::upslope::connections::DarcyKinematic::right_node "flux_node::ptr +right_node() const -Sets the stress function to limit water uptake. "; +returns the right node of this connection "; %feature("docstring") -cmf::upslope::ET::HargreaveET::set_tracer_filter "void +cmf::upslope::connections::DarcyKinematic::set_tracer_filter "void set_tracer_filter(real value) A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -5541,1343 +8726,1630 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::ET::HargreaveET::set_tracer_filter "void +cmf::upslope::connections::DarcyKinematic::set_tracer_filter "void set_tracer_filter(solute S, real value) "; -%feature("docstring") cmf::upslope::ET::HargreaveET::short_string "virtual std::string short_string() const "; +%feature("docstring") +cmf::upslope::connections::DarcyKinematic::short_string "virtual +std::string short_string() const "; -%feature("docstring") cmf::upslope::ET::HargreaveET::to_string "std::string to_string() const "; +%feature("docstring") +cmf::upslope::connections::DarcyKinematic::to_string "virtual +std::string to_string() const "; -// File: classcmf_1_1math_1_1_heun_integrator.xml -%feature("docstring") cmf::math::HeunIntegrator " +// File: classcmf__core_1_1_date.xml +%feature("docstring") cmf_core::Date " -A simple predictor - corrector solver. +An absolute time, not for calculation. Date and Time are +interchangable. C++ includes: time.h "; -Not tested and very experimentally :math:`y^{n+1} = y^n + \\\\alpha f(y^n + f(y^n)dt)dt + (1-\\\\alpha)f(y^n)dt` +%feature("docstring") cmf_core::Date::__init__ "def __init__(self, +args) -C++ includes: explicit_euler.h "; +__init__(cmf::math::Date self, int _day, int _month, int _year, int +_hour=0, int _minute=0, int _second=0, int _ms=0) -> Date +__init__(cmf::math::Date self, Time time) -> Date Date(const Time +&time) Creates a new date from time (based on the 31.12.1899, like in +Excel(TM)) "; -/* Accuracy parameters */ +%feature("docstring") cmf_core::Date::__getstate__ "def +__getstate__(self) "; -/* model time */ +%feature("docstring") cmf_core::Date::__repr__ "def __repr__(self) +"; -%feature("docstring") cmf::math::HeunIntegrator::get_t "cmf::math::Time get_t() const +%feature("docstring") cmf_core::Date::__setstate__ "def +__setstate__(self, data) "; -Returns the current model time. "; +%feature("docstring") cmf_core::Date::as_datetime "def +as_datetime(self) "; -%feature("docstring") cmf::math::HeunIntegrator::set_t "void -set_t(cmf::math::Time val) +%feature("docstring") cmf_core::Date::AsPython "def AsPython(self) +"; -Sets the current model time. "; +%feature("docstring") cmf_core::Date::DOY "def DOY(self, args, +kwargs) -%feature("docstring") cmf::math::HeunIntegrator::get_dt "cmf::math::Time get_dt() const +DOY(Date self) -> double double DOY() Returns the day of year. "; -Returns the last time step. "; +%feature("docstring") cmf_core::Date::to_string "def to_string(self, +args, kwargs) -%feature("docstring") cmf::math::HeunIntegrator::reset "virtual void -reset() +to_string(Date self) -> std::string std::string to_string() Returns +a string representing the date. "; -Resets any saved history (for multistep methods) "; +%feature("docstring") cmf_core::Date::ToTime "def ToTime(self, args, +kwargs) -/* Integrate */ +ToTime(Date self) -> Time Time ToTime() Converts a date to Time +(based on the 31.12.1899, like in Excel(TM) "; -%feature("docstring") cmf::math::HeunIntegrator::integrate_until "void integrate_until(cmf::math::Time t_max, cmf::math::Time dt=Time(), -bool reset=false) -Integrates the vector of state variables until t_max. +// File: structcmf_1_1math_1_1_date.xml +%feature("docstring") cmf::math::Date " -Parameters: ------------ +An absolute time, not for calculation. Date and Time are +interchangable. -t_max: Time, the solver should run to +C++ includes: time.h "; -dt: Time step (may be omitted) +%feature("docstring") cmf::math::Date::Date "Date(int _day, int +_month, int _year, int _hour=0, int _minute=0, int _second=0, int +_ms=0) -reset: If true, solver is reseted before integration starts "; +Creates a new date. "; -%feature("docstring") cmf::math::HeunIntegrator::HeunIntegrator "HeunIntegrator(StateVariableOwner &states, real Alpha=0.5) +%feature("docstring") cmf::math::Date::Date "Date(const Time &time) -Constructs a new PredictCorrectSimple from a pointer to a vector of -state variables. +Creates a new date from time (based on the 31.12.1899, like in +Excel(TM)) "; -The Integrator becomes the owner of states +%feature("docstring") cmf::math::Date::DOY "double DOY() -Parameters: ------------ +Returns the day of year. "; -states: Statevariable owner of the system +%feature("docstring") cmf::math::Date::to_string "std::string +to_string() -Alpha: Weight factor :math:`\\\\alpha` to weight :math:`f(y^n)` and :math:`f(y^{n+1})` -"; +Returns a string representing the date. "; -%feature("docstring") cmf::math::HeunIntegrator::HeunIntegrator "HeunIntegrator(real Alpha=0.5) +%feature("docstring") cmf::math::Date::ToTime "Time ToTime() -Constructs a new PredictCorrectSimple. +Converts a date to Time (based on the 31.12.1899, like in Excel(TM) "; -Parameters: ------------ -Alpha: Weight factor :math:`\\\\alpha` to weight :math:`f(y^n)` and :math:`f(y^{n+1})` -"; +// File: classcmf_1_1upslope_1_1connections_1_1_diffusive_macro_micro_exchange.xml +%feature("docstring") +cmf::upslope::connections::DiffusiveMacroMicroExchange " -%feature("docstring") cmf::math::HeunIntegrator::HeunIntegrator "HeunIntegrator(const Integrator ©) +A simple first order diffusive water exchange between MacroPore and +matrix ( SoilLayer) -copy constructor "; -%feature("docstring") cmf::math::HeunIntegrator::~HeunIntegrator "virtual ~HeunIntegrator() "; -%feature("docstring") cmf::math::HeunIntegrator::add_single_state "virtual void add_single_state(cmf::math::StateVariable::ptr state) +.. math:: -Adds a single state variable to the integrator. "; + q = \\\\omega (W_{ma} - W_{mi,eff}) V_{soil} -%feature("docstring") cmf::math::HeunIntegrator::add_states "void -add_states(cmf::math::StateVariableOwner &stateOwner) +where: +:math:`\\\\omega` is the exchange rate in :math:`day^{-1}` -Add state variables from a StateVariableOwner. "; +:math:`W_{ma}` is the filled fraction of the macropore system [-] -%feature("docstring") cmf::math::HeunIntegrator::add_values_to_states -"void add_values_to_states(const num_array &operands) +:math:`W_{mi,eff}` is the water filled pore space of the micropores above +the residual pF value [-], default 4.2 -Adds the values in operands to the current states. "; +:math:`V_{soil} = A_{cell} d_{layer}` is the total volume of the soil layer +[ :math:`m^3`] -%feature("docstring") cmf::math::HeunIntegrator::copy "virtual -Integrator* copy() const +The residual micropore pF is used to determine a residual water +content of the micropores. Residual in this case means, that above +this pF value, water is not draining to the macro pores, even if they +are empty. Although the default value is at wilting point, lower pF +values are much more sensible, and should be rather lower than field +capacity (pF=1.8 - 2.5). However, since this equation is rather +conceptual than physical, this value can only be estimated or +calibrated. -Polymorphic copy constructor. "; +cf. Simunek et al J. of Hydr. 2003 -%feature("docstring") cmf::math::HeunIntegrator::copy_dxdt "void -copy_dxdt(Time time, num_array &destination, real factor=1) const +C++ includes: macropore.h "; -Copies the derivatives at time step \"time\" to a numeric vector using -use_OpenMP. +%feature("docstring") +cmf::upslope::connections::DiffusiveMacroMicroExchange::DiffusiveMacroMicroExchange +"DiffusiveMacroMicroExchange(cmf::upslope::MacroPore::ptr left, +cmf::upslope::SoilLayer::ptr right, real omega, real pFrmi=4.2) "; -Parameters: ------------ +%feature("docstring") +cmf::upslope::connections::DiffusiveMacroMicroExchange::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) -time: Time at which the derivatives should be calculated +Returns the concentration of the flux. -destination: Vector to be overwritten by the results +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; -factor: A factor that is multiplied to the derivate (e.g. unit -conversion or integration length) "; +%feature("docstring") +cmf::upslope::connections::DiffusiveMacroMicroExchange::exchange_target +"void exchange_target(flux_node::ptr oldtarget, flux_node::ptr +newTarget) "; -%feature("docstring") cmf::math::HeunIntegrator::copy_dxdt "void -copy_dxdt(Time time, real *destination, real factor=1) const +%feature("docstring") +cmf::upslope::connections::DiffusiveMacroMicroExchange::get_ptr "ptr +get_ptr() const "; -Copies the derivatives at time step \"time\" to an preallocated c -array. +%feature("docstring") +cmf::upslope::connections::DiffusiveMacroMicroExchange::get_target "flux_node::ptr get_target(const flux_node &inquirer) -Parameters: ------------ +Returns the other end of a connection than the asking end. "; -time: Time at which the derivatives should be calculated +%feature("docstring") +cmf::upslope::connections::DiffusiveMacroMicroExchange::get_target "flux_node::ptr get_target(int index) const -destination: Allocated c array +With index 0, the left node is returned, with index 1 the right node +of the connection. "; -factor: A factor that is multiplied to the derivate (e.g. unit -conversion or integration length) "; +%feature("docstring") +cmf::upslope::connections::DiffusiveMacroMicroExchange::get_tracer_filter +"real get_tracer_filter() -%feature("docstring") cmf::math::HeunIntegrator::copy_states "void -copy_states(num_array &destination) const +A value ranging from 0 to 1 to filter tracers out of the water flux. -Copies the states to a numeric vector using use_OpenMP. "; +1.0 is no filter and 0.0 means no solute is crossing this connection +"; -%feature("docstring") cmf::math::HeunIntegrator::copy_states "void -copy_states(real *destination) const "; +%feature("docstring") +cmf::upslope::connections::DiffusiveMacroMicroExchange::get_tracer_filter +"real get_tracer_filter(solute S) -%feature("docstring") cmf::math::HeunIntegrator::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; -%feature("docstring") cmf::math::HeunIntegrator::get_state "real -get_state(ptrdiff_t position) const +%feature("docstring") +cmf::upslope::connections::DiffusiveMacroMicroExchange::kill_me "bool +kill_me() -Returns the statevariable at position Simplifies the assessment of -state variables. "; +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; -%feature("docstring") cmf::math::HeunIntegrator::get_states "cmf::math::num_array get_states() const "; +%feature("docstring") +cmf::upslope::connections::DiffusiveMacroMicroExchange::left_node "flux_node::ptr left_node() const -%feature("docstring") cmf::math::HeunIntegrator::get_states "StateVariableList get_states() +Returns the left node of this connection. "; -gets the state variables of the integrator "; +%feature("docstring") +cmf::upslope::connections::DiffusiveMacroMicroExchange::q "real +q(const flux_node &inquirer, cmf::math::Time t) -%feature("docstring") cmf::math::HeunIntegrator::integrate "int -integrate(cmf::math::Time MaxTime, cmf::math::Time TimeStep) +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; -Integrates the vector of state variables. +%feature("docstring") +cmf::upslope::connections::DiffusiveMacroMicroExchange::refresh "void +refresh(cmf::math::Time t) -Parameters: ------------ +Performes a new calculation of the flux. "; -MaxTime: (ignored) To stop the model (if running in a model -framework) at time steps of value exchange e.g. full hours, the next -value exchange time can be given +%feature("docstring") +cmf::upslope::connections::DiffusiveMacroMicroExchange::right_node "flux_node::ptr right_node() const -TimeStep: Takes the proposed time step "; +returns the right node of this connection "; -%feature("docstring") cmf::math::HeunIntegrator::set_state "void -set_state(ptrdiff_t position, real newState) +%feature("docstring") +cmf::upslope::connections::DiffusiveMacroMicroExchange::set_tracer_filter +"void set_tracer_filter(real value) -Simplifies the assessment of state variables. "; +A value ranging from 0 to 1 to filter tracers out of the water flux. -%feature("docstring") cmf::math::HeunIntegrator::set_states "void -set_states(const num_array &newStates) +1.0 is no filter and 0.0 means no solute is crossing this connection +"; -Copies the new states to the actual states. "; +%feature("docstring") +cmf::upslope::connections::DiffusiveMacroMicroExchange::set_tracer_filter +"void set_tracer_filter(solute S, real value) "; -%feature("docstring") cmf::math::HeunIntegrator::set_states "void -set_states(real *newStates) "; +%feature("docstring") +cmf::upslope::connections::DiffusiveMacroMicroExchange::short_string "virtual std::string short_string() const "; -%feature("docstring") cmf::math::HeunIntegrator::size "size_t size() -const +%feature("docstring") +cmf::upslope::connections::DiffusiveMacroMicroExchange::to_string "virtual std::string to_string() const "; -returns the number of state variables "; +// File: classcmf__core_1_1_diffusive_macro_micro_exchange.xml +%feature("docstring") cmf_core::DiffusiveMacroMicroExchange " -// File: classcmf_1_1draw_1_1hillplot_1_1_hill_plot.xml -%feature("docstring") cmf::draw::hillplot::HillPlot " +A simple first order diffusive water exchange between MacroPore and +matrix ( SoilLayer) .. math:: q = \\\\\\\\omega (W_{ma} - +W_{mi,eff}) V_{soil} where: :math:`\\\\\\\\omega` is the exchange +rate in :math:`day^{-1}` :math:`W_{ma}` is the filled fraction of the +macropore system [-] :math:`W_{mi,eff}` is the water filled pore +space of the micropores above the residual pF value [-], default 4.2 +:math:`V_{soil} = A_{cell} d_{layer}` is the total volume of the soil +layer [ :math:`m^3`] The residual micropore pF is used to determine a +residual water content of the micropores. Residual in this case means, +that above this pF value, water is not draining to the macro pores, +even if they are empty. Although the default value is at wilting +point, lower pF values are much more sensible, and should be rather +lower than field capacity (pF=1.8 - 2.5). However, since this equation +is rather conceptual than physical, this value can only be estimated +or calibrated. cf. Simunek et al J. of Hydr. 2003 C++ includes: +macropore.h "; + +%feature("docstring") cmf_core::DiffusiveMacroMicroExchange::__init__ +"def __init__(self, args, kwargs) + +__init__(cmf::upslope::connections::DiffusiveMacroMicroExchange self, +cmf::upslope::MacroPore::ptr left, cmf::upslope::SoilLayer::ptr right, +real omega, real pFrmi=4.2) -> DiffusiveMacroMicroExchange +DiffusiveMacroMicroExchange(cmf::upslope::MacroPore::ptr left, +cmf::upslope::SoilLayer::ptr right, real omega, real pFrmi=4.2) "; -Plots a hillslope using colored sheared rectangles for each layer and -arrows (matplotlib.quiver) to show fluxes. Properties: - -evalfunction: a function returning the value of a layer to plot. The -value should be a float between 0..1 for scaling. The default is: -lambda l: l.wetness - q_sub: The matplotlib.Quiver object for -subsurface fluxes - q_surf: The matplotlib.Quiver object for -subsurface fluxes - title: Title of the plot - scale: The scale of -q_sub and q_surf "; +%feature("docstring") +cmf_core::DiffusiveMacroMicroExchange::__contains__ "def +__contains__(self, cmp) "; -%feature("docstring") cmf::draw::hillplot::HillPlot::__init__ "def -__init__(self, cells, t, solute=None, cmap=default_color_map) +%feature("docstring") cmf_core::DiffusiveMacroMicroExchange::__eq__ "def __eq__(self, args, kwargs) -Creates a new HillPlot on the active figure, showing the state of each -layer - cells: The a sequence of cmf cells to use in this hill_plot. -You can use the whole project if you like - t: Current time -step. Needed to retrieve the fluxes - solute:The solute concentration -to show. If None, the wetness of the layer will be shown - cmap: a -matplotlib colormap (see module cm) for coloring "; +__eq__(flux_connection self, flux_connection other) -> bool "; -%feature("docstring") cmf::draw::hillplot::HillPlot::__call__ "def -__call__(self, t, text='') +%feature("docstring") +cmf_core::DiffusiveMacroMicroExchange::__getitem__ "def +__getitem__(self, index) "; -Updates the hill_plot at time t. You can provide a title for the -figure. If bool(title)==False, t is shown. "; +%feature("docstring") cmf_core::DiffusiveMacroMicroExchange::__iter__ +"def __iter__(self) "; -%feature("docstring") cmf::draw::hillplot::HillPlot::get_animator "def get_animator(self, integration) +%feature("docstring") cmf_core::DiffusiveMacroMicroExchange::__repr__ +"def __repr__(self) "; -Returns a matplotlib.animation.FuncAnimator object that uses the -integration iteratable to advance your model to animate the HillPlot -Usage example: >>>p=cmf.project() >>>solver = cmf.CVodeIntegrator(p, -1e-9) >>>hp = HillPlot(p, solver.t) >>>animator = -hp.get_animator(solver.run(datetime(2012, 1, 1), datetime(2012, 2, 1), -timedelta(hours=1))) :param integration: An iterable that advances -the model and yields the current time :return: A -matplotlib.animation.FuncAnimator "; +%feature("docstring") cmf_core::DiffusiveMacroMicroExchange::conc "def conc(self, args, kwargs) +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -// File: classcmf_1_1river_1_1_i_channel.xml -%feature("docstring") cmf::river::IChannel " +%feature("docstring") +cmf_core::DiffusiveMacroMicroExchange::exchange_target "def +exchange_target(self, args, kwargs) -Structure for the description of structural parameters of a reach -Abstract base class for different IChannel geometries. +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -C++ includes: ReachType.h "; +%feature("docstring") +cmf_core::DiffusiveMacroMicroExchange::get_target "def +get_target(self, args) -%feature("docstring") cmf::river::IChannel::~IChannel "virtual -~IChannel() "; +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -%feature("docstring") cmf::river::IChannel::A "virtual double -A(double V) const +%feature("docstring") +cmf_core::DiffusiveMacroMicroExchange::get_tracer_filter "def +get_tracer_filter(self, args) -Returns the area of the surface for a given volume. "; +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -%feature("docstring") cmf::river::IChannel::copy "virtual IChannel* -copy() const =0 "; +%feature("docstring") cmf_core::DiffusiveMacroMicroExchange::kill_me +"def kill_me(self, args, kwargs) -%feature("docstring") cmf::river::IChannel::get_channel_width "virtual double get_channel_width(double depth) const =0 +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -Calculates the flow width from a given actual depth [m] using the -actual IChannel geometry. "; +%feature("docstring") +cmf_core::DiffusiveMacroMicroExchange::left_node "def left_node(self, +args, kwargs) -%feature("docstring") cmf::river::IChannel::get_depth "virtual -double get_depth(double area) const =0 +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -Calculates the actual depth of the reach using the IChannel geometry. +%feature("docstring") cmf_core::DiffusiveMacroMicroExchange::q "def +q(self, args, kwargs) -get_depth of the reach [m] +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; -Parameters: ------------ +%feature("docstring") cmf_core::DiffusiveMacroMicroExchange::refresh +"def refresh(self, args, kwargs) -area: Wetted area of a river cross section [m2], can be obtained by -V/l, where V is the stored volume and l is the reach length "; +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; -%feature("docstring") cmf::river::IChannel::get_flux_crossection "virtual double get_flux_crossection(double depth) const =0 +%feature("docstring") +cmf_core::DiffusiveMacroMicroExchange::right_node "def +right_node(self, args, kwargs) -Calculates the wetted area from a given depth using the IChannel -geometry. +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; -In most cases use get_flux_crossection=V/l, where V is the stored -volume and l is the reach length Wetted area of a river cross section -[m2] +%feature("docstring") +cmf_core::DiffusiveMacroMicroExchange::set_tracer_filter "def +set_tracer_filter(self, args) -Parameters: ------------ +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; -depth: depth of the reach [m] "; +%feature("docstring") +cmf_core::DiffusiveMacroMicroExchange::short_string "def +short_string(self, args, kwargs) -%feature("docstring") cmf::river::IChannel::get_length "virtual -double get_length() const =0 +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -Length of the reach. "; +%feature("docstring") +cmf_core::DiffusiveMacroMicroExchange::to_string "def to_string(self, +args, kwargs) -%feature("docstring") cmf::river::IChannel::get_nManning "virtual -double get_nManning() const =0 "; +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -%feature("docstring") cmf::river::IChannel::get_wetted_perimeter "virtual double get_wetted_perimeter(double depth) const =0 -Calculates the wetted perimeter from a given actual depth [m] using -the actual IChannel geometry. "; +// File: classcmf_1_1upslope_1_1connections_1_1_diffusive_surface_runoff.xml +%feature("docstring") +cmf::upslope::connections::DiffusiveSurfaceRunoff " -%feature("docstring") cmf::river::IChannel::h "virtual double -h(double V) const +A connection to route water from a SurfaceWater storage to another +node following the gradient of the water level. -Returns the depth of a given volume. "; -%feature("docstring") cmf::river::IChannel::q "virtual double -q(double h, double slope) const "; -%feature("docstring") cmf::river::IChannel::qManning "virtual double -qManning(double A, double slope) const +.. math:: -Calculates the flow rate from a given water volume in the reach + q_{runoff} = A_{cross} d_{eff}^{2/3} + \\\\frac{\\\\sqrt{S}}{n} +where: :math:`q_{runoff}` is the surface +runoff -.. math:: +:math:`A_{cross}` is the wetted crossectional flux area, given as :math:`d_{eff} \\\\cdot w` - q_{Manning}&=& A R^{\\\\frac 2 3} - \\\\sqrt{\\\\frac {\\\\Delta_z} n} \\\\\\\\ A &=& \\\\frac V l - \\\\mbox{, (Crosssectional area of the wetted crossection, Volume per - length)} \\\\\\\\ R &=& \\\\frac A {P(d)} \\\\\\\\ P(d) &=& \\\\mbox{ - the perimeter of the wetted crosssection, a function of reach depth} - \\\\\\\\ d(V) &=& \\\\mbox{ the depth of the reach a function of the - volume} \\\\\\\\ \\\\Delta_z &=& \\\\frac{z_{max} - z_{min}}{l} - \\\\mbox{ Slope of the reach} +:math:`w` is the width of the shared boundary between the surface water +storage and the target node -. +:math:`d_{eff}` is the effective flow depth of the surface water.The +effective flow depth is defined as either the mean of the effective +depth of the left and the right node (when use_depthmax=false) or the +maximum of the efficitve depth. The effective depth for a surfacewater +is always defined as: -Flow rate [m3/s] +.. math:: -Parameters: ------------ + d_{eff} = \\\\begin{cases} + V/A-d_{puddle}\\\\ & V/A>d_{puddle} \\\\\\\\ 0.0 & V/A<=d_{puddle} + \\\\end{cases} -A: The area of the cross section [m2] +The right node might be not a surfacewater. If the +right node is an OpenWaterStorage, then the effective depth is the +depth of the OWS above the cell height of the left surfacewater, given +by: -slope: The slope of the reach [m/m] "; +.. math:: -%feature("docstring") cmf::river::IChannel::set_nManning "virtual -void set_nManning(double val)=0 "; + d_{eff,ows} = \\\\Psi_{ows} - z_{cell} -%feature("docstring") cmf::river::IChannel::typecode "virtual char -typecode() const =0 "; +In case of +another node, the right node depth equals the effective depth of the +left node. -%feature("docstring") cmf::river::IChannel::V "virtual double -V(double h) const "; +:math:`V` the volume of stored water in the surface in :math:`m^3` +:math:`A` the area of the cell in :math:`m^2` -// File: classcmf_1_1atmosphere_1_1_i_d_w___meteorology.xml -%feature("docstring") cmf::atmosphere::IDW_Meteorology " +:math:`d_{puddle}=V_{puddle}/A` the average depth of water in the surface +water needed to start run off -Regionalizes meteorological measurements using a simple inverse -distance weighted (IDW) method. +:math:`S = \\\\|\\\\frac{\\\\Delta h\\\\|}{d}` the slope between +surfacewater center potential and the target node potential -See: IDW +:math:`n` the manning roughness -C++ includes: meteorology.h "; +The DiffusiveSurfaceRunoff can be used as a cell connecting flux as +in: This results in a connection of the surfacewater storage of each +cell with the surface water storages of its neighborssee -%feature("docstring") -cmf::atmosphere::IDW_Meteorology::IDW_Meteorology "IDW_Meteorology(const cmf::geometry::point &position, const -MeteoStationList &stations, double z_weight, double power) +C++ includes: surfacewater.h "; -Creates an reference to a list of stations and interpolates the -weather using IDW. +%feature("docstring") +cmf::upslope::connections::DiffusiveSurfaceRunoff::DiffusiveSurfaceRunoff +"DiffusiveSurfaceRunoff(cmf::upslope::SurfaceWater::ptr left, +cmf::water::flux_node::ptr right, real flowwidth, real distance=-1) "; -Parameters: ------------ +%feature("docstring") +cmf::upslope::connections::DiffusiveSurfaceRunoff::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) -position: Position of reference +Returns the concentration of the flux. -stations: Meteo stations +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; -z_weight: Weight of height in IDW procedure +%feature("docstring") +cmf::upslope::connections::DiffusiveSurfaceRunoff::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr +newTarget) "; -power: Power of IDW procedure "; +%feature("docstring") +cmf::upslope::connections::DiffusiveSurfaceRunoff::get_ptr "ptr +get_ptr() const "; %feature("docstring") -cmf::atmosphere::IDW_Meteorology::IDW_Meteorology "IDW_Meteorology(const IDW_Meteorology ©) +cmf::upslope::connections::DiffusiveSurfaceRunoff::get_target "flux_node::ptr get_target(const flux_node &inquirer) -Copy c'tor. "; +Returns the other end of a connection than the asking end. "; -%feature("docstring") cmf::atmosphere::IDW_Meteorology::copy "virtual IDW_Meteorology* copy() const +%feature("docstring") +cmf::upslope::connections::DiffusiveSurfaceRunoff::get_target "flux_node::ptr get_target(int index) const -Returns a copy of the meteorology object. Pure virtual function, needs -to be implemented. "; +With index 0, the left node is returned, with index 1 the right node +of the connection. "; %feature("docstring") -cmf::atmosphere::IDW_Meteorology::get_instrument_height "virtual real -get_instrument_height() const +cmf::upslope::connections::DiffusiveSurfaceRunoff::get_tracer_filter "real get_tracer_filter() -Returns the height of the instruments above canopy. "; +A value ranging from 0 to 1 to filter tracers out of the water flux. -%feature("docstring") cmf::atmosphere::IDW_Meteorology::get_weather "virtual Weather get_weather(cmf::math::Time t) const +1.0 is no filter and 0.0 means no solute is crossing this connection +"; -Returns the Weather at time t. Pure virtual function. Must get -implemented by child functions. "; +%feature("docstring") +cmf::upslope::connections::DiffusiveSurfaceRunoff::get_tracer_filter "real get_tracer_filter(solute S) +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; -// File: classcmf_1_1atmosphere_1_1_i_d_w_rainfall.xml -%feature("docstring") cmf::atmosphere::IDWRainfall " +%feature("docstring") +cmf::upslope::connections::DiffusiveSurfaceRunoff::kill_me "bool +kill_me() -A RainSource using a spatially interpolated rainfall intensity from -all stations. +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; -Interpolation method is inverse distance weighted (IDW) +%feature("docstring") +cmf::upslope::connections::DiffusiveSurfaceRunoff::left_node "flux_node::ptr left_node() const -C++ includes: precipitation.h "; +Returns the left node of this connection. "; -%feature("docstring") cmf::atmosphere::IDWRainfall::conc "real -conc(cmf::math::Time t, const cmf::water::solute &Solute) const +%feature("docstring") +cmf::upslope::connections::DiffusiveSurfaceRunoff::q "real q(const +flux_node &inquirer, cmf::math::Time t) -Returns the concentration of a solute in the rainfall at time t. "; +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; -%feature("docstring") cmf::atmosphere::IDWRainfall::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node -&target) +%feature("docstring") +cmf::upslope::connections::DiffusiveSurfaceRunoff::refresh "void +refresh(cmf::math::Time t) -Returns the connection between this and target. "; +Performes a new calculation of the flux. "; -%feature("docstring") cmf::atmosphere::IDWRainfall::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, -cmf::math::Time t) "; +%feature("docstring") +cmf::upslope::connections::DiffusiveSurfaceRunoff::right_node "flux_node::ptr right_node() const -%feature("docstring") cmf::atmosphere::IDWRainfall::flux_to "real -flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +returns the right node of this connection "; -Returns the actual flux between this and target (positive sign means -\"from this into target\") "; +%feature("docstring") +cmf::upslope::connections::DiffusiveSurfaceRunoff::set_tracer_filter "void set_tracer_filter(real value) -%feature("docstring") cmf::atmosphere::IDWRainfall::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) +A value ranging from 0 to 1 to filter tracers out of the water flux. -Returns the sum of all flux vectors. "; +1.0 is no filter and 0.0 means no solute is crossing this connection +"; -%feature("docstring") cmf::atmosphere::IDWRainfall::get_connections "cmf::water::connection_list get_connections() const "; +%feature("docstring") +cmf::upslope::connections::DiffusiveSurfaceRunoff::set_tracer_filter "void set_tracer_filter(solute S, real value) "; -%feature("docstring") cmf::atmosphere::IDWRainfall::get_intensity "real get_intensity(cmf::math::Time t) const +%feature("docstring") +cmf::upslope::connections::DiffusiveSurfaceRunoff::short_string "virtual std::string short_string() const "; -Returns the actual rainfall intensity in mm/day. "; +%feature("docstring") +cmf::upslope::connections::DiffusiveSurfaceRunoff::to_string "virtual +std::string to_string() const "; -%feature("docstring") cmf::atmosphere::IDWRainfall::get_potential "virtual real get_potential() const -Returns the water potential of the node in m waterhead. +// File: classcmf__core_1_1_diffusive_surface_runoff.xml +%feature("docstring") cmf_core::DiffusiveSurfaceRunoff " -The base class water storage always returns the height of the location -"; +A connection to route water from a SurfaceWater storage to another +node following the gradient of the water level. .. math:: +q_{runoff} = A_{cross} d_{eff}^{2/3} \\\\\\\\frac{\\\\\\\\sqrt{S}}{n} +where: :math:`q_{runoff}` is the surface runoff :math:`A_{cross}` is +the wetted crossectional flux area, given as :math:`d_{eff} +\\\\\\\\cdot w` :math:`w` is the width of the shared boundary between +the surface water storage and the target node :math:`d_{eff}` is the +effective flow depth of the surface water.The effective flow depth is +defined as either the mean of the effective depth of the left and the +right node (when use_depthmax=false) or the maximum of the efficitve +depth. The effective depth for a surfacewater is always defined as: +.. math:: d_{eff} = \\\\\\\\begin{cases} V/A-d_{puddle}\\\\\\\\ & +V/A>d_{puddle} \\\\\\\\\\\\\\\\ 0.0 & V/A<=d_{puddle} +\\\\\\\\end{cases} The right node might be not a surfacewater. If the +right node is an OpenWaterStorage, then the effective depth is the +depth of the OWS above the cell height of the left surfacewater, given +by: .. math:: d_{eff,ows} = \\\\\\\\Psi_{ows} - z_{cell} In +case of another node, the right node depth equals the effective depth +of the left node. :math:`V` the volume of stored water in the surface +in :math:`m^3` :math:`A` the area of the cell in :math:`m^2` +:math:`d_{puddle}=V_{puddle}/A` the average depth of water in the +surface water needed to start run off :math:`S = +\\\\\\\\|\\\\\\\\frac{\\\\\\\\Delta h\\\\\\\\|}{d}` the slope between +surfacewater center potential and the target node potential :math:`n` +the manning roughness The DiffusiveSurfaceRunoff can be used as a +cell connecting flux as in: This results in a connection of the +surfacewater storage of each cell with the surface water storages of +its neighborssee C++ includes: surfacewater.h "; + +%feature("docstring") cmf_core::DiffusiveSurfaceRunoff::__init__ "def __init__(self, args, kwargs) + +__init__(cmf::upslope::connections::DiffusiveSurfaceRunoff self, +cmf::upslope::SurfaceWater::ptr left, cmf::water::flux_node::ptr +right, real flowwidth, real distance=-1) -> DiffusiveSurfaceRunoff +DiffusiveSurfaceRunoff(cmf::upslope::SurfaceWater::ptr left, +cmf::water::flux_node::ptr right, real flowwidth, real distance=-1) "; -%feature("docstring") cmf::atmosphere::IDWRainfall::get_project "cmf::project& get_project() const +%feature("docstring") cmf_core::DiffusiveSurfaceRunoff::__contains__ +"def __contains__(self, cmp) "; -Returns the project, this node is part of. "; +%feature("docstring") cmf_core::DiffusiveSurfaceRunoff::__eq__ "def +__eq__(self, args, kwargs) -%feature("docstring") cmf::atmosphere::IDWRainfall::is_empty "virtual double is_empty() const +__eq__(flux_connection self, flux_connection other) -> bool "; -Returns false. "; +%feature("docstring") cmf_core::DiffusiveSurfaceRunoff::__getitem__ "def __getitem__(self, index) "; -%feature("docstring") cmf::atmosphere::IDWRainfall::is_storage "virtual bool is_storage() const +%feature("docstring") cmf_core::DiffusiveSurfaceRunoff::__iter__ "def __iter__(self) "; -true, if this is a waterstorage "; +%feature("docstring") cmf_core::DiffusiveSurfaceRunoff::__repr__ "def __repr__(self) "; -%feature("docstring") cmf::atmosphere::IDWRainfall::RecalcFluxes "virtual bool RecalcFluxes(cmf::math::Time t) +%feature("docstring") cmf_core::DiffusiveSurfaceRunoff::conc "def +conc(self, args, kwargs) -Pure flux_nodes do not influence fluxes, therefore no recalculation of -fluxes is required by flux_node. +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -WaterStorage overrides this, since state changes require an update of -the fluxes "; +%feature("docstring") +cmf_core::DiffusiveSurfaceRunoff::exchange_target "def +exchange_target(self, args, kwargs) -%feature("docstring") cmf::atmosphere::IDWRainfall::remove_connection -"bool remove_connection(cmf::water::flux_node::ptr To) +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -Remove the connection. "; +%feature("docstring") +cmf_core::DiffusiveSurfaceRunoff::get_linear_slope "def +get_linear_slope(args, kwargs) -%feature("docstring") cmf::atmosphere::IDWRainfall::set_potential "virtual void set_potential(real new_potential) +get_linear_slope() -> real "; -Sets the potential of this flux node. "; +%feature("docstring") cmf_core::DiffusiveSurfaceRunoff::get_target "def get_target(self, args) -%feature("docstring") cmf::atmosphere::IDWRainfall::to_string "virtual std::string to_string() const "; +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -%feature("docstring") cmf::atmosphere::IDWRainfall::waterbalance "real waterbalance(cmf::math::Time t, const flux_connection *Without=0) -const +%feature("docstring") +cmf_core::DiffusiveSurfaceRunoff::get_tracer_filter "def +get_tracer_filter(self, args) -Returns the sum of all fluxes (positive and negative) at time t. +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -Single fluxes can be excluded from the calculation +%feature("docstring") cmf_core::DiffusiveSurfaceRunoff::kill_me "def +kill_me(self, args, kwargs) -Parameters: ------------ +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -t: Time of the query +%feature("docstring") cmf_core::DiffusiveSurfaceRunoff::left_node "def left_node(self, args, kwargs) -Without: A flux_connection that is excluded from the waterbalance -(e.g. to prevent closed circuits) "; +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; +%feature("docstring") cmf_core::DiffusiveSurfaceRunoff::q "def +q(self, args, kwargs) -// File: classcmf_1_1math_1_1_implicit_euler.xml -%feature("docstring") cmf::math::ImplicitEuler " +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; -An implicit (backward) Euler integrator using fixpoint iteration. +%feature("docstring") cmf_core::DiffusiveSurfaceRunoff::refresh "def +refresh(self, args, kwargs) -C++ includes: implicit_euler.h "; +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; -/* Internal data storages */ +%feature("docstring") cmf_core::DiffusiveSurfaceRunoff::right_node "def right_node(self, args, kwargs) -/* Accuracy parameters */ +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; -/* model time */ +%feature("docstring") +cmf_core::DiffusiveSurfaceRunoff::set_linear_slope "def +set_linear_slope(args, kwargs) -%feature("docstring") cmf::math::ImplicitEuler::get_t "cmf::math::Time get_t() const +set_linear_slope(real width) "; -Returns the current model time. "; +%feature("docstring") +cmf_core::DiffusiveSurfaceRunoff::set_tracer_filter "def +set_tracer_filter(self, args) -%feature("docstring") cmf::math::ImplicitEuler::set_t "void -set_t(cmf::math::Time val) +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; -Sets the current model time. "; +%feature("docstring") cmf_core::DiffusiveSurfaceRunoff::short_string +"def short_string(self, args, kwargs) -%feature("docstring") cmf::math::ImplicitEuler::get_dt "cmf::math::Time get_dt() const +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -Returns the last time step. "; +%feature("docstring") cmf_core::DiffusiveSurfaceRunoff::to_string "def to_string(self, args, kwargs) -%feature("docstring") cmf::math::ImplicitEuler::reset "virtual void -reset() +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -Resets any saved history (for multistep methods) "; -/* Integrate */ +// File: classcmf__core_1_1_dirichlet_boundary.xml +%feature("docstring") cmf_core::DirichletBoundary " -%feature("docstring") cmf::math::ImplicitEuler::integrate_until "void integrate_until(cmf::math::Time t_max, cmf::math::Time dt=Time(), -bool reset=false) +Dirichlet (constant head) boundary condition. This boundary condition +can be used either as a pure sink boundary condition or as a +conditional source / sink boundary condition. The constant head of the +boundary condition is interpreted and handled by the connections of +the boundary condition. Not head aware connections, should not be +used, since they are ignoring the constant head. C++ includes: +boundary_condition.h "; -Integrates the vector of state variables until t_max. +%feature("docstring") cmf_core::DirichletBoundary::__init__ "def +__init__(self, args, kwargs) -Parameters: ------------ +__init__(cmf::water::DirichletBoundary self, project _p, real +potential, point Location) -> DirichletBoundary +DirichletBoundary(cmf::project &_p, real potential, +cmf::geometry::point Location=cmf::geometry::point()) "; -t_max: Time, the solver should run to +%feature("docstring") cmf_core::DirichletBoundary::__call__ "def +__call__(self, args, kwargs) -dt: Time step (may be omitted) +__call__(flux_node self, Time t) -> real "; -reset: If true, solver is reseted before integration starts "; +%feature("docstring") cmf_core::DirichletBoundary::__eq__ "def +__eq__(self, args, kwargs) -%feature("docstring") cmf::math::ImplicitEuler::ImplicitEuler "ImplicitEuler(StateVariableOwner &states, real epsilon=1e-9, -cmf::math::Time tStepMin=cmf::math::timespan(10)) +__eq__(flux_node self, flux_node other) -> bool "; -Constructs a new FixPointImplicitEuler from a pointer to a vector of -state variables. +%feature("docstring") cmf_core::DirichletBoundary::__repr__ "def +__repr__(self) "; -The Integrator becomes the owner of states +%feature("docstring") cmf_core::DirichletBoundary::conc "def +conc(self, args, kwargs) -Parameters: ------------ +conc(flux_node self, Time t, solute Solute) -> real virtual real +conc(cmf::math::Time t, const cmf::water::solute &Solute) const +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; -states: Statevariables of the system +%feature("docstring") cmf_core::DirichletBoundary::connected_nodes "def connected_nodes(self) "; -epsilon: relative error tolerance per time step (default=1e-9) +%feature("docstring") cmf_core::DirichletBoundary::connection_to "def connection_to(self, args, kwargs) -tStepMin: minimum time step (default=10s) "; +connection_to(flux_node self, flux_node target) -> flux_connection +cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) Returns the connection between this and target. "; -%feature("docstring") cmf::math::ImplicitEuler::ImplicitEuler "ImplicitEuler(real epsilon=1e-9, cmf::math::Time -tStepMin=cmf::math::timespan(10)) +%feature("docstring") cmf_core::DirichletBoundary::flux3d_to "def +flux3d_to(self, args, kwargs) -Constructs a new FixPointImplicitEuler. +flux3d_to(flux_node self, flux_node target, Time t) -> point +cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; -Parameters: ------------ +%feature("docstring") cmf_core::DirichletBoundary::flux_to "def +flux_to(self, args, kwargs) -epsilon: relative error tolerance per time step (default=1e-9) +flux_to(flux_node self, flux_node target, Time t) -> real real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; -tStepMin: minimum time step (default=10s) "; +%feature("docstring") cmf_core::DirichletBoundary::fluxes "def +fluxes(self, t) "; -%feature("docstring") cmf::math::ImplicitEuler::ImplicitEuler "ImplicitEuler(const Integrator &) +%feature("docstring") cmf_core::DirichletBoundary::get_3d_flux "def +get_3d_flux(self, args, kwargs) -copy constructor "; +get_3d_flux(flux_node self, Time t) -> point cmf::geometry::point +get_3d_flux(cmf::math::Time t) Returns the sum of all flux vectors. +"; -%feature("docstring") cmf::math::ImplicitEuler::add_single_state "virtual void add_single_state(cmf::math::StateVariable::ptr state) +%feature("docstring") cmf_core::DirichletBoundary::is_empty "def +is_empty(self, args, kwargs) -Adds a single state variable to the integrator. "; +is_empty(flux_node self) -> double virtual double is_empty() const +Returns true if the node has no water. "; -%feature("docstring") cmf::math::ImplicitEuler::add_states "void -add_states(cmf::math::StateVariableOwner &stateOwner) +%feature("docstring") cmf_core::DirichletBoundary::is_storage "def +is_storage(self, args, kwargs) -Add state variables from a StateVariableOwner. "; +is_storage(flux_node self) -> bool virtual bool is_storage() const +true, if this is a waterstorage "; -%feature("docstring") cmf::math::ImplicitEuler::add_values_to_states -"void add_values_to_states(const num_array &operands) +%feature("docstring") cmf_core::DirichletBoundary::RecalcFluxes "def +RecalcFluxes(self, args, kwargs) -Adds the values in operands to the current states. "; +RecalcFluxes(DirichletBoundary self, Time t) -> bool virtual bool +RecalcFluxes(cmf::math::Time t) Pure flux_nodes do not influence +fluxes, therefore no recalculation of fluxes is required by flux_node. +WaterStorage overrides this, since state changes require an update of +the fluxes "; -%feature("docstring") cmf::math::ImplicitEuler::copy "virtual -Integrator* copy() const +%feature("docstring") cmf_core::DirichletBoundary::remove_connection +"def remove_connection(self, args, kwargs) -Polymorphic copy constructor. "; +remove_connection(flux_node self, cmf::water::flux_node::ptr To) -> +bool bool remove_connection(cmf::water::flux_node::ptr To) Remove +the connection. "; -%feature("docstring") cmf::math::ImplicitEuler::copy_dxdt "void -copy_dxdt(Time time, num_array &destination, real factor=1) const +%feature("docstring") cmf_core::DirichletBoundary::set_conc "def +set_conc(self, args, kwargs) -Copies the derivatives at time step \"time\" to a numeric vector using -use_OpenMP. +set_conc(DirichletBoundary self, solute _Solute, double value) virtual +void set_conc(const cmf::water::solute &_Solute, double value) "; -Parameters: ------------ +%feature("docstring") cmf_core::DirichletBoundary::to_string "def +to_string(self, args, kwargs) -time: Time at which the derivatives should be calculated +to_string(flux_node self) -> std::string virtual std::string +to_string() const "; -destination: Vector to be overwritten by the results +%feature("docstring") cmf_core::DirichletBoundary::waterbalance "def +waterbalance(self, args, kwargs) -factor: A factor that is multiplied to the derivate (e.g. unit -conversion or integration length) "; +waterbalance(flux_node self, Time t, flux_connection Without=None) -> +real real waterbalance(cmf::math::Time t, const flux_connection +*Without=0) const Returns the sum of all fluxes (positive and +negative) at time t. Single fluxes can be excluded from the +calculation Parameters: ----------- t: Time of the query Without: +A flux_connection that is excluded from the waterbalance (e.g. to +prevent closed circuits) "; -%feature("docstring") cmf::math::ImplicitEuler::copy_dxdt "void -copy_dxdt(Time time, real *destination, real factor=1) const -Copies the derivatives at time step \"time\" to an preallocated c -array. +// File: classcmf_1_1water_1_1_dirichlet_boundary.xml +%feature("docstring") cmf::water::DirichletBoundary " -Parameters: ------------ +Dirichlet (constant head) boundary condition. -time: Time at which the derivatives should be calculated +This boundary condition can be used either as a pure sink boundary +condition or as a conditional source / sink boundary condition. The +constant head of the boundary condition is interpreted and handled by +the connections of the boundary condition. Not head aware connections, +should not be used, since they are ignoring the constant head. -destination: Allocated c array +C++ includes: boundary_condition.h "; -factor: A factor that is multiplied to the derivate (e.g. unit -conversion or integration length) "; +%feature("docstring") +cmf::water::DirichletBoundary::DirichletBoundary "DirichletBoundary(cmf::project &_p, real potential, +cmf::geometry::point Location=cmf::geometry::point()) "; -%feature("docstring") cmf::math::ImplicitEuler::copy_states "void -copy_states(num_array &destination) const +%feature("docstring") cmf::water::DirichletBoundary::conc "virtual +real conc(cmf::math::Time t, const cmf::water::solute &_Solute) const -Copies the states to a numeric vector using use_OpenMP. "; +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; -%feature("docstring") cmf::math::ImplicitEuler::copy_states "void -copy_states(real *destination) const "; +%feature("docstring") cmf::water::DirichletBoundary::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) -%feature("docstring") cmf::math::ImplicitEuler::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; +Returns the connection between this and target. "; -%feature("docstring") cmf::math::ImplicitEuler::get_state "real -get_state(ptrdiff_t position) const +%feature("docstring") cmf::water::DirichletBoundary::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; -Returns the statevariable at position Simplifies the assessment of -state variables. "; +%feature("docstring") cmf::water::DirichletBoundary::flux_to "real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) -%feature("docstring") cmf::math::ImplicitEuler::get_states "cmf::math::num_array get_states() const "; +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; -%feature("docstring") cmf::math::ImplicitEuler::get_states "StateVariableList get_states() +%feature("docstring") cmf::water::DirichletBoundary::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) -gets the state variables of the integrator "; +Returns the sum of all flux vectors. "; -%feature("docstring") cmf::math::ImplicitEuler::integrate "int -integrate(cmf::math::Time MaxTime, cmf::math::Time TimeStep) +%feature("docstring") cmf::water::DirichletBoundary::get_connections +"cmf::water::connection_list get_connections() const "; -Integrates the vector of state variables. +%feature("docstring") cmf::water::DirichletBoundary::get_potential "real get_potential() const -Parameters: ------------ +Returns the water potential of the node in m waterhead. -MaxTime: To stop the model (if running in a model framework) at time -steps of value exchange e.g. full hours, the next value exchange time -can be given +The base class water storage always returns the height of the location +"; -TimeStep: Takes the proposed timestep, and changes it into the -effictivly used timestep according to the local stiffness of the -problem and MaxTime "; +%feature("docstring") cmf::water::DirichletBoundary::get_project "cmf::project& get_project() const -%feature("docstring") cmf::math::ImplicitEuler::set_state "void -set_state(ptrdiff_t position, real newState) +Returns the project, this node is part of. "; -Simplifies the assessment of state variables. "; +%feature("docstring") cmf::water::DirichletBoundary::is_empty "double is_empty() const -%feature("docstring") cmf::math::ImplicitEuler::set_states "void -set_states(const num_array &newStates) +Returns true if the node has no water. "; -Copies the new states to the actual states. "; +%feature("docstring") cmf::water::DirichletBoundary::is_storage "virtual bool is_storage() const -%feature("docstring") cmf::math::ImplicitEuler::set_states "void -set_states(real *newStates) "; +true, if this is a waterstorage "; -%feature("docstring") cmf::math::ImplicitEuler::size "size_t size() -const +%feature("docstring") cmf::water::DirichletBoundary::RecalcFluxes "bool RecalcFluxes(cmf::math::Time t) const "; -returns the number of state variables "; +%feature("docstring") cmf::water::DirichletBoundary::RecalcFluxes "virtual bool RecalcFluxes(cmf::math::Time t) +Pure flux_nodes do not influence fluxes, therefore no recalculation of +fluxes is required by flux_node. -// File: classcmf_1_1math_1_1integratable.xml -%feature("docstring") cmf::math::integratable " +WaterStorage overrides this, since state changes require an update of +the fluxes "; -integratable is a functionality for different classes for integrating -values over time. +%feature("docstring") +cmf::water::DirichletBoundary::remove_connection "bool +remove_connection(cmf::water::flux_node::ptr To) -Main usage of an integratable is the calculation of average fluxes -over time e.g. +Remove the connection. "; -.. math:: +%feature("docstring") cmf::water::DirichletBoundary::set_conc "virtual void set_conc(const cmf::water::solute &_Solute, double value) +"; - - \\\\int_{t_0}^{t_{end}}q\\\\left(t,V_i,V_j\\\\right)dt +%feature("docstring") cmf::water::DirichletBoundary::set_potential "void set_potential(real new_potential) -C++ includes: statevariable.h "; +Sets the potential of this flux node. "; -%feature("docstring") cmf::math::integratable::avg "virtual double -avg() const =0 +%feature("docstring") cmf::water::DirichletBoundary::to_string "virtual std::string to_string() const "; -Returns average of the integrated variable (eg. flux) from the last -reset until the last call of integrate. "; +%feature("docstring") cmf::water::DirichletBoundary::waterbalance "real waterbalance(cmf::math::Time t, const flux_connection *Without=0) +const -%feature("docstring") cmf::math::integratable::integrate "virtual -void integrate(Time t)=0 +Returns the sum of all fluxes (positive and negative) at time t. -Integrates the variable until time t. "; +Single fluxes can be excluded from the calculation -%feature("docstring") cmf::math::integratable::reset "virtual void -reset(Time t)=0 +Parameters: +----------- -Sets the start time of the integral. "; +t: Time of the query -%feature("docstring") cmf::math::integratable::sum "virtual double -sum() const =0 +Without: A flux_connection that is excluded from the waterbalance +(e.g. to prevent closed circuits) "; -Get the integral from the last reset until the last call of integrate. -"; +// File: classcmf__core_1_1_energy_budget_snow_melt.xml +%feature("docstring") cmf_core::EnergyBudgetSnowMelt " -// File: classcmf_1_1math_1_1integratable__list.xml -%feature("docstring") cmf::math::integratable_list " +Calculates snow melt using the surface energy budget method. C++ +includes: surfacefluxes.h "; -A list of cmf::math::integratable objects. +%feature("docstring") cmf_core::EnergyBudgetSnowMelt::__init__ "def +__init__(self, args, kwargs) -Todo TODO: Complete collection interface (getitem with slicing etc.) +__init__(cmf::upslope::connections::EnergyBudgetSnowMelt self, +cmf::water::WaterStorage::ptr snow, cmf::water::flux_node::ptr +surface_water, Cell cell) -> EnergyBudgetSnowMelt +EnergyBudgetSnowMelt(cmf::water::WaterStorage::ptr snow, +cmf::water::flux_node::ptr surface_water, cmf::upslope::Cell &cell) "; -C++ includes: statevariable.h "; +%feature("docstring") cmf_core::EnergyBudgetSnowMelt::__contains__ "def __contains__(self, cmp) "; -%feature("docstring") cmf::math::integratable_list::integratable_list -"integratable_list() "; +%feature("docstring") cmf_core::EnergyBudgetSnowMelt::__eq__ "def +__eq__(self, args, kwargs) -%feature("docstring") cmf::math::integratable_list::integratable_list -"integratable_list(const integratable_list &for_copy) "; +__eq__(flux_connection self, flux_connection other) -> bool "; -%feature("docstring") cmf::math::integratable_list::append "void -append(cmf::math::integratable::ptr add) +%feature("docstring") cmf_core::EnergyBudgetSnowMelt::__getitem__ "def __getitem__(self, index) "; -Adds an integratable to the list. "; +%feature("docstring") cmf_core::EnergyBudgetSnowMelt::__iter__ "def +__iter__(self) "; -%feature("docstring") cmf::math::integratable_list::avg "cmf::math::num_array avg() const "; +%feature("docstring") cmf_core::EnergyBudgetSnowMelt::__repr__ "def +__repr__(self) "; -%feature("docstring") cmf::math::integratable_list::integrate "void -integrate(Time t) "; +%feature("docstring") cmf_core::EnergyBudgetSnowMelt::conc "def +conc(self, args, kwargs) -%feature("docstring") cmf::math::integratable_list::remove "void -remove(cmf::math::integratable::ptr rm) +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -Removes an integratable from the list. "; +%feature("docstring") cmf_core::EnergyBudgetSnowMelt::exchange_target +"def exchange_target(self, args, kwargs) -%feature("docstring") cmf::math::integratable_list::reset "void -reset(Time t) "; +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") cmf::math::integratable_list::size "size_t -size() const +%feature("docstring") cmf_core::EnergyBudgetSnowMelt::get_target "def get_target(self, args) -Number of integratables in the list. "; +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -%feature("docstring") cmf::math::integratable_list::sum "cmf::math::num_array sum() const "; +%feature("docstring") +cmf_core::EnergyBudgetSnowMelt::get_tracer_filter "def +get_tracer_filter(self, args) +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -// File: classcmf_1_1math_1_1_integrator.xml -%feature("docstring") cmf::math::Integrator " +%feature("docstring") cmf_core::EnergyBudgetSnowMelt::kill_me "def +kill_me(self, args, kwargs) -Base class for any kind of integrator. +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -Pure virtual functions: Integrate +%feature("docstring") cmf_core::EnergyBudgetSnowMelt::left_node "def +left_node(self, args, kwargs) -copy Please provide a custom copy constructor +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -C++ includes: integrator.h "; +%feature("docstring") cmf_core::EnergyBudgetSnowMelt::q "def q(self, +args, kwargs) -/* Accuracy parameters */ +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; -/* model time */ +%feature("docstring") cmf_core::EnergyBudgetSnowMelt::refresh "def +refresh(self, args, kwargs) -%feature("docstring") cmf::math::Integrator::get_t "cmf::math::Time -get_t() const +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; -Returns the current model time. "; +%feature("docstring") cmf_core::EnergyBudgetSnowMelt::right_node "def right_node(self, args, kwargs) -%feature("docstring") cmf::math::Integrator::set_t "void -set_t(cmf::math::Time val) +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; -Sets the current model time. "; +%feature("docstring") +cmf_core::EnergyBudgetSnowMelt::set_tracer_filter "def +set_tracer_filter(self, args) -%feature("docstring") cmf::math::Integrator::get_dt "cmf::math::Time -get_dt() const +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; -Returns the last time step. "; +%feature("docstring") cmf_core::EnergyBudgetSnowMelt::short_string "def short_string(self, args, kwargs) -%feature("docstring") cmf::math::Integrator::reset "virtual void -reset() +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -Resets any saved history (for multistep methods) "; +%feature("docstring") cmf_core::EnergyBudgetSnowMelt::to_string "def +to_string(self, args, kwargs) -/* Constructors and Destructors */ +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -%feature("docstring") cmf::math::Integrator::Integrator "Integrator(real epsilon=1e-9) +%feature("docstring") cmf_core::EnergyBudgetSnowMelt::use_for_cell "def use_for_cell(args, kwargs) -Constructs a new Integrator with a new own state vector. +use_for_cell(Cell cell) "; -Parameters: ------------ -epsilon: relative error tolerance per time step (default=1e-9) "; +// File: classcmf_1_1upslope_1_1connections_1_1_energy_budget_snow_melt.xml +%feature("docstring") cmf::upslope::connections::EnergyBudgetSnowMelt +" -%feature("docstring") cmf::math::Integrator::Integrator "Integrator(cmf::math::StateVariableOwner &states, real epsilon=1e-9) -"; +Calculates snow melt using the surface energy budget method. -%feature("docstring") cmf::math::Integrator::Integrator "Integrator(const cmf::math::Integrator &other) "; +C++ includes: surfacefluxes.h "; -%feature("docstring") cmf::math::Integrator::copy "virtual -Integrator* copy() const =0 +%feature("docstring") +cmf::upslope::connections::EnergyBudgetSnowMelt::EnergyBudgetSnowMelt +"EnergyBudgetSnowMelt(cmf::water::WaterStorage::ptr snow, +cmf::water::flux_node::ptr surface_water, cmf::upslope::Cell &cell) "; -Polymorphic copy constructor. "; +%feature("docstring") +cmf::upslope::connections::EnergyBudgetSnowMelt::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) -/* Integrate */ +Returns the concentration of the flux. -%feature("docstring") cmf::math::Integrator::integrate "virtual int -integrate(cmf::math::Time t_max, cmf::math::Time dt)=0 +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; -Integrates the vector of state variables. +%feature("docstring") +cmf::upslope::connections::EnergyBudgetSnowMelt::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr +newTarget) "; -Parameters: ------------ +%feature("docstring") +cmf::upslope::connections::EnergyBudgetSnowMelt::get_ptr "ptr +get_ptr() const "; -t_max: To stop the model (if running in a model framework) at time -steps of value exchange e.g. full hours, the next value exchange time -can be given +%feature("docstring") +cmf::upslope::connections::EnergyBudgetSnowMelt::get_target "flux_node::ptr get_target(const flux_node &inquirer) -dt: Takes the proposed time step, and changes it into the effectively -used time step according to the local stiffness of the problem and -MaxTime "; +Returns the other end of a connection than the asking end. "; -%feature("docstring") cmf::math::Integrator::integrate_until "void -integrate_until(cmf::math::Time t_max, cmf::math::Time dt=Time(), bool -reset=false) +%feature("docstring") +cmf::upslope::connections::EnergyBudgetSnowMelt::get_target "flux_node::ptr get_target(int index) const -Integrates the vector of state variables until t_max. +With index 0, the left node is returned, with index 1 the right node +of the connection. "; -Parameters: ------------ +%feature("docstring") +cmf::upslope::connections::EnergyBudgetSnowMelt::get_tracer_filter "real get_tracer_filter() -t_max: Time, the solver should run to +A value ranging from 0 to 1 to filter tracers out of the water flux. -dt: Time step (may be omitted) +1.0 is no filter and 0.0 means no solute is crossing this connection +"; -reset: If true, solver is reseted before integration starts "; +%feature("docstring") +cmf::upslope::connections::EnergyBudgetSnowMelt::get_tracer_filter "real get_tracer_filter(solute S) -%feature("docstring") cmf::math::Integrator::~Integrator "virtual -~Integrator() "; +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; -%feature("docstring") cmf::math::Integrator::add_single_state "virtual void add_single_state(cmf::math::StateVariable::ptr state) +%feature("docstring") +cmf::upslope::connections::EnergyBudgetSnowMelt::kill_me "bool +kill_me() -Adds a single state variable to the integrator. "; +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; -%feature("docstring") cmf::math::Integrator::add_states "virtual -void add_states(cmf::math::StateVariableOwner &stateOwner) +%feature("docstring") +cmf::upslope::connections::EnergyBudgetSnowMelt::left_node "flux_node::ptr left_node() const -Add state variables from a StateVariableOwner. "; +Returns the left node of this connection. "; -%feature("docstring") cmf::math::Integrator::add_values_to_states "void add_values_to_states(const num_array &operands) +%feature("docstring") +cmf::upslope::connections::EnergyBudgetSnowMelt::q "real q(const +flux_node &inquirer, cmf::math::Time t) -Adds the values in operands to the current states. "; +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; -%feature("docstring") cmf::math::Integrator::copy_dxdt "void -copy_dxdt(Time time, num_array &destination, real factor=1) const +%feature("docstring") +cmf::upslope::connections::EnergyBudgetSnowMelt::refresh "void +refresh(cmf::math::Time t) -Copies the derivatives at time step \"time\" to a numeric vector using -use_OpenMP. +Performes a new calculation of the flux. "; -Parameters: ------------ +%feature("docstring") +cmf::upslope::connections::EnergyBudgetSnowMelt::right_node "flux_node::ptr right_node() const -time: Time at which the derivatives should be calculated +returns the right node of this connection "; -destination: Vector to be overwritten by the results +%feature("docstring") +cmf::upslope::connections::EnergyBudgetSnowMelt::set_tracer_filter "void set_tracer_filter(real value) -factor: A factor that is multiplied to the derivate (e.g. unit -conversion or integration length) "; +A value ranging from 0 to 1 to filter tracers out of the water flux. -%feature("docstring") cmf::math::Integrator::copy_dxdt "void -copy_dxdt(Time time, real *destination, real factor=1) const +1.0 is no filter and 0.0 means no solute is crossing this connection +"; -Copies the derivatives at time step \"time\" to an preallocated c -array. +%feature("docstring") +cmf::upslope::connections::EnergyBudgetSnowMelt::set_tracer_filter "void set_tracer_filter(solute S, real value) "; -Parameters: ------------ +%feature("docstring") +cmf::upslope::connections::EnergyBudgetSnowMelt::short_string "virtual std::string short_string() const "; -time: Time at which the derivatives should be calculated +%feature("docstring") +cmf::upslope::connections::EnergyBudgetSnowMelt::to_string "virtual +std::string to_string() const "; -destination: Allocated c array -factor: A factor that is multiplied to the derivate (e.g. unit -conversion or integration length) "; +// File: classcmf__core_1_1_explicit_euler__fixed.xml +%feature("docstring") cmf_core::ExplicitEuler_fixed " -%feature("docstring") cmf::math::Integrator::copy_states "void -copy_states(num_array &destination) const +An explicit Euler integrator, with a fixed time step. C++ includes: +explicit_euler.h "; -Copies the states to a numeric vector using use_OpenMP. "; +%feature("docstring") cmf_core::ExplicitEuler_fixed::__init__ "def +__init__(self, args) -%feature("docstring") cmf::math::Integrator::copy_states "void -copy_states(real *destination) const "; +__init__(cmf::math::ExplicitEuler_fixed self, StateVariableOwner +states) -> ExplicitEuler_fixed __init__(cmf::math::ExplicitEuler_fixed +self) -> ExplicitEuler_fixed __init__(cmf::math::ExplicitEuler_fixed +self, Integrator copy) -> ExplicitEuler_fixed +ExplicitEuler_fixed(const Integrator ©) copy constructor "; -%feature("docstring") cmf::math::Integrator::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; +%feature("docstring") cmf_core::ExplicitEuler_fixed::__call__ "def +__call__(self, t, dt=None, reset=False) -%feature("docstring") cmf::math::Integrator::get_state "real -get_state(ptrdiff_t position) const +Advances the integration until `t` A shortcut to .integrate_until +Parameters ---------- t : cmf.Time The time step to advance to. If +t < current time, the solver will advance to self.t + t dt : +cmf.Time, optional The timestep for the integration. If not given +try to integrate in one step reset : bool, optional If True, the +solver will perform a reset before starting Returns ------- cmf.Time +The new time stamp "; -Returns the statevariable at position Simplifies the assessment of -state variables. "; +%feature("docstring") cmf_core::ExplicitEuler_fixed::__getitem__ "def __getitem__(self, args, kwargs) -%feature("docstring") cmf::math::Integrator::get_states "cmf::math::num_array get_states() const "; +__getitem__(Integrator self, long position) -> +cmf::math::StateVariable::ptr "; -%feature("docstring") cmf::math::Integrator::get_states "StateVariableList get_states() +%feature("docstring") cmf_core::ExplicitEuler_fixed::__len__ "def +__len__(self, args, kwargs) -gets the state variables of the integrator "; +__len__(Integrator self) -> size_t "; -%feature("docstring") cmf::math::Integrator::set_state "void -set_state(ptrdiff_t position, real newState) +%feature("docstring") cmf_core::ExplicitEuler_fixed::__repr__ "def +__repr__(self) "; -Simplifies the assessment of state variables. "; +%feature("docstring") cmf_core::ExplicitEuler_fixed::add_single_state +"def add_single_state(self, args, kwargs) -%feature("docstring") cmf::math::Integrator::set_states "void -set_states(const num_array &newStates) +add_single_state(Integrator self, cmf::math::StateVariable::ptr state) +virtual void add_single_state(cmf::math::StateVariable::ptr state) +Adds a single state variable to the integrator. "; -Copies the new states to the actual states. "; +%feature("docstring") cmf_core::ExplicitEuler_fixed::add_states "def +add_states(self, args, kwargs) -%feature("docstring") cmf::math::Integrator::set_states "void -set_states(real *newStates) "; +add_states(Integrator self, StateVariableOwner stateOwner) virtual +void add_states(cmf::math::StateVariableOwner &stateOwner) Add state +variables from a StateVariableOwner. "; -%feature("docstring") cmf::math::Integrator::size "size_t size() -const +%feature("docstring") cmf_core::ExplicitEuler_fixed::copy "def +copy(self, args, kwargs) -returns the number of state variables "; +copy(Integrator self) -> Integrator virtual Integrator* copy() const +=0 Polymorphic copy constructor. "; +%feature("docstring") cmf_core::ExplicitEuler_fixed::get_dt "def +get_dt(self, args, kwargs) -// File: classcmf_1_1math_1_1root__finding_1_1iteration__error.xml -%feature("docstring") cmf::math::root_finding::iteration_error ""; +get_dt(Integrator self) -> Time cmf::math::Time get_dt() const +Returns the last time step. "; -%feature("docstring") -cmf::math::root_finding::iteration_error::iteration_error "iteration_error(std::string msg) "; +%feature("docstring") cmf_core::ExplicitEuler_fixed::get_dxdt "def +get_dxdt(self, args, kwargs) +get_dxdt(Integrator self, Time time) -> cmf::math::num_array +cmf::math::num_array get_dxdt(Time time) const "; -// File: classcmf_1_1river_1_1_i_volume_height_function.xml -%feature("docstring") cmf::river::IVolumeHeightFunction " +%feature("docstring") cmf_core::ExplicitEuler_fixed::get_state "def +get_state(self, args, kwargs) -Volume height relations are functional objects, which return a height -and a crosssectional area of a volume for different geometric bodies. +get_state(Integrator self, ptrdiff_t position) -> real real +get_state(ptrdiff_t position) const Returns the statevariable at +position Simplifies the assessment of state variables. "; -This is the abstract base class, where the geometries derive from +%feature("docstring") cmf_core::ExplicitEuler_fixed::get_states "def +get_states(self, args) -C++ includes: ReachType.h "; +get_states(Integrator self) -> cmf::math::num_array +get_states(Integrator self) -> StateVariableList StateVariableList +get_states() gets the state variables of the integrator "; -%feature("docstring") -cmf::river::IVolumeHeightFunction::~IVolumeHeightFunction "virtual -~IVolumeHeightFunction() "; +%feature("docstring") cmf_core::ExplicitEuler_fixed::get_t "def +get_t(self, args, kwargs) -%feature("docstring") cmf::river::IVolumeHeightFunction::A "virtual -double A(double V) const =0 +get_t(Integrator self) -> Time cmf::math::Time get_t() const Returns +the current model time. "; -Returns the area of the surface for a given volume. "; +%feature("docstring") cmf_core::ExplicitEuler_fixed::integrate "def +integrate(self, args, kwargs) -%feature("docstring") cmf::river::IVolumeHeightFunction::copy "virtual IVolumeHeightFunction* copy() const =0 "; +integrate(Integrator self, Time t_max, Time dt) -> int virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt)=0 Integrates the +vector of state variables. Parameters: ----------- t_max: To stop +the model (if running in a model framework) at time steps of value +exchange e.g. full hours, the next value exchange time can be given +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; -%feature("docstring") cmf::river::IVolumeHeightFunction::h "virtual -double h(double V) const =0 +%feature("docstring") cmf_core::ExplicitEuler_fixed::integrate_until +"def integrate_until(self, args, kwargs) -Returns the depth of a given volume. "; +integrate_until(Integrator self, Time t_max, Time dt, bool +reset=False) void integrate_until(cmf::math::Time t_max, +cmf::math::Time dt=Time(), bool reset=false) Integrates the vector of +state variables until t_max. Parameters: ----------- t_max: Time, +the solver should run to dt: Time step (may be omitted) reset: If +true, solver is reseted before integration starts "; -%feature("docstring") cmf::river::IVolumeHeightFunction::q "virtual -double q(double h, double slope) const "; +%feature("docstring") cmf_core::ExplicitEuler_fixed::reset "def +reset(self, args, kwargs) -%feature("docstring") cmf::river::IVolumeHeightFunction::V "virtual -double V(double h) const =0 "; +reset(Integrator self) virtual void reset() Resets any saved history +(for multistep methods) "; +%feature("docstring") cmf_core::ExplicitEuler_fixed::run "def +run(self, start=None, end=None, step=day *1, max_errors=0, +reset=False) -// File: classcmf_1_1jacobian_1_1_jacobian.xml -%feature("docstring") cmf::jacobian::Jacobian " +Returns an iterator over the timesteps start..end **Examples:** >>> +solver=cmf.CVodeIntegrator(...) >>> for t in solver.run(solver.t, +solver.t + cmf.week, cmf.h): >>> print(t, solver[0].state) or with +list comprehension >>> states = [solver[0].state for t in +solver.run(solver.t, solver.t + cmf.week, cmf.h)] Parameters +---------- start : cmf.Time, optional Start time for the solver +iteration end : cmf.Time, optional End time of the iteration step : +cmf.Time, optional Step size for the integration max_errors: int +Number of tolerated errors. If >0, up to these number of runtime +errors will be saved with their time and the integration proceeds +after a reset of the solver. Some systems operate with values close to +their physical limits and inifinite values in the integration can +easily occur. For these kind of systems set max_errors to eg. 10. A +larger number of errors should be eliminated usually. reset: bool If +True, the solver performs a `reset` at every time step Yields ------ +cmf.Time the actual timestep "; -Approximates the jacobian for a cmf solver J[i,j] = -(dxdt(S_i,t)[j]-dxdt(S,t)[j])/delta S is the state vector S_i equals -S, except for S_i[i]=S[i]+delta delta is the finite difference to -approximate the Jacobian. delta should be a small number, but big -enough to avoid floating point errors. 1e-6 to 1e-9 should be -nice values Usage to show the jacobian: # Allocate memory for the -jacobian jac = Jacobian(solver,delta) # Calculate the Jacobian -J = jac() # Show the Jacobian -imshow(jac(),interpolation='nearest') "; +%feature("docstring") cmf_core::ExplicitEuler_fixed::set_state "def +set_state(self, args, kwargs) -%feature("docstring") cmf::jacobian::Jacobian::__init__ "def -__init__(self, solver, delta=1e-6) +set_state(Integrator self, ptrdiff_t position, real newState) void +set_state(ptrdiff_t position, real newState) Simplifies the +assessment of state variables. "; -solver is a cmf integrator, delta is the amount the state should be -changed "; +%feature("docstring") cmf_core::ExplicitEuler_fixed::set_t "def +set_t(self, args, kwargs) -%feature("docstring") cmf::jacobian::Jacobian::__call__ "def -__call__(self) "; +set_t(Integrator self, Time val) void set_t(cmf::math::Time val) Sets +the current model time. "; -%feature("docstring") cmf::jacobian::Jacobian::__len__ "def -__len__(self) "; +%feature("docstring") cmf_core::ExplicitEuler_fixed::size "def +size(self, args, kwargs) -%feature("docstring") cmf::jacobian::Jacobian::dxdt "def dxdt(self) +size(Integrator self) -> size_t size_t size() const returns the +number of state variables "; -Returns the current right hand side of the ODE for the current states -and the current time "; -%feature("docstring") cmf::jacobian::Jacobian::t "def t(self) "; +// File: classcmf_1_1math_1_1_explicit_euler__fixed.xml +%feature("docstring") cmf::math::ExplicitEuler_fixed " +An explicit Euler integrator, with a fixed time step. -// File: classcmf_1_1upslope_1_1connections_1_1_jarvis_macro_flow.xml -%feature("docstring") cmf::upslope::connections::JarvisMacroFlow " +C++ includes: explicit_euler.h "; -A physically based macropore to macropore connection according to -Jarvis & Leeds-Harrison 1987, JSS. +/* Accuracy parameters */ +/* model time */ +%feature("docstring") cmf::math::ExplicitEuler_fixed::get_t "cmf::math::Time get_t() const -.. math:: +Returns the current model time. "; - q_{i->j} [m/s]= \\\\rho \\\\frac G {12\\\\eta} w^2 \\\\frac{e_v- - e_r}{1-e_r} S_{c,i}^\\\\beta\\\\ (1-S_{c,j}) +%feature("docstring") cmf::math::ExplicitEuler_fixed::set_t "void +set_t(cmf::math::Time val) -where: :math:`q_{i->j}` -the flow from macro pore layer i to macropore layer j +Sets the current model time. "; -:math:`\\\\rho=10^{-3} kg/m^3` - the density of water +%feature("docstring") cmf::math::ExplicitEuler_fixed::get_dt "cmf::math::Time get_dt() const -:math:`G=9.81 m/s^2` the earth acceleration +Returns the last time step. "; -:math:`\\\\eta=1.0 kg/(m s)` the viscosity of water (at 20 degC) +%feature("docstring") cmf::math::ExplicitEuler_fixed::reset "virtual +void reset() -:math:`w [m]` the crack width, a function of water content and crack -distance +Resets any saved history (for multistep methods) "; -:math:`e_v [-]` the crack porosity +/* Integrate */ -:math:`e_r [-]` crack por +%feature("docstring") cmf::math::ExplicitEuler_fixed::integrate_until +"void integrate_until(cmf::math::Time t_max, cmf::math::Time +dt=Time(), bool reset=false) -:math:`S_c [-]` the crack saturation of layer i resp. j - -:math:`\\\\beta [-]` a conceptional exponent to shape the flow reaction - -C++ includes: macropore.h "; - -%feature("docstring") -cmf::upslope::connections::JarvisMacroFlow::JarvisMacroFlow "JarvisMacroFlow(cmf::water::WaterStorage::ptr left, -cmf::water::flux_node::ptr right, real beta=1., real -porefraction_r=0.0) - -Constructs the connection. +Integrates the vector of state variables until t_max. Parameters: ----------- -left: right: the connected macropores +t_max: Time, the solver should run to -beta: User defined parameter for the swelling reaction +dt: Time step (may be omitted) -porefraction_r: Porefraction at which flow starts. For swelling soils -that are closing completely th "; +reset: If true, solver is reseted before integration starts "; %feature("docstring") -cmf::upslope::connections::JarvisMacroFlow::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +cmf::math::ExplicitEuler_fixed::ExplicitEuler_fixed "ExplicitEuler_fixed(StateVariableOwner &states) -Returns the concentration of the flux. +Constructs a new ExplicitEuler_fixed from a pointer to a vector of +state variables. -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +The Integrator becomes the owner of states -%feature("docstring") -cmf::upslope::connections::JarvisMacroFlow::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +Parameters: +----------- -%feature("docstring") -cmf::upslope::connections::JarvisMacroFlow::get_ptr "ptr get_ptr() -const "; +states: Statevariables of the system "; %feature("docstring") -cmf::upslope::connections::JarvisMacroFlow::get_target "flux_node::ptr get_target(const flux_node &inquirer) +cmf::math::ExplicitEuler_fixed::ExplicitEuler_fixed "ExplicitEuler_fixed() -Returns the other end of a connection than the asking end. "; +Constructs a new ExplicitEuler_fixed. "; %feature("docstring") -cmf::upslope::connections::JarvisMacroFlow::get_target "flux_node::ptr get_target(int index) const +cmf::math::ExplicitEuler_fixed::ExplicitEuler_fixed "ExplicitEuler_fixed(const Integrator ©) -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +copy constructor "; %feature("docstring") -cmf::upslope::connections::JarvisMacroFlow::get_tracer_filter "real -get_tracer_filter() - -A value ranging from 0 to 1 to filter tracers out of the water flux. - -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +cmf::math::ExplicitEuler_fixed::~ExplicitEuler_fixed "virtual +~ExplicitEuler_fixed() "; %feature("docstring") -cmf::upslope::connections::JarvisMacroFlow::get_tracer_filter "real -get_tracer_filter(solute S) +cmf::math::ExplicitEuler_fixed::add_single_state "virtual void +add_single_state(cmf::math::StateVariable::ptr state) -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +Adds a single state variable to the integrator. "; -%feature("docstring") -cmf::upslope::connections::JarvisMacroFlow::kill_me "bool kill_me() +%feature("docstring") cmf::math::ExplicitEuler_fixed::add_states "void add_states(cmf::math::StateVariableOwner &stateOwner) -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +Add state variables from a StateVariableOwner. "; %feature("docstring") -cmf::upslope::connections::JarvisMacroFlow::left_node "flux_node::ptr -left_node() const +cmf::math::ExplicitEuler_fixed::add_values_to_states "void +add_values_to_states(const num_array &operands) -Returns the left node of this connection. "; +Adds the values in operands to the current states. "; -%feature("docstring") cmf::upslope::connections::JarvisMacroFlow::q "real q(const flux_node &inquirer, cmf::math::Time t) +%feature("docstring") cmf::math::ExplicitEuler_fixed::copy "virtual +Integrator* copy() const -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +Polymorphic copy constructor. "; -%feature("docstring") -cmf::upslope::connections::JarvisMacroFlow::refresh "void -refresh(cmf::math::Time t) +%feature("docstring") cmf::math::ExplicitEuler_fixed::copy_dxdt "void copy_dxdt(Time time, num_array &destination, real factor=1) const -Performes a new calculation of the flux. "; +Copies the derivatives at time step \"time\" to a numeric vector using +use_OpenMP. -%feature("docstring") -cmf::upslope::connections::JarvisMacroFlow::right_node "flux_node::ptr right_node() const +Parameters: +----------- -returns the right node of this connection "; +time: Time at which the derivatives should be calculated -%feature("docstring") -cmf::upslope::connections::JarvisMacroFlow::set_tracer_filter "void -set_tracer_filter(real value) +destination: Vector to be overwritten by the results -A value ranging from 0 to 1 to filter tracers out of the water flux. +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf::math::ExplicitEuler_fixed::copy_dxdt "void copy_dxdt(Time time, real *destination, real factor=1) const -%feature("docstring") -cmf::upslope::connections::JarvisMacroFlow::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; +Copies the derivatives at time step \"time\" to an preallocated c +array. -%feature("docstring") -cmf::upslope::connections::JarvisMacroFlow::short_string "virtual -std::string short_string() const "; +Parameters: +----------- -%feature("docstring") -cmf::upslope::connections::JarvisMacroFlow::to_string "virtual -std::string to_string() const "; +time: Time at which the derivatives should be calculated +destination: Allocated c array -// File: classcmf_1_1water_1_1kinematic__wave.xml -%feature("docstring") cmf::water::kinematic_wave " +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; -Calculates flux out of a storage as a linear function of its volume to -a power. +%feature("docstring") cmf::math::ExplicitEuler_fixed::copy_states "void copy_states(num_array &destination) const -Deprecated kinematic_wave is superseeded by LinearStorageConnection -and PowerLawConnection +Copies the states to a numeric vector using use_OpenMP. "; +%feature("docstring") cmf::math::ExplicitEuler_fixed::copy_states "void copy_states(real *destination) const "; +%feature("docstring") cmf::math::ExplicitEuler_fixed::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; -.. math:: +%feature("docstring") cmf::math::ExplicitEuler_fixed::get_state "real get_state(ptrdiff_t position) const - q = \\\\frac 1 {t_r} {\\\\left(\\\\frac{V - V_{residual}}{V_0} - \\\\right)^\\\\beta} +Returns the statevariable at position Simplifies the assessment of +state variables. "; -where: :math:`V_{residual} [m^3]` The volume of -water not flowing out (default = 0) +%feature("docstring") cmf::math::ExplicitEuler_fixed::get_states "cmf::math::num_array get_states() const "; -:math:`V_0` The reference volume to scale the exponent (default = 1m3/day) +%feature("docstring") cmf::math::ExplicitEuler_fixed::get_states "StateVariableList get_states() -:math:`\\\\beta` A parameter to shape the response curve. In case of -:math:`\\\\beta \\\\neq 1`, :math:`t_r` is not a residence time, but just a -parameter. +gets the state variables of the integrator "; -:math:`t_r [days]` The residence time of the water in this storage in days +%feature("docstring") cmf::math::ExplicitEuler_fixed::integrate "int +integrate(cmf::math::Time MaxTime, cmf::math::Time TimeStep) -WARNING: :math:`\\\\beta < 0.5` may lead to numerical troubles and have a -dubious hydrological meaning. Please avoid. +Integrates the vector of state variables. -C++ includes: simple_connections.h "; +Parameters: +----------- -%feature("docstring") cmf::water::kinematic_wave::kinematic_wave "kinematic_wave(WaterStorage::ptr source, flux_node::ptr target, real -residencetime, real exponent=1.0, real residual=0.0, real V0=1.0) +MaxTime: (ignored) To stop the model (if running in a model +framework) at time steps of value exchange e.g. full hours, the next +value exchange time can be given -Creates a kinematic wave connection. +TimeStep: Takes the proposed time step "; +%feature("docstring") cmf::math::ExplicitEuler_fixed::set_state "void set_state(ptrdiff_t position, real newState) +Simplifies the assessment of state variables. "; -.. math:: +%feature("docstring") cmf::math::ExplicitEuler_fixed::set_states "void set_states(const num_array &newStates) - q = \\\\frac 1 {t_r} {\\\\left(\\\\frac{V - V_{residual}}{V_0} - \\\\right)^\\\\beta} +Copies the new states to the actual states. "; -Parameters: ------------ +%feature("docstring") cmf::math::ExplicitEuler_fixed::set_states "void set_states(real *newStates) "; -source: Water storage from which the water flows out. Flux is a -function of source.volume +%feature("docstring") cmf::math::ExplicitEuler_fixed::size "size_t +size() const -target: Target node (boundary condition or storage). Does not -influence the strength of the flow +returns the number of state variables "; -residencetime: :math:`t_r [days]` The residence time of the water in this -storage -exponent: :math:`\\\\beta [-]` An empirical exponent to shape the flux -function (default = 1 (linear function)) +// File: classcmf__core_1_1_exponential_decline_connection.xml +%feature("docstring") cmf_core::ExponentialDeclineConnection " -residual: :math:`V_{residual} [m^3]` The volume of water not flowing out -(default = 0) +A conceptual TOPmodel inspired connection. .. math:: q = Q_0 +\\\\\\\\cdot e^{(V-V_0)/m} C++ includes: simple_connections.h "; -V0: :math:`V_0` The reference volume to scale the exponent "; +%feature("docstring") +cmf_core::ExponentialDeclineConnection::__init__ "def __init__(self, +args, kwargs) -%feature("docstring") cmf::water::kinematic_wave::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +__init__(cmf::water::ExponentialDeclineConnection self, +cmf::water::WaterStorage::ptr source, cmf::water::flux_node::ptr +target, real Q0, real V0, real m) -> ExponentialDeclineConnection +ExponentialDeclineConnection(WaterStorage::ptr source, flux_node::ptr +target, real Q0, real V0, real m) creates the exponential decline +connection "; -Returns the concentration of the flux. +%feature("docstring") +cmf_core::ExponentialDeclineConnection::__contains__ "def +__contains__(self, cmp) "; -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +%feature("docstring") cmf_core::ExponentialDeclineConnection::__eq__ +"def __eq__(self, args, kwargs) -%feature("docstring") cmf::water::kinematic_wave::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr -newTarget) "; +__eq__(flux_connection self, flux_connection other) -> bool "; -%feature("docstring") cmf::water::kinematic_wave::get_ptr "ptr -get_ptr() const "; +%feature("docstring") +cmf_core::ExponentialDeclineConnection::__getitem__ "def +__getitem__(self, index) "; -%feature("docstring") cmf::water::kinematic_wave::get_target "flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") +cmf_core::ExponentialDeclineConnection::__iter__ "def __iter__(self) +"; -Returns the other end of a connection than the asking end. "; +%feature("docstring") +cmf_core::ExponentialDeclineConnection::__repr__ "def __repr__(self) +"; -%feature("docstring") cmf::water::kinematic_wave::get_target "flux_node::ptr get_target(int index) const +%feature("docstring") cmf_core::ExponentialDeclineConnection::conc "def conc(self, args, kwargs) -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -%feature("docstring") cmf::water::kinematic_wave::get_tracer_filter "real get_tracer_filter() +%feature("docstring") +cmf_core::ExponentialDeclineConnection::exchange_target "def +exchange_target(self, args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") +cmf_core::ExponentialDeclineConnection::get_target "def +get_target(self, args) -%feature("docstring") cmf::water::kinematic_wave::get_tracer_filter "real get_tracer_filter(solute S) +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +%feature("docstring") +cmf_core::ExponentialDeclineConnection::get_tracer_filter "def +get_tracer_filter(self, args) -%feature("docstring") cmf::water::kinematic_wave::kill_me "bool -kill_me() +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +%feature("docstring") cmf_core::ExponentialDeclineConnection::kill_me +"def kill_me(self, args, kwargs) -%feature("docstring") cmf::water::kinematic_wave::left_node "flux_node::ptr left_node() const +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -Returns the left node of this connection. "; +%feature("docstring") +cmf_core::ExponentialDeclineConnection::left_node "def +left_node(self, args, kwargs) -%feature("docstring") cmf::water::kinematic_wave::q "real q(const -flux_node &inquirer, cmf::math::Time t) +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +%feature("docstring") cmf_core::ExponentialDeclineConnection::q "def +q(self, args, kwargs) -%feature("docstring") cmf::water::kinematic_wave::refresh "void -refresh(cmf::math::Time t) +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; +%feature("docstring") cmf_core::ExponentialDeclineConnection::refresh +"def refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) Performes a new calculation of the flux. "; -%feature("docstring") cmf::water::kinematic_wave::right_node "flux_node::ptr right_node() const +%feature("docstring") +cmf_core::ExponentialDeclineConnection::right_node "def +right_node(self, args, kwargs) -returns the right node of this connection "; +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; -%feature("docstring") cmf::water::kinematic_wave::set_tracer_filter "void set_tracer_filter(real value) +%feature("docstring") +cmf_core::ExponentialDeclineConnection::set_tracer_filter "def +set_tracer_filter(self, args) -A value ranging from 0 to 1 to filter tracers out of the water flux. +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") +cmf_core::ExponentialDeclineConnection::short_string "def +short_string(self, args, kwargs) -%feature("docstring") cmf::water::kinematic_wave::set_tracer_filter "void set_tracer_filter(solute S, real value) "; +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -%feature("docstring") cmf::water::kinematic_wave::short_string "virtual std::string short_string() const "; +%feature("docstring") +cmf_core::ExponentialDeclineConnection::to_string "def +to_string(self, args, kwargs) -%feature("docstring") cmf::water::kinematic_wave::to_string "virtual -std::string to_string() const "; +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -// File: classcmf_1_1upslope_1_1connections_1_1_kinematic_macro_flow.xml -%feature("docstring") cmf::upslope::connections::KinematicMacroFlow " +// File: classcmf_1_1water_1_1_exponential_decline_connection.xml +%feature("docstring") cmf::water::ExponentialDeclineConnection " -Linear storage based flux from macro pore to macro pore. - -Deprecated The MacroPore model is still very experimental and not -stable. Only for tryouts! +A conceptual TOPmodel inspired connection. .. math:: - q = A_{cell} K_{macro} - \\\\left(\\\\frac{V_{upper}}{C_{upper}}\\\\right)^\\\\beta - \\\\left(1-\\\\frac{V_{lower}}{C_{lower}}\\\\right) - -where: -:math:`A_{cell}` is the area of the owning cell in m2 - -:math:`K_{macro}` is the conductivity of the macro pore storage - -:math:`V` is the actual stored water volume in the upper resp. lower macro -pore storage - -:math:`C` is the capacity of the upper resp. lower macro pore storage + q = Q_0 \\\\cdot e^{(V-V_0)/m} -C++ includes: macropore.h "; +C++ includes: simple_connections.h "; %feature("docstring") -cmf::upslope::connections::KinematicMacroFlow::KinematicMacroFlow "KinematicMacroFlow(cmf::water::WaterStorage::ptr left, -cmf::water::flux_node::ptr right, real beta=1.) - -Creates the connection. - -Parameters: ------------ - -left: right: the nodes between the connection should be created. - -beta: a conceptional curve shape parameter for the relation between -storage and outflow +cmf::water::ExponentialDeclineConnection::ExponentialDeclineConnection +"ExponentialDeclineConnection(WaterStorage::ptr source, +flux_node::ptr target, real Q0, real V0, real m) -Either left or right needs to be a MacroPore, left needs to be a water -storage "; +creates the exponential decline connection "; -%feature("docstring") -cmf::upslope::connections::KinematicMacroFlow::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +%feature("docstring") cmf::water::ExponentialDeclineConnection::conc +"real conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns the concentration of the flux. @@ -6885,26 +10357,29 @@ If not overridden, it returns the concentration of the source of the flux (direction depending) "; %feature("docstring") -cmf::upslope::connections::KinematicMacroFlow::exchange_target "void +cmf::water::ExponentialDeclineConnection::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; %feature("docstring") -cmf::upslope::connections::KinematicMacroFlow::get_ptr "ptr get_ptr() +cmf::water::ExponentialDeclineConnection::get_ptr "ptr get_ptr() const "; %feature("docstring") -cmf::upslope::connections::KinematicMacroFlow::get_target "flux_node::ptr get_target(const flux_node &inquirer) +cmf::water::ExponentialDeclineConnection::get_target "flux_node::ptr +get_target(const flux_node &inquirer) Returns the other end of a connection than the asking end. "; %feature("docstring") -cmf::upslope::connections::KinematicMacroFlow::get_target "flux_node::ptr get_target(int index) const +cmf::water::ExponentialDeclineConnection::get_target "flux_node::ptr +get_target(int index) const With index 0, the left node is returned, with index 1 the right node of the connection. "; %feature("docstring") -cmf::upslope::connections::KinematicMacroFlow::get_tracer_filter "real get_tracer_filter() +cmf::water::ExponentialDeclineConnection::get_tracer_filter "real +get_tracer_filter() A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -6912,43 +10387,44 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::connections::KinematicMacroFlow::get_tracer_filter "real get_tracer_filter(solute S) +cmf::water::ExponentialDeclineConnection::get_tracer_filter "real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::connections::KinematicMacroFlow::kill_me "bool -kill_me() +cmf::water::ExponentialDeclineConnection::kill_me "bool kill_me() Deregisters this connection from its nodes. Returns true if only one reference is left. "; %feature("docstring") -cmf::upslope::connections::KinematicMacroFlow::left_node "flux_node::ptr left_node() const +cmf::water::ExponentialDeclineConnection::left_node "flux_node::ptr +left_node() const Returns the left node of this connection. "; -%feature("docstring") -cmf::upslope::connections::KinematicMacroFlow::q "real q(const -flux_node &inquirer, cmf::math::Time t) +%feature("docstring") cmf::water::ExponentialDeclineConnection::q "real q(const flux_node &inquirer, cmf::math::Time t) Returns the current flux through a connection. Negative signs mean out of the inquirer, positive are inflows to the inquirer. "; %feature("docstring") -cmf::upslope::connections::KinematicMacroFlow::refresh "void +cmf::water::ExponentialDeclineConnection::refresh "void refresh(cmf::math::Time t) Performes a new calculation of the flux. "; %feature("docstring") -cmf::upslope::connections::KinematicMacroFlow::right_node "flux_node::ptr right_node() const +cmf::water::ExponentialDeclineConnection::right_node "flux_node::ptr +right_node() const returns the right node of this connection "; %feature("docstring") -cmf::upslope::connections::KinematicMacroFlow::set_tracer_filter "void set_tracer_filter(real value) +cmf::water::ExponentialDeclineConnection::set_tracer_filter "void +set_tracer_filter(real value) A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -6956,90 +10432,165 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::connections::KinematicMacroFlow::set_tracer_filter "void set_tracer_filter(solute S, real value) "; +cmf::water::ExponentialDeclineConnection::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; %feature("docstring") -cmf::upslope::connections::KinematicMacroFlow::short_string "virtual +cmf::water::ExponentialDeclineConnection::short_string "virtual std::string short_string() const "; %feature("docstring") -cmf::upslope::connections::KinematicMacroFlow::to_string "virtual +cmf::water::ExponentialDeclineConnection::to_string "virtual std::string to_string() const "; -// File: classcmf_1_1upslope_1_1connections_1_1_kinematic_surface_runoff.xml +// File: classcmf__core_1_1external__control__connection.xml +%feature("docstring") cmf_core::external_control_connection " + +Flux from one node to another, controlled by the user or an external +program, by changing the flux constant. It is easy to create negative +volumes in water storages with this connection, which can be hazard to +the solver, since most connections rely on a positive volume in a +storage. Handle with care! C++ includes: simple_connections.h "; + +%feature("docstring") cmf_core::external_control_connection::__init__ +"def __init__(self, args, kwargs) + +__init__(cmf::water::external_control_connection self, +cmf::water::flux_node::ptr source, cmf::water::flux_node::ptr target, +real flux_value=0) -> external_control_connection +external_control_connection(flux_node::ptr source, flux_node::ptr +target, real flux_value=0) "; + %feature("docstring") -cmf::upslope::connections::KinematicSurfaceRunoff " +cmf_core::external_control_connection::__contains__ "def +__contains__(self, cmp) "; -A connection to route water from a SurfaceWater storage to another -node following a topographic gradient. +%feature("docstring") cmf_core::external_control_connection::__eq__ "def __eq__(self, args, kwargs) +__eq__(flux_connection self, flux_connection other) -> bool "; +%feature("docstring") +cmf_core::external_control_connection::__getitem__ "def +__getitem__(self, index) "; -.. math:: +%feature("docstring") cmf_core::external_control_connection::__iter__ +"def __iter__(self) "; - q_{runoff} = A_{cross} d_{eff}^{2/3} - \\\\frac{\\\\sqrt{S}}{n} +%feature("docstring") cmf_core::external_control_connection::__repr__ +"def __repr__(self) "; -where: :math:`q_{runoff}` is the surface -runoff +%feature("docstring") cmf_core::external_control_connection::conc "def conc(self, args, kwargs) -:math:`A_{cross}` is the wetted crossectional flux area, given as :math:`d_{eff} \\\\cdot w` +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -:math:`w` is the width of the shared boundary between the surface water -storage and the target node +%feature("docstring") +cmf_core::external_control_connection::exchange_target "def +exchange_target(self, args, kwargs) -:math:`d_{eff}` is the effective flow depth of the surface water.The -effective flow depth is defined as +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -.. math:: +%feature("docstring") +cmf_core::external_control_connection::get_target "def +get_target(self, args) - d_{eff} = \\\\begin{cases} - V/A-d_{puddle}\\\\ & V/A>d_{puddle} \\\\\\\\ 0.0 & V/A<=d_{puddle} - \\\\end{cases} +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -:math:`V` the volume of stored water in the surface in :math:`m^3` +%feature("docstring") +cmf_core::external_control_connection::get_tracer_filter "def +get_tracer_filter(self, args) -:math:`A` the area of the cell in :math:`m^2` +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -:math:`d_{puddle}=V_{puddle}/A` the average depth of water in the surface -water needed to start run off +%feature("docstring") cmf_core::external_control_connection::kill_me +"def kill_me(self, args, kwargs) -:math:`S = \\\\|\\\\frac{\\\\Delta z\\\\|}{d}` the slope between -surfacewater center and the target node +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -:math:`n` the manning roughness +%feature("docstring") +cmf_core::external_control_connection::left_node "def left_node(self, +args, kwargs) -The KinematicSurfaceRunoff can be used as a cell connecting flux as -in: This results in a connection of the surfacewater storage of each -cell with the surface water storages of its neighborssee +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -C++ includes: surfacewater.h "; +%feature("docstring") cmf_core::external_control_connection::q "def +q(self, args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::external_control_connection::refresh +"def refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; %feature("docstring") -cmf::upslope::connections::KinematicSurfaceRunoff::KinematicSurfaceRunoff -"KinematicSurfaceRunoff(cmf::upslope::SurfaceWater::ptr left, -cmf::water::flux_node::ptr right, real flowwidth, real distance=-1) +cmf_core::external_control_connection::right_node "def +right_node(self, args, kwargs) -Creates a KinematicSurfaceRunoff between a SurfaceWater (left) with -another (right) node. +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; -Parameters: ------------ +%feature("docstring") +cmf_core::external_control_connection::set_tracer_filter "def +set_tracer_filter(self, args) -left: A surfacewater storage +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; -right: The target node +%feature("docstring") +cmf_core::external_control_connection::short_string "def +short_string(self, args, kwargs) -flowwidth: the length of the shared boundary between left and right -in m +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -distance: the distance between left and right in m. If d<=0m, the -distance is calculated according to the position of left and right "; +%feature("docstring") +cmf_core::external_control_connection::to_string "def to_string(self, +args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf_1_1water_1_1external__control__connection.xml +%feature("docstring") cmf::water::external_control_connection " + +Flux from one node to another, controlled by the user or an external +program, by changing the flux constant. + +It is easy to create negative volumes in water storages with this +connection, which can be hazard to the solver, since most connections +rely on a positive volume in a storage. Handle with care! + +C++ includes: simple_connections.h "; %feature("docstring") -cmf::upslope::connections::KinematicSurfaceRunoff::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +cmf::water::external_control_connection::external_control_connection "external_control_connection(flux_node::ptr source, flux_node::ptr +target, real flux_value=0) "; + +%feature("docstring") cmf::water::external_control_connection::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns the concentration of the flux. @@ -7047,26 +10598,29 @@ If not overridden, it returns the concentration of the source of the flux (direction depending) "; %feature("docstring") -cmf::upslope::connections::KinematicSurfaceRunoff::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr -newTarget) "; +cmf::water::external_control_connection::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; %feature("docstring") -cmf::upslope::connections::KinematicSurfaceRunoff::get_ptr "ptr -get_ptr() const "; +cmf::water::external_control_connection::get_ptr "ptr get_ptr() const +"; %feature("docstring") -cmf::upslope::connections::KinematicSurfaceRunoff::get_target "flux_node::ptr get_target(const flux_node &inquirer) +cmf::water::external_control_connection::get_target "flux_node::ptr +get_target(const flux_node &inquirer) Returns the other end of a connection than the asking end. "; %feature("docstring") -cmf::upslope::connections::KinematicSurfaceRunoff::get_target "flux_node::ptr get_target(int index) const +cmf::water::external_control_connection::get_target "flux_node::ptr +get_target(int index) const With index 0, the left node is returned, with index 1 the right node of the connection. "; %feature("docstring") -cmf::upslope::connections::KinematicSurfaceRunoff::get_tracer_filter "real get_tracer_filter() +cmf::water::external_control_connection::get_tracer_filter "real +get_tracer_filter() A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -7074,43 +10628,44 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::connections::KinematicSurfaceRunoff::get_tracer_filter "real get_tracer_filter(solute S) +cmf::water::external_control_connection::get_tracer_filter "real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::connections::KinematicSurfaceRunoff::kill_me "bool -kill_me() +cmf::water::external_control_connection::kill_me "bool kill_me() Deregisters this connection from its nodes. Returns true if only one reference is left. "; %feature("docstring") -cmf::upslope::connections::KinematicSurfaceRunoff::left_node "flux_node::ptr left_node() const +cmf::water::external_control_connection::left_node "flux_node::ptr +left_node() const Returns the left node of this connection. "; -%feature("docstring") -cmf::upslope::connections::KinematicSurfaceRunoff::q "real q(const -flux_node &inquirer, cmf::math::Time t) +%feature("docstring") cmf::water::external_control_connection::q "real q(const flux_node &inquirer, cmf::math::Time t) Returns the current flux through a connection. Negative signs mean out of the inquirer, positive are inflows to the inquirer. "; %feature("docstring") -cmf::upslope::connections::KinematicSurfaceRunoff::refresh "void +cmf::water::external_control_connection::refresh "void refresh(cmf::math::Time t) Performes a new calculation of the flux. "; %feature("docstring") -cmf::upslope::connections::KinematicSurfaceRunoff::right_node "flux_node::ptr right_node() const +cmf::water::external_control_connection::right_node "flux_node::ptr +right_node() const returns the right node of this connection "; %feature("docstring") -cmf::upslope::connections::KinematicSurfaceRunoff::set_tracer_filter "void set_tracer_filter(real value) +cmf::water::external_control_connection::set_tracer_filter "void +set_tracer_filter(real value) A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -7118,109 +10673,220 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::connections::KinematicSurfaceRunoff::set_tracer_filter "void set_tracer_filter(solute S, real value) "; +cmf::water::external_control_connection::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; %feature("docstring") -cmf::upslope::connections::KinematicSurfaceRunoff::short_string "virtual std::string short_string() const "; +cmf::water::external_control_connection::short_string "virtual +std::string short_string() const "; %feature("docstring") -cmf::upslope::connections::KinematicSurfaceRunoff::to_string "virtual +cmf::water::external_control_connection::to_string "virtual std::string to_string() const "; -// File: classcmf_1_1water_1_1_langmuir_adsorption.xml -%feature("docstring") cmf::water::LangmuirAdsorption " +// File: classcmf_1_1fit__retention__curve_1_1_fit_brooks_corey.xml +%feature("docstring") cmf::fit_retention_curve::FitBrooksCorey ""; -This class calculates the adsorption equilibrium between sorbat and -sorbent using the Langmuir isotherme. +%feature("docstring") +cmf::fit_retention_curve::FitBrooksCorey::__init__ "def +__init__(self, theta, pF, verbose=False) "; -Langmuir Adsorption: +%feature("docstring") +cmf::fit_retention_curve::FitBrooksCorey::__call__ "def +__call__(self, count=1) "; +%feature("docstring") +cmf::fit_retention_curve::FitBrooksCorey::create_rc "def +create_rc(self, params) "; +%feature("docstring") +cmf::fit_retention_curve::FitBrooksCorey::get_error "def +get_error(self, params) "; -.. math:: - \\\\frac{x_{ad}}{m} = q = \\\\frac{K c}{1 + K c} +// File: classcmf_1_1fit__retention__curve_1_1_fit_retention_curve.xml +%feature("docstring") cmf::fit_retention_curve::FitRetentionCurve ""; -where -:math:`x_{ad} = x_{tot} - x_{free}` is the adsorbed tracer mass :math:`x_{tot}` -is the total tracer mass +%feature("docstring") +cmf::fit_retention_curve::FitRetentionCurve::__init__ "def +__init__(self, rc_class, theta, pF, verbose=False) "; -:math:`x_{free}` is the dissolved tracer mass +%feature("docstring") +cmf::fit_retention_curve::FitRetentionCurve::__call__ "def +__call__(self, count=1) "; -:math:`m` is the mass of the sorbent in the same unit as the tracer mass +%feature("docstring") +cmf::fit_retention_curve::FitRetentionCurve::create_rc "def +create_rc(self, params) "; -:math:`K` is the Langmuir sorption coefficient +%feature("docstring") +cmf::fit_retention_curve::FitRetentionCurve::get_error "def +get_error(self, params) "; -:math:`c = \\\\frac{x_{free}}{V}` is the concentration of the tracer in -tracer mass per m3 -CMF stores in a solute storage the total mass of a tracer and needs to -calculate the free tracer mass. The analytical solution for :math:`x_{free}` -from :math:`x_{tot}` is implemented in freesolute and derived usingsympy. If -you really want to see it, look in the code. - -http://en.wikipedia.org/wiki/Langmuir_equation +// File: classcmf_1_1fit__retention__curve_1_1_fit_van_genuchten_mualem.xml +%feature("docstring") cmf::fit_retention_curve::FitVanGenuchtenMualem +""; -C++ includes: adsorption.h "; +%feature("docstring") +cmf::fit_retention_curve::FitVanGenuchtenMualem::__init__ "def +__init__(self, theta, pF, fit_theta_r=False, fit_m=False, +verbose=False) "; %feature("docstring") -cmf::water::LangmuirAdsorption::LangmuirAdsorption "LangmuirAdsorption(real K, real m) "; +cmf::fit_retention_curve::FitVanGenuchtenMualem::__call__ "def +__call__(self, count=1) "; %feature("docstring") -cmf::water::LangmuirAdsorption::LangmuirAdsorption "LangmuirAdsorption(const LangmuirAdsorption &other) "; +cmf::fit_retention_curve::FitVanGenuchtenMualem::create_rc "def +create_rc(self, params) "; %feature("docstring") -cmf::water::LangmuirAdsorption::~LangmuirAdsorption "virtual -~LangmuirAdsorption() "; +cmf::fit_retention_curve::FitVanGenuchtenMualem::get_error "def +get_error(self, params) "; -%feature("docstring") cmf::water::LangmuirAdsorption::copy "LangmuirAdsorption* copy(real m=-1) const -returns a copy of the Adsorption object. +// File: classcmf__core_1_1flux__connection.xml +%feature("docstring") cmf_core::flux_connection " -If the adsorption is depending on the sorbent mass, you can give a -positive value for the sorbent mass m. If the value is not given or -negative, m is used from the original object. "; +The connections in cmf hold the processes for the calculation of +fluxes between water storages and model boundaries. Todo Elaborate on +this Represents a connection between flux_nodes, where water fluxes +occur. C++ includes: flux_connection.h "; -%feature("docstring") cmf::water::LangmuirAdsorption::freesolute "real freesolute(real xt, real V) const +%feature("docstring") cmf_core::flux_connection::__init__ "def +__init__(self, args, kwargs) "; -Returns the mass of dissolved tracer as a function of the total tracer -mass in the solute storage and the water volume. +%feature("docstring") cmf_core::flux_connection::__contains__ "def +__contains__(self, cmp) "; -Parameters: ------------ +%feature("docstring") cmf_core::flux_connection::__eq__ "def +__eq__(self, args, kwargs) -xt: :math:`x_t` the total tracer mass in the storage +__eq__(flux_connection self, flux_connection other) -> bool "; -V: :math:`V m^3` the water volume in the storage +%feature("docstring") cmf_core::flux_connection::__getitem__ "def +__getitem__(self, index) "; -:math:`x_f` the dissolved mass of the tracer "; +%feature("docstring") cmf_core::flux_connection::__iter__ "def +__iter__(self) "; -%feature("docstring") cmf::water::LangmuirAdsorption::totalsolute "real totalsolute(real xf, real V) const +%feature("docstring") cmf_core::flux_connection::__repr__ "def +__repr__(self) "; -Returns the total mass of the tracer from the dissolved concetration -in tracer unit/m3. +%feature("docstring") cmf_core::flux_connection::conc "def +conc(self, args, kwargs) -Parameters: ------------ +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -xf: :math:`x_f` the dissolved tracer mass in the storage +%feature("docstring") cmf_core::flux_connection::exchange_target "def exchange_target(self, args, kwargs) -V: :math:`V m^3` the water volume in the storage +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -:math:`x_t` the total mass of the tracer "; +%feature("docstring") cmf_core::flux_connection::get_target "def +get_target(self, args) +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -// File: classcmf_1_1upslope_1_1connections_1_1lateral__sub__surface__flux.xml -%feature("docstring") -cmf::upslope::connections::lateral_sub_surface_flux " +%feature("docstring") cmf_core::flux_connection::get_tracer_filter "def get_tracer_filter(self, args) -An abstract base class for lateral subsurface fluxes. +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -C++ includes: subsurfacefluxes.h "; +%feature("docstring") cmf_core::flux_connection::kill_me "def +kill_me(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::lateral_sub_surface_flux::conc "real +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::flux_connection::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::flux_connection::q "def q(self, +args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::flux_connection::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::flux_connection::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::flux_connection::set_tracer_filter "def set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::flux_connection::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::flux_connection::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf_1_1water_1_1flux__connection.xml +%feature("docstring") cmf::water::flux_connection " + +The connections in cmf hold the processes for the calculation of +fluxes between water storages and model boundaries. + +Todo Elaborate on this Represents a connection between flux_nodes, +where water fluxes occur. + +C++ includes: flux_connection.h "; + +%feature("docstring") cmf::water::flux_connection::flux_connection "flux_connection(flux_node::ptr left, flux_node::ptr right, std::string +_type) + +Creates a flux connection between the flux_node left and right. + +Parameters: +----------- + +left: flux_node on the one side of the connection + +right: flux_node on the other side of the connection + +_type: Type of the flux connection "; + +%feature("docstring") cmf::water::flux_connection::~flux_connection "virtual ~flux_connection() "; + +%feature("docstring") cmf::water::flux_connection::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns the concentration of the flux. @@ -7228,27 +10894,22 @@ Returns the concentration of the flux. If not overridden, it returns the concentration of the source of the flux (direction depending) "; -%feature("docstring") -cmf::upslope::connections::lateral_sub_surface_flux::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr +%feature("docstring") cmf::water::flux_connection::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") -cmf::upslope::connections::lateral_sub_surface_flux::get_ptr "ptr +%feature("docstring") cmf::water::flux_connection::get_ptr "ptr get_ptr() const "; -%feature("docstring") -cmf::upslope::connections::lateral_sub_surface_flux::get_target "flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") cmf::water::flux_connection::get_target "flux_node::ptr get_target(const flux_node &inquirer) Returns the other end of a connection than the asking end. "; -%feature("docstring") -cmf::upslope::connections::lateral_sub_surface_flux::get_target "flux_node::ptr get_target(int index) const +%feature("docstring") cmf::water::flux_connection::get_target "flux_node::ptr get_target(int index) const With index 0, the left node is returned, with index 1 the right node of the connection. "; -%feature("docstring") -cmf::upslope::connections::lateral_sub_surface_flux::get_tracer_filter +%feature("docstring") cmf::water::flux_connection::get_tracer_filter "real get_tracer_filter() A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -7256,45 +10917,38 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. 1.0 is no filter and 0.0 means no solute is crossing this connection "; -%feature("docstring") -cmf::upslope::connections::lateral_sub_surface_flux::get_tracer_filter +%feature("docstring") cmf::water::flux_connection::get_tracer_filter "real get_tracer_filter(solute S) A value ranging from 0 to 1 to filter tracers out of the water flux. "; -%feature("docstring") -cmf::upslope::connections::lateral_sub_surface_flux::kill_me "bool +%feature("docstring") cmf::water::flux_connection::kill_me "bool kill_me() Deregisters this connection from its nodes. Returns true if only one reference is left. "; -%feature("docstring") -cmf::upslope::connections::lateral_sub_surface_flux::left_node "flux_node::ptr left_node() const +%feature("docstring") cmf::water::flux_connection::left_node "flux_node::ptr left_node() const Returns the left node of this connection. "; -%feature("docstring") -cmf::upslope::connections::lateral_sub_surface_flux::q "real q(const +%feature("docstring") cmf::water::flux_connection::q "real q(const flux_node &inquirer, cmf::math::Time t) Returns the current flux through a connection. Negative signs mean out of the inquirer, positive are inflows to the inquirer. "; -%feature("docstring") -cmf::upslope::connections::lateral_sub_surface_flux::refresh "void +%feature("docstring") cmf::water::flux_connection::refresh "void refresh(cmf::math::Time t) Performes a new calculation of the flux. "; -%feature("docstring") -cmf::upslope::connections::lateral_sub_surface_flux::right_node "flux_node::ptr right_node() const +%feature("docstring") cmf::water::flux_connection::right_node "flux_node::ptr right_node() const returns the right node of this connection "; -%feature("docstring") -cmf::upslope::connections::lateral_sub_surface_flux::set_tracer_filter +%feature("docstring") cmf::water::flux_connection::set_tracer_filter "void set_tracer_filter(real value) A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -7302,234 +10956,13954 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. 1.0 is no filter and 0.0 means no solute is crossing this connection "; -%feature("docstring") -cmf::upslope::connections::lateral_sub_surface_flux::set_tracer_filter +%feature("docstring") cmf::water::flux_connection::set_tracer_filter "void set_tracer_filter(solute S, real value) "; -%feature("docstring") -cmf::upslope::connections::lateral_sub_surface_flux::short_string "virtual std::string short_string() const "; +%feature("docstring") cmf::water::flux_connection::short_string "virtual std::string short_string() const "; -%feature("docstring") -cmf::upslope::connections::lateral_sub_surface_flux::to_string "virtual std::string to_string() const "; +%feature("docstring") cmf::water::flux_connection::to_string "virtual std::string to_string() const "; -// File: classcmf_1_1upslope_1_1layer__list.xml -%feature("docstring") cmf::upslope::layer_list " +// File: classcmf__core_1_1flux__integrator.xml +%feature("docstring") cmf_core::flux_integrator " -A vector of layers, with array access to the properties of the layers, -for fast data exchange. +The flux_integrator is an integratable for precise output of average +fluxes over time. It can be added to solver (any +cmf::math::Integrator), which is then calling the integrate method at +each substep. C++ includes: flux_connection.h "; -C++ includes: layer_list.h "; +%feature("docstring") cmf_core::flux_integrator::__init__ "def +__init__(self, args) -%feature("docstring") cmf::upslope::layer_list::layer_list "layer_list(const layer_list &for_copy) +__init__(cmf::water::flux_integrator self, flux_connection connection) +-> flux_integrator __init__(cmf::water::flux_integrator self, +cmf::water::flux_node::ptr left, cmf::water::flux_node::ptr right) -> +flux_integrator flux_integrator(cmf::water::flux_node::ptr left, +cmf::water::flux_node::ptr right) Creates a flux_integrator from the +endpoints of a connection. Throws if there is no connection between +the endpoints. "; -Copy constructor. "; +%feature("docstring") cmf_core::flux_integrator::avg "def avg(self, +args, kwargs) -%feature("docstring") cmf::upslope::layer_list::layer_list "layer_list() +avg(integratable self) -> double virtual double avg() const =0 +Returns average of the integrated variable (eg. flux) from the last +reset until the last call of integrate. "; -Creates an empty layer list. "; +%feature("docstring") cmf_core::flux_integrator::connection "def +connection(self, args, kwargs) -%feature("docstring") cmf::upslope::layer_list::layer_list "layer_list(const cmf::water::node_list &for_copy) +connection(flux_integrator self) -> cmf::water::flux_connection::ptr +flux_connection::ptr connection() const Returns the flux_connection. +"; -Creates a list of all soil layers from a node_list. "; +%feature("docstring") cmf_core::flux_integrator::integrate "def +integrate(self, args, kwargs) -%feature("docstring") cmf::upslope::layer_list::append "layer_list& -append(SoilLayer::ptr l) +integrate(integratable self, Time t) virtual void integrate(Time t)=0 +Integrates the variable until time t. "; -Appends a soil layer to the list. "; +%feature("docstring") cmf_core::flux_integrator::integration_t "def +integration_t(self, args, kwargs) -%feature("docstring") cmf::upslope::layer_list::begin "iterator -begin() "; +integration_t(flux_integrator self) -> Time cmf::math::Time +integration_t() const Returns the duration of the integration. "; -%feature("docstring") cmf::upslope::layer_list::begin "const_iterator begin() const "; +%feature("docstring") cmf_core::flux_integrator::reset "def +reset(self, args, kwargs) -%feature("docstring") cmf::upslope::layer_list::clear "void clear() +reset(integratable self, Time t) virtual void reset(Time t)=0 Sets +the start time of the integral. "; -Clears the list. "; +%feature("docstring") cmf_core::flux_integrator::sum "def sum(self, +args, kwargs) -%feature("docstring") cmf::upslope::layer_list::end "iterator end() -"; +sum(integratable self) -> double virtual double sum() const =0 Get +the integral from the last reset until the last call of integrate. "; -%feature("docstring") cmf::upslope::layer_list::end "const_iterator -end() const "; +%feature("docstring") cmf_core::flux_integrator::t0 "def t0(self, +args, kwargs) -%feature("docstring") cmf::upslope::layer_list::extend "layer_list& -extend(const layer_list &ll) +t0(flux_integrator self) -> Time cmf::math::Time t0() const Returns +the start time of the integration. "; -Appends all soil layers of layer_list to this. "; -%feature("docstring") cmf::upslope::layer_list::extend "layer_list& -extend(const cmf::water::node_list &nl) +// File: classcmf_1_1water_1_1flux__integrator.xml +%feature("docstring") cmf::water::flux_integrator " -Appends all soil layers from a node_list to this. "; +The flux_integrator is an integratable for precise output of average +fluxes over time. -%feature("docstring") -cmf::upslope::layer_list::get_gravitational_potential "cmf::math::num_array get_gravitational_potential() const +It can be added to solver (any cmf::math::Integrator), which is then +calling the integrate method at each substep. -Returns an array containing the gravitational potential in m of all -layers in the list. "; +C++ includes: flux_connection.h "; -%feature("docstring") cmf::upslope::layer_list::get_ice_fraction "cmf::math::num_array get_ice_fraction() const "; +%feature("docstring") cmf::water::flux_integrator::flux_integrator "flux_integrator(cmf::water::flux_connection &connection) -%feature("docstring") cmf::upslope::layer_list::get_K "cmf::math::num_array get_K() const +Creates a flux_integrator from an connection. "; -Returns an array containing the conductivity in m/day of all layers in -the list. "; +%feature("docstring") cmf::water::flux_integrator::flux_integrator "flux_integrator(cmf::water::flux_node::ptr left, +cmf::water::flux_node::ptr right) -%feature("docstring") cmf::upslope::layer_list::get_Ksat "cmf::math::num_array get_Ksat() const +Creates a flux_integrator from the endpoints of a connection. Throws +if there is no connection between the endpoints. "; -Returns an array containing the saturated conductivity in m/day of all -layers in the list. "; +%feature("docstring") cmf::water::flux_integrator::avg "double avg() +const -%feature("docstring") cmf::upslope::layer_list::get_lower_boundary "cmf::math::num_array get_lower_boundary() const +Returns the average flux of the integration time in m3/day. "; -Returns an array containing the lower boundary in m below surface of -all layers in the list. "; +%feature("docstring") cmf::water::flux_integrator::connection "flux_connection::ptr connection() const -%feature("docstring") cmf::upslope::layer_list::get_matrix_potential -"cmf::math::num_array get_matrix_potential() const +Returns the flux_connection. "; -Returns an array containing the matrix potential in m of all layers in -the list. "; +%feature("docstring") cmf::water::flux_integrator::integrate "void +integrate(cmf::math::Time until) -%feature("docstring") cmf::upslope::layer_list::get_percolation "cmf::math::num_array get_percolation(cmf::math::Time t) const +Integrates the flux a timestep further. Note: until is an absolute +time. If until is before t0, the integration is initilized again. "; -Returns the flux to each layer from the upper layer, or, in case of -the first layer from the surface water. "; +%feature("docstring") cmf::water::flux_integrator::integration_t "cmf::math::Time integration_t() const -%feature("docstring") cmf::upslope::layer_list::get_porosity "cmf::math::num_array get_porosity() const +Returns the duration of the integration. "; -Returns an array containing the porosity in m3/m3 of all layers in the -list. "; +%feature("docstring") cmf::water::flux_integrator::reset "void +reset(cmf::math::Time t) -%feature("docstring") cmf::upslope::layer_list::get_potential "cmf::math::num_array get_potential() const +Initializes the integration. "; -Returns an array containing the potentials of all layers in the list. -"; +%feature("docstring") cmf::water::flux_integrator::sum "double sum() +const -%feature("docstring") cmf::upslope::layer_list::get_rootfraction "cmf::math::num_array get_rootfraction() const +Returns the amount of water along this connection in the integration +time in m3. "; -Returns an array containing the rootfraction of each layer. "; +%feature("docstring") cmf::water::flux_integrator::t0 "cmf::math::Time t0() const -%feature("docstring") cmf::upslope::layer_list::get_slice "layer_list get_slice(size_t first=0, size_t last=1000000, size_t -step=1) "; +Returns the start time of the integration. "; -%feature("docstring") cmf::upslope::layer_list::get_theta "cmf::math::num_array get_theta() const "; -%feature("docstring") cmf::upslope::layer_list::get_thickness "cmf::math::num_array get_thickness() const +// File: classcmf__core_1_1flux__node.xml +%feature("docstring") cmf_core::flux_node " -Returns an array containing the thickness in m of all layers in the -list. "; +Base class for everything that can be connected by fluxes. Flux nodes +can be WaterStorages, flux end points, sinks, sources and bridges to +other model domains (e.g. Ponded water to river system). The base +class can be used where a simple routing, potentially with mixing, is +needed. C++ includes: flux_node.h "; -%feature("docstring") cmf::upslope::layer_list::get_upper_boundary "cmf::math::num_array get_upper_boundary() const +%feature("docstring") cmf_core::flux_node::__init__ "def +__init__(self, args, kwargs) -Returns an array containing the upper boundary in m below surface of -all layers in the list. "; +__init__(cmf::water::flux_node self, project _project, point location) +-> flux_node flux_node(cmf::project &_project, cmf::geometry::point +location=cmf::geometry::point()) "; -%feature("docstring") cmf::upslope::layer_list::get_volume "cmf::math::num_array get_volume() const +%feature("docstring") cmf_core::flux_node::__call__ "def +__call__(self, args, kwargs) + +__call__(flux_node self, Time t) -> real "; + +%feature("docstring") cmf_core::flux_node::__eq__ "def __eq__(self, +args, kwargs) + +__eq__(flux_node self, flux_node other) -> bool "; + +%feature("docstring") cmf_core::flux_node::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::flux_node::conc "def conc(self, +args, kwargs) + +conc(flux_node self, Time t, solute Solute) -> real virtual real +conc(cmf::math::Time t, const cmf::water::solute &Solute) const +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; + +%feature("docstring") cmf_core::flux_node::connected_nodes "def +connected_nodes(self) "; + +%feature("docstring") cmf_core::flux_node::connection_to "def +connection_to(self, args, kwargs) + +connection_to(flux_node self, flux_node target) -> flux_connection +cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) Returns the connection between this and target. "; + +%feature("docstring") cmf_core::flux_node::flux3d_to "def +flux3d_to(self, args, kwargs) + +flux3d_to(flux_node self, flux_node target, Time t) -> point +cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; + +%feature("docstring") cmf_core::flux_node::flux_to "def +flux_to(self, args, kwargs) + +flux_to(flux_node self, flux_node target, Time t) -> real real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; + +%feature("docstring") cmf_core::flux_node::fluxes "def fluxes(self, +t) "; + +%feature("docstring") cmf_core::flux_node::get_3d_flux "def +get_3d_flux(self, args, kwargs) + +get_3d_flux(flux_node self, Time t) -> point cmf::geometry::point +get_3d_flux(cmf::math::Time t) Returns the sum of all flux vectors. +"; + +%feature("docstring") cmf_core::flux_node::is_empty "def +is_empty(self, args, kwargs) + +is_empty(flux_node self) -> double virtual double is_empty() const +Returns true if the node has no water. "; + +%feature("docstring") cmf_core::flux_node::is_storage "def +is_storage(self, args, kwargs) + +is_storage(flux_node self) -> bool virtual bool is_storage() const +true, if this is a waterstorage "; + +%feature("docstring") cmf_core::flux_node::RecalcFluxes "def +RecalcFluxes(self, args, kwargs) + +RecalcFluxes(flux_node self, Time t) -> bool virtual bool +RecalcFluxes(cmf::math::Time t) Pure flux_nodes do not influence +fluxes, therefore no recalculation of fluxes is required by flux_node. +WaterStorage overrides this, since state changes require an update of +the fluxes "; + +%feature("docstring") cmf_core::flux_node::remove_connection "def +remove_connection(self, args, kwargs) + +remove_connection(flux_node self, cmf::water::flux_node::ptr To) -> +bool bool remove_connection(cmf::water::flux_node::ptr To) Remove +the connection. "; + +%feature("docstring") cmf_core::flux_node::to_string "def +to_string(self, args, kwargs) + +to_string(flux_node self) -> std::string virtual std::string +to_string() const "; + +%feature("docstring") cmf_core::flux_node::waterbalance "def +waterbalance(self, args, kwargs) + +waterbalance(flux_node self, Time t, flux_connection Without=None) -> +real real waterbalance(cmf::math::Time t, const flux_connection +*Without=0) const Returns the sum of all fluxes (positive and +negative) at time t. Single fluxes can be excluded from the +calculation Parameters: ----------- t: Time of the query Without: +A flux_connection that is excluded from the waterbalance (e.g. to +prevent closed circuits) "; + + +// File: classcmf_1_1water_1_1flux__node.xml +%feature("docstring") cmf::water::flux_node " + +Base class for everything that can be connected by fluxes. + +Flux nodes can be WaterStorages, flux end points, sinks, sources and +bridges to other model domains (e.g. Ponded water to river system). +The base class can be used where a simple routing, potentially with +mixing, is needed. + +C++ includes: flux_node.h "; + +%feature("docstring") cmf::water::flux_node::flux_node "flux_node(cmf::project &_project, cmf::geometry::point +location=cmf::geometry::point()) "; + +%feature("docstring") cmf::water::flux_node::~flux_node "virtual +~flux_node() + +The destructor deletes all connections. "; + +%feature("docstring") cmf::water::flux_node::conc "virtual real +conc(cmf::math::Time t, const cmf::water::solute &Solute) const + +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; + +%feature("docstring") cmf::water::flux_node::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) + +Returns the connection between this and target. "; + +%feature("docstring") cmf::water::flux_node::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; + +%feature("docstring") cmf::water::flux_node::flux_to "real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) + +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; + +%feature("docstring") cmf::water::flux_node::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) + +Returns the sum of all flux vectors. "; + +%feature("docstring") cmf::water::flux_node::get_connections "cmf::water::connection_list get_connections() const "; + +%feature("docstring") cmf::water::flux_node::get_potential "virtual +real get_potential() const + +Returns the water potential of the node in m waterhead. + +The base class water storage always returns the height of the location +"; + +%feature("docstring") cmf::water::flux_node::get_project "cmf::project& get_project() const + +Returns the project, this node is part of. "; + +%feature("docstring") cmf::water::flux_node::is_empty "virtual +double is_empty() const + +Returns true if the node has no water. "; + +%feature("docstring") cmf::water::flux_node::is_storage "virtual +bool is_storage() const + +true, if this is a waterstorage "; + +%feature("docstring") cmf::water::flux_node::RecalcFluxes "virtual +bool RecalcFluxes(cmf::math::Time t) + +Pure flux_nodes do not influence fluxes, therefore no recalculation of +fluxes is required by flux_node. + +WaterStorage overrides this, since state changes require an update of +the fluxes "; + +%feature("docstring") cmf::water::flux_node::remove_connection "bool +remove_connection(cmf::water::flux_node::ptr To) + +Remove the connection. "; + +%feature("docstring") cmf::water::flux_node::set_potential "virtual +void set_potential(real new_potential) + +Sets the potential of this flux node. "; + +%feature("docstring") cmf::water::flux_node::to_string "virtual +std::string to_string() const "; + +%feature("docstring") cmf::water::flux_node::waterbalance "real +waterbalance(cmf::math::Time t, const flux_connection *Without=0) +const + +Returns the sum of all fluxes (positive and negative) at time t. + +Single fluxes can be excluded from the calculation + +Parameters: +----------- + +t: Time of the query + +Without: A flux_connection that is excluded from the waterbalance +(e.g. to prevent closed circuits) "; + + +// File: classcmf_1_1draw_1_1cellmap_1_1_flux_map.xml +%feature("docstring") cmf::draw::cellmap::FluxMap " + +Draws for each cell an arrow indicating the direction and velocity of +flow through the cell (in horizontal direction). Uses plt.quiver The +FluxMap can be updated by calling it with the new timestep Usage: >>> +import cmf >>> p = cmf.project() >>> solver = cmf.RKFIntegrator(p, +1e-9) >>> fm = FluxMap(p, cmf.Time()) >>> for t in +solver.run(solver.t, solver.t + cmf.day * 30, cmf.h): ... fm(t) "; + +%feature("docstring") cmf::draw::cellmap::FluxMap::__init__ "def +__init__(self, cells, t, kwargs) + +Creates a new flux map :param cells: The cells to be used :param t: +The current time step :param kwargs: Keyword arguments for plt.quiver +"; + +%feature("docstring") cmf::draw::cellmap::FluxMap::__call__ "def +__call__(self, t=None) "; + + +// File: classcmf__core_1_1_free_drainage_percolation.xml +%feature("docstring") cmf_core::FreeDrainagePercolation " + +Calculates a free drainage (unit gradient) from a layer to somewhere +else. .. math:: q = K(\\\\\\\\theta) A where: :math:`q` +Flux from the layer to the other side of the connection in +:math:`m^3/day` :math:`K(\\\\\\\\theta)` Actual conductivity in +:math:`m/day` depending on the water content of the layer +:math:`\\\\\\\\theta` :math:`A` Cell area in :math:`m^2` C++ +includes: Percolation.h "; + +%feature("docstring") cmf_core::FreeDrainagePercolation::__init__ "def __init__(self, args, kwargs) + +__init__(cmf::upslope::connections::FreeDrainagePercolation self, +cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right) +-> FreeDrainagePercolation +FreeDrainagePercolation(cmf::upslope::SoilLayer::ptr left, +cmf::water::flux_node::ptr right) "; + +%feature("docstring") cmf_core::FreeDrainagePercolation::__contains__ +"def __contains__(self, cmp) "; + +%feature("docstring") cmf_core::FreeDrainagePercolation::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::FreeDrainagePercolation::__getitem__ +"def __getitem__(self, index) "; + +%feature("docstring") cmf_core::FreeDrainagePercolation::__iter__ "def __iter__(self) "; + +%feature("docstring") cmf_core::FreeDrainagePercolation::__repr__ "def __repr__(self) "; + +%feature("docstring") cmf_core::FreeDrainagePercolation::conc "def +conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") +cmf_core::FreeDrainagePercolation::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::FreeDrainagePercolation::get_target "def get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") +cmf_core::FreeDrainagePercolation::get_tracer_filter "def +get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::FreeDrainagePercolation::kill_me "def kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::FreeDrainagePercolation::left_node "def left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::FreeDrainagePercolation::q "def +q(self, args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::FreeDrainagePercolation::refresh "def refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::FreeDrainagePercolation::right_node "def right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") +cmf_core::FreeDrainagePercolation::set_tracer_filter "def +set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::FreeDrainagePercolation::short_string +"def short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::FreeDrainagePercolation::to_string "def to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf_1_1upslope_1_1connections_1_1_free_drainage_percolation.xml +%feature("docstring") +cmf::upslope::connections::FreeDrainagePercolation " + +Calculates a free drainage (unit gradient) from a layer to somewhere +else. + + + +.. math:: + + q = K(\\\\theta) A + +where: :math:`q` Flux from the layer to the +other side of the connection in :math:`m^3/day` + +:math:`K(\\\\theta)` Actual conductivity in :math:`m/day` depending on the water +content of the layer :math:`\\\\theta` + +:math:`A` Cell area in :math:`m^2` + +C++ includes: Percolation.h "; + +%feature("docstring") +cmf::upslope::connections::FreeDrainagePercolation::FreeDrainagePercolation +"FreeDrainagePercolation(cmf::upslope::SoilLayer::ptr left, +cmf::water::flux_node::ptr right) "; + +%feature("docstring") +cmf::upslope::connections::FreeDrainagePercolation::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") +cmf::upslope::connections::FreeDrainagePercolation::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr +newTarget) "; + +%feature("docstring") +cmf::upslope::connections::FreeDrainagePercolation::get_ptr "ptr +get_ptr() const "; + +%feature("docstring") +cmf::upslope::connections::FreeDrainagePercolation::get_target "flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") +cmf::upslope::connections::FreeDrainagePercolation::get_target "flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") +cmf::upslope::connections::FreeDrainagePercolation::get_tracer_filter +"real get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::FreeDrainagePercolation::get_tracer_filter +"real get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") +cmf::upslope::connections::FreeDrainagePercolation::kill_me "bool +kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") +cmf::upslope::connections::FreeDrainagePercolation::left_node "flux_node::ptr left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") +cmf::upslope::connections::FreeDrainagePercolation::q "real q(const +flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") +cmf::upslope::connections::FreeDrainagePercolation::refresh "void +refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") +cmf::upslope::connections::FreeDrainagePercolation::right_node "flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") +cmf::upslope::connections::FreeDrainagePercolation::set_tracer_filter +"void set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::FreeDrainagePercolation::set_tracer_filter +"void set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf::upslope::connections::FreeDrainagePercolation::short_string "virtual std::string short_string() const "; + +%feature("docstring") +cmf::upslope::connections::FreeDrainagePercolation::to_string "virtual std::string to_string() const "; + + +// File: classcmf__core_1_1_freundlich_adsorbtion.xml +%feature("docstring") cmf_core::FreundlichAdsorbtion " + +This class calculates the adsorption equilibrium between sorbat and +sorbent using the Freundlich isotherme. Freundlich isotherme: .. +math:: \\\\\\\\frac{x_{ad}}{m} = K c^n where :math:`x_{ad} = +x_{tot} - x_{free}` is the adsorbed tracer mass :math:`x_{tot}` is +the total tracer mass :math:`x_{free}` is the dissolved tracer mass +:math:`m` is the mass of the sorbent in the same unit as the tracer +mass :math:`K` is the Freundlich sorption coefficient :math:`c = +\\\\\\\\frac{x_{free}}{V}` is the concentration of the tracer in +tracer mass per m3 :math:`n` is the Freundlich exponent CMF stores +in a solute storage the total mass of a tracer and needs to calculate +the free tracer mass. The eq. above can not be rearanged to get +:math:`x_{free}` from :math:`x_{tot}`. Instead, the value is iterated +usingregula falsi. If n is near to 1, using LinearAdsorption will +speed up your calculations.Todo Check if an analytical solution is +available The simplest physically based adsorption model by Langmuir ( +LangmuirAdsorption) has also a analytical solution and is hence +calculated faster then Freundlich. C++ includes: adsorption.h "; + +%feature("docstring") cmf_core::FreundlichAdsorbtion::__init__ "def +__init__(self, args) + +__init__(cmf::water::FreundlichAdsorbtion self, real K, real n, real +m, real epsilon=1e-12, int maxiter=100) -> FreundlichAdsorbtion +__init__(cmf::water::FreundlichAdsorbtion self, FreundlichAdsorbtion +other) -> FreundlichAdsorbtion FreundlichAdsorbtion(const +FreundlichAdsorbtion &other) "; + +%feature("docstring") cmf_core::FreundlichAdsorbtion::copy "def +copy(self, args, kwargs) + +copy(FreundlichAdsorbtion self, real m=-1) -> FreundlichAdsorbtion +FreundlichAdsorbtion* copy(real m=-1) const returns a copy of the +Adsorption object. If the adsorption is depending on the sorbent +mass, you can give a positive value for the sorbent mass m. If the +value is not given or negative, m is used from the original object. "; + +%feature("docstring") cmf_core::FreundlichAdsorbtion::freesolute "def freesolute(self, args, kwargs) + +freesolute(Adsorption self, real xt, real V) -> real virtual real +freesolute(real xt, real V) const =0 Returns the mass of dissolved +tracer as a function of the total tracer mass in the solute storage +and the water volume. Parameters: ----------- xt: :math:`x_t` the +total tracer mass in the storage V: :math:`V m^3` the water volume +in the storage :math:`x_f` the dissolved mass of the tracer "; + +%feature("docstring") cmf_core::FreundlichAdsorbtion::totalsolute "def totalsolute(self, args, kwargs) + +totalsolute(Adsorption self, real xf, real V) -> real virtual real +totalsolute(real xf, real V) const =0 Returns the total mass of the +tracer from the dissolved concetration in tracer unit/m3. Parameters: +----------- xf: :math:`x_f` the dissolved tracer mass in the +storage V: :math:`V m^3` the water volume in the storage +:math:`x_t` the total mass of the tracer "; + + +// File: classcmf_1_1water_1_1_freundlich_adsorbtion.xml +%feature("docstring") cmf::water::FreundlichAdsorbtion " + +This class calculates the adsorption equilibrium between sorbat and +sorbent using the Freundlich isotherme. + +Freundlich isotherme: + + + +.. math:: + + \\\\frac{x_{ad}}{m} = K c^n + +where :math:`x_{ad} = x_{tot} - x_{free}` is the adsorbed tracer mass :math:`x_{tot}` is the total tracer +mass + +:math:`x_{free}` is the dissolved tracer mass + +:math:`m` is the mass of the sorbent in the same unit as the tracer mass + +:math:`K` is the Freundlich sorption coefficient + +:math:`c = \\\\frac{x_{free}}{V}` is the concentration of the tracer in +tracer mass per m3 + +:math:`n` is the Freundlich exponent + +CMF stores in a solute storage the total mass of a tracer and needs to +calculate the free tracer mass. The eq. above can not be rearanged to +get :math:`x_{free}` from :math:`x_{tot}`. Instead, the value is iterated +usingregula falsi. If n is near to 1, using LinearAdsorption will +speed up your calculations.Todo Check if an analytical solution is +available The simplest physically based adsorption model by Langmuir ( +LangmuirAdsorption) has also a analytical solution and is hence +calculated faster then Freundlich. + +C++ includes: adsorption.h "; + +%feature("docstring") +cmf::water::FreundlichAdsorbtion::FreundlichAdsorbtion "FreundlichAdsorbtion(real K, real n, real m, real epsilon=1e-12, int +maxiter=100) + +Parameters: +----------- + +K: n: Freundlich coefficents + +m: Mass of sorbent in units of tracer + +epsilon: Tolerance of regula falsi iteration for the calculation of +dissolved tracer from total trace, default = 1e-12 + +maxiter: Maximum number of iterations, default = 100 "; + +%feature("docstring") +cmf::water::FreundlichAdsorbtion::FreundlichAdsorbtion "FreundlichAdsorbtion(const FreundlichAdsorbtion &other) "; + +%feature("docstring") +cmf::water::FreundlichAdsorbtion::~FreundlichAdsorbtion "virtual +~FreundlichAdsorbtion() "; + +%feature("docstring") cmf::water::FreundlichAdsorbtion::copy "FreundlichAdsorbtion* copy(real m=-1) const + +returns a copy of the Adsorption object. + +If the adsorption is depending on the sorbent mass, you can give a +positive value for the sorbent mass m. If the value is not given or +negative, m is used from the original object. "; + +%feature("docstring") cmf::water::FreundlichAdsorbtion::freesolute "real freesolute(real xt, real V) const + +Returns the mass of dissolved tracer as a function of the total tracer +mass in the solute storage and the water volume. + +Parameters: +----------- + +xt: :math:`x_t` the total tracer mass in the storage + +V: :math:`V m^3` the water volume in the storage + +:math:`x_f` the dissolved mass of the tracer "; + +%feature("docstring") cmf::water::FreundlichAdsorbtion::totalsolute "real totalsolute(real xf, real V) const + +Returns the total mass of the tracer from the dissolved concetration +in tracer unit/m3. + +Parameters: +----------- + +xf: :math:`x_f` the dissolved tracer mass in the storage + +V: :math:`V m^3` the water volume in the storage + +:math:`x_t` the total mass of the tracer "; + + +// File: classcmf__core_1_1generic__gradient__connection.xml +%feature("docstring") cmf_core::generic_gradient_connection " + +A generic node-to-node gradient based connection. This connection is +similar to the Darcy-connection, but there are no restrictions +concerning the type of nodes. However, the left side needs to be a +water storage .. math:: q = K A +\\\\\\\\frac{\\\\\\\\Psi_{l}-\\\\\\\\Psi_{r}}{d} where: :math:`q`: +the resulting flux in :math:`m^3/day` :math:`K`: the conductivity of +the connection :math:`A`: the area of the connection cross section +:math:`\\\\\\\\Psi`: The hydraulic head of the (l)eft, resp. (r)ight +node of the connection :math:`d`: The topographic length of the +connection in m C++ includes: simple_connections.h "; + +%feature("docstring") cmf_core::generic_gradient_connection::__init__ +"def __init__(self, args, kwargs) + +__init__(cmf::water::generic_gradient_connection self, +cmf::water::WaterStorage::ptr left, cmf::water::WaterStorage::ptr +right, real K, real d=1.0, real A=1.0) -> generic_gradient_connection +generic_gradient_connection(cmf::water::WaterStorage::ptr left, +cmf::water::WaterStorage::ptr right, real K, real d=1.0, real A=1.0) +Creates a generic gradient based flux, if enough water is present in +the source. Parameters: ----------- left: The left node of the +connection right: The right node of the connection K: the +conductivity of the connection in m/day d: the topographic lenght of +the connection in m A: the area of the connection cross section in +m2 "; + +%feature("docstring") +cmf_core::generic_gradient_connection::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::generic_gradient_connection::__eq__ "def __eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") +cmf_core::generic_gradient_connection::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::generic_gradient_connection::__iter__ +"def __iter__(self) "; + +%feature("docstring") cmf_core::generic_gradient_connection::__repr__ +"def __repr__(self) "; + +%feature("docstring") cmf_core::generic_gradient_connection::conc "def conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") +cmf_core::generic_gradient_connection::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") +cmf_core::generic_gradient_connection::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") +cmf_core::generic_gradient_connection::get_tracer_filter "def +get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::generic_gradient_connection::kill_me +"def kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") +cmf_core::generic_gradient_connection::left_node "def left_node(self, +args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::generic_gradient_connection::q "def +q(self, args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::generic_gradient_connection::refresh +"def refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") +cmf_core::generic_gradient_connection::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") +cmf_core::generic_gradient_connection::set_tracer_filter "def +set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf_core::generic_gradient_connection::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") +cmf_core::generic_gradient_connection::to_string "def to_string(self, +args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf_1_1water_1_1generic__gradient__connection.xml +%feature("docstring") cmf::water::generic_gradient_connection " + +A generic node-to-node gradient based connection. + +This connection is similar to the Darcy-connection, but there are no +restrictions concerning the type of nodes. However, the left side +needs to be a water storage + +.. math:: + + q = K A + \\\\frac{\\\\Psi_{l}-\\\\Psi_{r}}{d} + +where: :math:`q`: the resulting +flux in :math:`m^3/day` + +:math:`K`: the conductivity of the connection + +:math:`A`: the area of the connection cross section + +:math:`\\\\Psi`: The hydraulic head of the (l)eft, resp. (r)ight node of the +connection + +:math:`d`: The topographic length of the connection in m + +C++ includes: simple_connections.h "; + +%feature("docstring") +cmf::water::generic_gradient_connection::generic_gradient_connection "generic_gradient_connection(cmf::water::WaterStorage::ptr left, +cmf::water::WaterStorage::ptr right, real K, real d=1.0, real A=1.0) + +Creates a generic gradient based flux, if enough water is present in +the source. + +Parameters: +----------- + +left: The left node of the connection + +right: The right node of the connection + +K: the conductivity of the connection in m/day + +d: the topographic lenght of the connection in m + +A: the area of the connection cross section in m2 "; + +%feature("docstring") cmf::water::generic_gradient_connection::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") +cmf::water::generic_gradient_connection::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") +cmf::water::generic_gradient_connection::get_ptr "ptr get_ptr() const +"; + +%feature("docstring") +cmf::water::generic_gradient_connection::get_target "flux_node::ptr +get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") +cmf::water::generic_gradient_connection::get_target "flux_node::ptr +get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") +cmf::water::generic_gradient_connection::get_tracer_filter "real +get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::water::generic_gradient_connection::get_tracer_filter "real +get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") +cmf::water::generic_gradient_connection::kill_me "bool kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") +cmf::water::generic_gradient_connection::left_node "flux_node::ptr +left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") cmf::water::generic_gradient_connection::q "real q(const flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") +cmf::water::generic_gradient_connection::refresh "void +refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") +cmf::water::generic_gradient_connection::right_node "flux_node::ptr +right_node() const + +returns the right node of this connection "; + +%feature("docstring") +cmf::water::generic_gradient_connection::set_tracer_filter "void +set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::water::generic_gradient_connection::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf::water::generic_gradient_connection::short_string "virtual +std::string short_string() const "; + +%feature("docstring") +cmf::water::generic_gradient_connection::to_string "virtual +std::string to_string() const "; + + +// File: classcmf_1_1upslope_1_1connections_1_1_gradient_macro_flow.xml +%feature("docstring") cmf::upslope::connections::GradientMacroFlow " + +Gradient based flux from macro pore to macro pore. + +Deprecated The MacroPore model is still very experimental and not +stable. Only for tryouts! + + + +.. math:: + + q = K(\\\\theta) \\\\frac{\\\\Delta \\\\Psi}{\\\\Delta z} + +C++ includes: macropore.h "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroFlow::GradientMacroFlow "GradientMacroFlow(cmf::upslope::MacroPore::ptr left, +cmf::water::flux_node::ptr right) "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroFlow::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroFlow::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroFlow::get_ptr "ptr get_ptr() +const "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroFlow::get_target "flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroFlow::get_target "flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroFlow::get_tracer_filter "real +get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::GradientMacroFlow::get_tracer_filter "real +get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") +cmf::upslope::connections::GradientMacroFlow::kill_me "bool kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroFlow::left_node "flux_node::ptr left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") cmf::upslope::connections::GradientMacroFlow::q +"real q(const flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroFlow::refresh "void +refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroFlow::right_node "flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroFlow::set_tracer_filter "void +set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::GradientMacroFlow::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroFlow::short_string "virtual +std::string short_string() const "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroFlow::to_string "virtual +std::string to_string() const "; + + +// File: classcmf__core_1_1_gradient_macro_flow.xml +%feature("docstring") cmf_core::GradientMacroFlow " + +Gradient based flux from macro pore to macro pore. Deprecated The +MacroPore model is still very experimental and not stable. Only for +tryouts! .. math:: q = K(\\\\\\\\theta) +\\\\\\\\frac{\\\\\\\\Delta \\\\\\\\Psi}{\\\\\\\\Delta z} C++ +includes: macropore.h "; + +%feature("docstring") cmf_core::GradientMacroFlow::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::connections::GradientMacroFlow self, +cmf::upslope::MacroPore::ptr left, cmf::water::flux_node::ptr right) +-> GradientMacroFlow GradientMacroFlow(cmf::upslope::MacroPore::ptr +left, cmf::water::flux_node::ptr right) "; + +%feature("docstring") cmf_core::GradientMacroFlow::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::GradientMacroFlow::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::GradientMacroFlow::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::GradientMacroFlow::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::GradientMacroFlow::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::GradientMacroFlow::conc "def +conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") cmf_core::GradientMacroFlow::exchange_target "def exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::GradientMacroFlow::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::GradientMacroFlow::get_tracer_filter +"def get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::GradientMacroFlow::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::GradientMacroFlow::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::GradientMacroFlow::q "def q(self, +args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::GradientMacroFlow::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::GradientMacroFlow::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::GradientMacroFlow::set_tracer_filter +"def set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::GradientMacroFlow::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::GradientMacroFlow::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf_1_1upslope_1_1connections_1_1_gradient_macro_micro_exchange.xml +%feature("docstring") +cmf::upslope::connections::GradientMacroMicroExchange " + +A gradient based exchange term between macropores and micropores, +using a fixed (air-) potential for macropores. + + + +.. math:: + + q = K \\\\frac{\\\\Delta\\\\Psi}{d/2} A + +where: :math:`K` The +conductivity of the aggregate boundary + +:math:`\\\\Delta\\\\Psi` The potential difference. Using the air potential +as the constant potential for the macro pores, you get: +:math:`\\\\Delta\\\\Psi = \\\\Psi_M(\\\\theta_{micro})` + +:math:`d` the mean aggregate size in m + +:math:`A` the crosssection area, given as the flow width ( +cmf::upslope::MacroPore::get_flowwidth) times layer thickness + +C++ includes: macropore.h "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroMicroExchange::GradientMacroMicroExchange +"GradientMacroMicroExchange(cmf::upslope::SoilLayer::ptr left, +cmf::upslope::MacroPore::ptr right) "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroMicroExchange::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroMicroExchange::exchange_target +"void exchange_target(flux_node::ptr oldtarget, flux_node::ptr +newTarget) "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroMicroExchange::get_ptr "ptr +get_ptr() const "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroMicroExchange::get_target "flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroMicroExchange::get_target "flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroMicroExchange::get_tracer_filter +"real get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::GradientMacroMicroExchange::get_tracer_filter +"real get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") +cmf::upslope::connections::GradientMacroMicroExchange::kill_me "bool +kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroMicroExchange::left_node "flux_node::ptr left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroMicroExchange::q "real +q(const flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroMicroExchange::refresh "void +refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroMicroExchange::right_node "flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroMicroExchange::set_tracer_filter +"void set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::GradientMacroMicroExchange::set_tracer_filter +"void set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroMicroExchange::short_string "virtual std::string short_string() const "; + +%feature("docstring") +cmf::upslope::connections::GradientMacroMicroExchange::to_string "virtual std::string to_string() const "; + + +// File: classcmf__core_1_1_gradient_macro_micro_exchange.xml +%feature("docstring") cmf_core::GradientMacroMicroExchange " + +A gradient based exchange term between macropores and micropores, +using a fixed (air-) potential for macropores. .. math:: q = K +\\\\\\\\frac{\\\\\\\\Delta\\\\\\\\Psi}{d/2} A where: :math:`K` The +conductivity of the aggregate boundary +:math:`\\\\\\\\Delta\\\\\\\\Psi` The potential difference. Using the +air potential as the constant potential for the macro pores, you get: +:math:`\\\\\\\\Delta\\\\\\\\Psi = +\\\\\\\\Psi_M(\\\\\\\\theta_{micro})` :math:`d` the mean aggregate +size in m :math:`A` the crosssection area, given as the flow width ( +cmf::upslope::MacroPore::get_flowwidth) times layer thickness C++ +includes: macropore.h "; + +%feature("docstring") cmf_core::GradientMacroMicroExchange::__init__ +"def __init__(self, args, kwargs) + +__init__(cmf::upslope::connections::GradientMacroMicroExchange self, +cmf::upslope::SoilLayer::ptr left, cmf::upslope::MacroPore::ptr right) +-> GradientMacroMicroExchange +GradientMacroMicroExchange(cmf::upslope::SoilLayer::ptr left, +cmf::upslope::MacroPore::ptr right) "; + +%feature("docstring") +cmf_core::GradientMacroMicroExchange::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::GradientMacroMicroExchange::__eq__ "def __eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") +cmf_core::GradientMacroMicroExchange::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::GradientMacroMicroExchange::__iter__ +"def __iter__(self) "; + +%feature("docstring") cmf_core::GradientMacroMicroExchange::__repr__ +"def __repr__(self) "; + +%feature("docstring") cmf_core::GradientMacroMicroExchange::conc "def conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") +cmf_core::GradientMacroMicroExchange::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") +cmf_core::GradientMacroMicroExchange::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") +cmf_core::GradientMacroMicroExchange::get_tracer_filter "def +get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::GradientMacroMicroExchange::kill_me "def kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::GradientMacroMicroExchange::left_node +"def left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::GradientMacroMicroExchange::q "def +q(self, args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::GradientMacroMicroExchange::refresh "def refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") +cmf_core::GradientMacroMicroExchange::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") +cmf_core::GradientMacroMicroExchange::set_tracer_filter "def +set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf_core::GradientMacroMicroExchange::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::GradientMacroMicroExchange::to_string +"def to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf__core_1_1_green_ampt_infiltration.xml +%feature("docstring") cmf_core::GreenAmptInfiltration " + +Connects the surfacewater and the most upper layer using a Green-Ampt +equation like infiltration. The Green-Ampt formula is given as: .. +math:: q(t) = -K_s \\\\\\\\frac{dh}{dz} A where: +:math:`q(t)` is the infiltration rate in m3/day :math:`K_s` is the +saturated conductivity in m/day :math:`\\\\\\\\frac{dh}{dz}` is the +hydraulic gradient in the wetting front :math:`A` is the surface area +of the cell The gradient in the wetting front is calculated as: .. +math:: \\\\\\\\frac{dh}{dz} = \\\\\\\\frac{h_f - h_0}{Z_f} = +\\\\\\\\frac{|\\\\\\\\Psi_f| + Z_f}{Z_f} where: :math:`h_f` is the +hydraulic head at the bottom of the wetting front in m :math:`h_0` is +the hydraulic head at the surface in m :math:`Z_f` is the length of +the wetting front in m Since :math:`Z_f` is unknown, the depth of the +wetting front can be approximated by: .. math:: Z_f = +\\\\\\\\frac{F}{\\\\\\\\theta_s - \\\\\\\\theta_i} with: +:math:`F` the accumulated volume per area of infiltrated water +:math:`\\\\\\\\theta_s, \\\\\\\\theta_i` the volumetric water content +at saturation resp. at start of the infiltration If the surface water +is modeled by a distinct water storage, the actual infiltration is +given as the product of the potential infiltration with the coverage +of the surface water cmf::upslope::Cell::surface_water_coverage .. +math:: q_{act} = q_{max} \\\\\\\\frac{A_{water}}{A_{cell}} If +the surface water is no storage on its own, but just a water +distribution node, the actual infiltration is the minimum of the +potential infiltration and the current inflow (rain, snow melt) to the +surface .. math:: q_{act} = \\\\\\\\min\\\\\\\\left(q_{max}, +\\\\\\\\sum{q_{in,surfacewater}}\\\\\\\\right) C++ includes: +infiltration.h "; + +%feature("docstring") cmf_core::GreenAmptInfiltration::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::connections::GreenAmptInfiltration self, +cmf::upslope::SoilLayer::ptr soilwater, cmf::water::flux_node::ptr +surfacewater) -> GreenAmptInfiltration +GreenAmptInfiltration(cmf::upslope::SoilLayer::ptr soilwater, +cmf::water::flux_node::ptr surfacewater) "; + +%feature("docstring") cmf_core::GreenAmptInfiltration::__contains__ "def __contains__(self, cmp) "; + +%feature("docstring") cmf_core::GreenAmptInfiltration::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::GreenAmptInfiltration::__getitem__ "def __getitem__(self, index) "; + +%feature("docstring") cmf_core::GreenAmptInfiltration::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::GreenAmptInfiltration::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::GreenAmptInfiltration::conc "def +conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") +cmf_core::GreenAmptInfiltration::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::GreenAmptInfiltration::get_target "def get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") +cmf_core::GreenAmptInfiltration::get_tracer_filter "def +get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::GreenAmptInfiltration::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::GreenAmptInfiltration::left_node "def left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::GreenAmptInfiltration::q "def +q(self, args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::GreenAmptInfiltration::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::GreenAmptInfiltration::right_node "def right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") +cmf_core::GreenAmptInfiltration::set_tracer_filter "def +set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::GreenAmptInfiltration::short_string "def short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::GreenAmptInfiltration::to_string "def to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + +%feature("docstring") cmf_core::GreenAmptInfiltration::use_for_cell "def use_for_cell(args, kwargs) + +use_for_cell(Cell c) "; + + +// File: classcmf_1_1upslope_1_1connections_1_1_green_ampt_infiltration.xml +%feature("docstring") cmf::upslope::connections::GreenAmptInfiltration +" + +Connects the surfacewater and the most upper layer using a Green-Ampt +equation like infiltration. + +The Green-Ampt formula is given as: + +.. math:: + + q(t) = -K_s \\\\frac{dh}{dz} + A + +where: :math:`q(t)` is the infiltration rate in m3/day + +:math:`K_s` is the saturated conductivity in m/day + +:math:`\\\\frac{dh}{dz}` is the hydraulic gradient in the wetting front + +:math:`A` is the surface area of the cell + +The gradient in the wetting front is calculated as: + + +.. math:: + + \\\\frac{dh}{dz} = \\\\frac{h_f - h_0}{Z_f} = + \\\\frac{|\\\\Psi_f| + Z_f}{Z_f} + +where: :math:`h_f` is the hydraulic +head at the bottom of the wetting front in m + +:math:`h_0` is the hydraulic head at the surface in m + +:math:`Z_f` is the length of the wetting front in m + +Since :math:`Z_f` is unknown, the depth of the wetting front can be +approximated by: + +.. math:: + + Z_f = \\\\frac{F}{\\\\theta_s - + \\\\theta_i} + +with: :math:`F` the accumulated volume per area of +infiltrated water + +:math:`\\\\theta_s, \\\\theta_i` the volumetric water content at saturation +resp. at start of the infiltration + +If the surface water is modeled by a distinct water storage, the +actual infiltration is given as the product of the potential +infiltration with the coverage of the surface water +cmf::upslope::Cell::surface_water_coverage + +.. math:: + + q_{act} = q_{max} + \\\\frac{A_{water}}{A_{cell}} + +If the surface water is no storage on its own, but just a water +distribution node, the actual infiltration is the minimum of the +potential infiltration and the current inflow (rain, snow melt) to the +surface + +.. math:: + + q_{act} = \\\\min\\\\left(q_{max}, + \\\\sum{q_{in,surfacewater}}\\\\right) + +C++ includes: infiltration.h "; + +%feature("docstring") +cmf::upslope::connections::GreenAmptInfiltration::GreenAmptInfiltration +"GreenAmptInfiltration(cmf::upslope::SoilLayer::ptr soilwater, +cmf::water::flux_node::ptr surfacewater) "; + +%feature("docstring") +cmf::upslope::connections::GreenAmptInfiltration::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") +cmf::upslope::connections::GreenAmptInfiltration::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr +newTarget) "; + +%feature("docstring") +cmf::upslope::connections::GreenAmptInfiltration::get_ptr "ptr +get_ptr() const "; + +%feature("docstring") +cmf::upslope::connections::GreenAmptInfiltration::get_target "flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") +cmf::upslope::connections::GreenAmptInfiltration::get_target "flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") +cmf::upslope::connections::GreenAmptInfiltration::get_tracer_filter "real get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::GreenAmptInfiltration::get_tracer_filter "real get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") +cmf::upslope::connections::GreenAmptInfiltration::kill_me "bool +kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") +cmf::upslope::connections::GreenAmptInfiltration::left_node "flux_node::ptr left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") +cmf::upslope::connections::GreenAmptInfiltration::q "real q(const +flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") +cmf::upslope::connections::GreenAmptInfiltration::refresh "void +refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") +cmf::upslope::connections::GreenAmptInfiltration::right_node "flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") +cmf::upslope::connections::GreenAmptInfiltration::set_tracer_filter "void set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::GreenAmptInfiltration::set_tracer_filter "void set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf::upslope::connections::GreenAmptInfiltration::short_string "virtual std::string short_string() const "; + +%feature("docstring") +cmf::upslope::connections::GreenAmptInfiltration::to_string "virtual +std::string to_string() const "; + + +// File: classcmf__core_1_1_hargreave_e_t.xml +%feature("docstring") cmf_core::HargreaveET " + +Calculates the Evapotranspiration using Hargreave's equation. .. +math:: ET_{rc} = 0.0135 K_T\\\\\\\\ s_0 +\\\\\\\\sqrt{\\\\\\\\Delta T} (T + 17.8) where: :math:`ET_{rc}` +the reference crop evapotranspiration in mm/day :math:`K_T = +0.00185{\\\\\\\\Delta T}^2 - 0.0433 \\\\\\\\Delta T + 0.4023` +Continentality factor as given in the reference :math:`\\\\\\\\Delta +T = |T_{max} - T_{min}|[K]` Daily temperature range :math:`T +[^\\\\\\\\circ C]` daily mean temperature :math:`s_0 = 15.392 d_r +\\\\\\\\left(\\\\\\\\omega_s\\\\\\\\sin(\\\\\\\\Phi) +\\\\\\\\sin{\\\\\\\\gamma} + +\\\\\\\\cos{\\\\\\\\Phi}\\\\\\\\cos{\\\\\\\\gamma} * +\\\\\\\\sin(\\\\\\\\omega_s)\\\\\\\\right)` the extraterrestrial solar +radiation in mm/day :math:`d_r = 1 + 0.0033 +\\\\\\\\cos(DOY\\\\\\\\frac{2 \\\\\\\\pi}{365})` relative distance +between earth and sun :math:`\\\\\\\\omega_s = +\\\\\\\\arccos(-\\\\\\\\tan{\\\\\\\\Phi} \\\\\\\\tan{\\\\\\\\gamma})` +sunset hour angle (radians) :math:`\\\\\\\\gamma = 0.4039 +\\\\\\\\sin(DOY\\\\\\\\frac{2 \\\\\\\\pi}{365} - 1.405)` solar +declination (radians) :math:`\\\\\\\\Phi` geographic latitude +(radians) See: SAMANI, Zohrab.Estimating solar radiation and +evapotranspiration using minimum climatological data. Journal of +Irrigation and Drainage Engineering, 2000, 126. Jg., Nr. 4, S. +265-267. Crop specific potential evapotranspiration is scaled by LAI: +:math:`ET_{pot} = ET_{rc} \\\\\\\\frac{LAI}{2.88}`. C++ includes: +ET.h "; + +%feature("docstring") cmf_core::HargreaveET::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::ET::HargreaveET self, +cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr +ET_target, real latitude=51.0) -> HargreaveET +HargreaveET(cmf::upslope::SoilLayer::ptr source, +cmf::water::flux_node::ptr ET_target, real latitude=51.0) "; + +%feature("docstring") cmf_core::HargreaveET::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::HargreaveET::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::HargreaveET::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::HargreaveET::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::HargreaveET::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::HargreaveET::conc "def conc(self, +args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") cmf_core::HargreaveET::ETpot "def ETpot(self, +args, kwargs) + +ETpot(stressedET self, Time t) -> real virtual real +ETpot(cmf::math::Time t) const "; + +%feature("docstring") cmf_core::HargreaveET::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::HargreaveET::get_layer "def +get_layer(self, args, kwargs) + +get_layer(stressedET self) -> cmf::upslope::SoilLayer::ptr +SoilLayer::ptr get_layer() const "; + +%feature("docstring") cmf_core::HargreaveET::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::HargreaveET::get_tracer_filter "def +get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::HargreaveET::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::HargreaveET::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::HargreaveET::q "def q(self, args, +kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::HargreaveET::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::HargreaveET::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::HargreaveET::set_stressfunction "def +set_stressfunction(self, args, kwargs) + +set_stressfunction(stressedET self, RootUptakeStessFunction +stressfunction) void set_stressfunction(const RootUptakeStessFunction +&stressfunction) Sets the stress function to limit water uptake. "; + +%feature("docstring") cmf_core::HargreaveET::set_tracer_filter "def +set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::HargreaveET::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::HargreaveET::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + +%feature("docstring") cmf_core::HargreaveET::use_for_cell "def +use_for_cell(args, kwargs) + +use_for_cell(Cell cell) "; + + +// File: classcmf_1_1upslope_1_1_e_t_1_1_hargreave_e_t.xml +%feature("docstring") cmf::upslope::ET::HargreaveET " + +Calculates the Evapotranspiration using Hargreave's equation. + + + +.. math:: + + ET_{rc} = 0.0135 K_T\\\\ s_0 \\\\sqrt{\\\\Delta T} (T + + 17.8) + +where: :math:`ET_{rc}` the reference crop evapotranspiration +in mm/day + +:math:`K_T = 0.00185{\\\\Delta T}^2 - 0.0433 \\\\Delta T + 0.4023` +Continentality factor as given in the reference + +:math:`\\\\Delta T = |T_{max} - T_{min}|[K]` Daily temperature range + +:math:`T [^\\\\circ C]` daily mean temperature + +:math:`s_0 = 15.392 d_r \\\\left(\\\\omega_s\\\\sin(\\\\Phi) \\\\sin{\\\\gamma} + \\\\cos{\\\\Phi}\\\\cos{\\\\gamma} * \\\\sin(\\\\omega_s)\\\\right)` the extraterrestrial solar radiation +in mm/day + +:math:`d_r = 1 + 0.0033 \\\\cos(DOY\\\\frac{2 \\\\pi}{365})` relative +distance between earth and sun + +:math:`\\\\omega_s = \\\\arccos(-\\\\tan{\\\\Phi} \\\\tan{\\\\gamma})` +sunset hour angle (radians) + +:math:`\\\\gamma = 0.4039 \\\\sin(DOY\\\\frac{2 \\\\pi}{365} - 1.405)` +solar declination (radians) + +:math:`\\\\Phi` geographic latitude (radians) + +See: SAMANI, Zohrab.Estimating solar radiation and evapotranspiration +using minimum climatological data. Journal of Irrigation and Drainage +Engineering, 2000, 126. Jg., Nr. 4, S. 265-267. Crop specific +potential evapotranspiration is scaled by LAI: :math:`ET_{pot} = ET_{rc} \\\\frac{LAI}{2.88}`. + +C++ includes: ET.h "; + +%feature("docstring") cmf::upslope::ET::HargreaveET::HargreaveET "HargreaveET(cmf::upslope::SoilLayer::ptr source, +cmf::water::flux_node::ptr ET_target, real latitude=51.0) "; + +%feature("docstring") cmf::upslope::ET::HargreaveET::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") cmf::upslope::ET::HargreaveET::ETpot "real +ETpot(cmf::math::Time t) const "; + +%feature("docstring") cmf::upslope::ET::HargreaveET::exchange_target +"void exchange_target(flux_node::ptr oldtarget, flux_node::ptr +newTarget) "; + +%feature("docstring") cmf::upslope::ET::HargreaveET::get_layer "SoilLayer::ptr get_layer() const "; + +%feature("docstring") cmf::upslope::ET::HargreaveET::get_ptr "ptr +get_ptr() const "; + +%feature("docstring") cmf::upslope::ET::HargreaveET::get_target "flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") cmf::upslope::ET::HargreaveET::get_target "flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") +cmf::upslope::ET::HargreaveET::get_tracer_filter "real +get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::ET::HargreaveET::get_tracer_filter "real +get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") cmf::upslope::ET::HargreaveET::kill_me "bool +kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") cmf::upslope::ET::HargreaveET::left_node "flux_node::ptr left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") cmf::upslope::ET::HargreaveET::q "real q(const +flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") cmf::upslope::ET::HargreaveET::refresh "void +refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") cmf::upslope::ET::HargreaveET::right_node "flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") +cmf::upslope::ET::HargreaveET::set_stressfunction "void +set_stressfunction(const RootUptakeStessFunction &stressfunction) + +Sets the stress function to limit water uptake. "; + +%feature("docstring") +cmf::upslope::ET::HargreaveET::set_tracer_filter "void +set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::ET::HargreaveET::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf::upslope::ET::HargreaveET::short_string "virtual std::string short_string() const "; + +%feature("docstring") cmf::upslope::ET::HargreaveET::to_string "std::string to_string() const "; + + +// File: classcmf__core_1_1_heun_integrator.xml +%feature("docstring") cmf_core::HeunIntegrator " + +A simple predictor - corrector solver. Not tested and very +experimentally :math:`y^{n+1} = y^n + \\\\\\\\alpha f(y^n + +f(y^n)dt)dt + (1-\\\\\\\\alpha)f(y^n)dt` C++ includes: +explicit_euler.h "; + +%feature("docstring") cmf_core::HeunIntegrator::__init__ "def +__init__(self, args) + +__init__(cmf::math::HeunIntegrator self, StateVariableOwner states, +real Alpha=0.5) -> HeunIntegrator __init__(cmf::math::HeunIntegrator +self, real Alpha=0.5) -> HeunIntegrator +__init__(cmf::math::HeunIntegrator self, Integrator copy) -> +HeunIntegrator HeunIntegrator(const Integrator ©) copy +constructor "; + +%feature("docstring") cmf_core::HeunIntegrator::__call__ "def +__call__(self, t, dt=None, reset=False) + +Advances the integration until `t` A shortcut to .integrate_until +Parameters ---------- t : cmf.Time The time step to advance to. If +t < current time, the solver will advance to self.t + t dt : +cmf.Time, optional The timestep for the integration. If not given +try to integrate in one step reset : bool, optional If True, the +solver will perform a reset before starting Returns ------- cmf.Time +The new time stamp "; + +%feature("docstring") cmf_core::HeunIntegrator::__getitem__ "def +__getitem__(self, args, kwargs) + +__getitem__(Integrator self, long position) -> +cmf::math::StateVariable::ptr "; + +%feature("docstring") cmf_core::HeunIntegrator::__len__ "def +__len__(self, args, kwargs) + +__len__(Integrator self) -> size_t "; + +%feature("docstring") cmf_core::HeunIntegrator::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::HeunIntegrator::add_single_state "def add_single_state(self, args, kwargs) + +add_single_state(Integrator self, cmf::math::StateVariable::ptr state) +virtual void add_single_state(cmf::math::StateVariable::ptr state) +Adds a single state variable to the integrator. "; + +%feature("docstring") cmf_core::HeunIntegrator::add_states "def +add_states(self, args, kwargs) + +add_states(Integrator self, StateVariableOwner stateOwner) virtual +void add_states(cmf::math::StateVariableOwner &stateOwner) Add state +variables from a StateVariableOwner. "; + +%feature("docstring") cmf_core::HeunIntegrator::copy "def copy(self, +args, kwargs) + +copy(Integrator self) -> Integrator virtual Integrator* copy() const +=0 Polymorphic copy constructor. "; + +%feature("docstring") cmf_core::HeunIntegrator::get_dt "def +get_dt(self, args, kwargs) + +get_dt(Integrator self) -> Time cmf::math::Time get_dt() const +Returns the last time step. "; + +%feature("docstring") cmf_core::HeunIntegrator::get_dxdt "def +get_dxdt(self, args, kwargs) + +get_dxdt(Integrator self, Time time) -> cmf::math::num_array +cmf::math::num_array get_dxdt(Time time) const "; + +%feature("docstring") cmf_core::HeunIntegrator::get_state "def +get_state(self, args, kwargs) + +get_state(Integrator self, ptrdiff_t position) -> real real +get_state(ptrdiff_t position) const Returns the statevariable at +position Simplifies the assessment of state variables. "; + +%feature("docstring") cmf_core::HeunIntegrator::get_states "def +get_states(self, args) + +get_states(Integrator self) -> cmf::math::num_array +get_states(Integrator self) -> StateVariableList StateVariableList +get_states() gets the state variables of the integrator "; + +%feature("docstring") cmf_core::HeunIntegrator::get_t "def +get_t(self, args, kwargs) + +get_t(Integrator self) -> Time cmf::math::Time get_t() const Returns +the current model time. "; + +%feature("docstring") cmf_core::HeunIntegrator::integrate "def +integrate(self, args, kwargs) + +integrate(Integrator self, Time t_max, Time dt) -> int virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt)=0 Integrates the +vector of state variables. Parameters: ----------- t_max: To stop +the model (if running in a model framework) at time steps of value +exchange e.g. full hours, the next value exchange time can be given +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; + +%feature("docstring") cmf_core::HeunIntegrator::integrate_until "def +integrate_until(self, args, kwargs) + +integrate_until(Integrator self, Time t_max, Time dt, bool +reset=False) void integrate_until(cmf::math::Time t_max, +cmf::math::Time dt=Time(), bool reset=false) Integrates the vector of +state variables until t_max. Parameters: ----------- t_max: Time, +the solver should run to dt: Time step (may be omitted) reset: If +true, solver is reseted before integration starts "; + +%feature("docstring") cmf_core::HeunIntegrator::reset "def +reset(self, args, kwargs) + +reset(Integrator self) virtual void reset() Resets any saved history +(for multistep methods) "; + +%feature("docstring") cmf_core::HeunIntegrator::run "def run(self, +start=None, end=None, step=day *1, max_errors=0, reset=False) + +Returns an iterator over the timesteps start..end **Examples:** >>> +solver=cmf.CVodeIntegrator(...) >>> for t in solver.run(solver.t, +solver.t + cmf.week, cmf.h): >>> print(t, solver[0].state) or with +list comprehension >>> states = [solver[0].state for t in +solver.run(solver.t, solver.t + cmf.week, cmf.h)] Parameters +---------- start : cmf.Time, optional Start time for the solver +iteration end : cmf.Time, optional End time of the iteration step : +cmf.Time, optional Step size for the integration max_errors: int +Number of tolerated errors. If >0, up to these number of runtime +errors will be saved with their time and the integration proceeds +after a reset of the solver. Some systems operate with values close to +their physical limits and inifinite values in the integration can +easily occur. For these kind of systems set max_errors to eg. 10. A +larger number of errors should be eliminated usually. reset: bool If +True, the solver performs a `reset` at every time step Yields ------ +cmf.Time the actual timestep "; + +%feature("docstring") cmf_core::HeunIntegrator::set_state "def +set_state(self, args, kwargs) + +set_state(Integrator self, ptrdiff_t position, real newState) void +set_state(ptrdiff_t position, real newState) Simplifies the +assessment of state variables. "; + +%feature("docstring") cmf_core::HeunIntegrator::set_t "def +set_t(self, args, kwargs) + +set_t(Integrator self, Time val) void set_t(cmf::math::Time val) Sets +the current model time. "; + +%feature("docstring") cmf_core::HeunIntegrator::size "def size(self, +args, kwargs) + +size(Integrator self) -> size_t size_t size() const returns the +number of state variables "; + + +// File: classcmf_1_1math_1_1_heun_integrator.xml +%feature("docstring") cmf::math::HeunIntegrator " + +A simple predictor - corrector solver. + +Not tested and very experimentally :math:`y^{n+1} = y^n + \\\\alpha f(y^n + f(y^n)dt)dt + (1-\\\\alpha)f(y^n)dt` + +C++ includes: explicit_euler.h "; + +/* Accuracy parameters */ + +/* model time */ + +%feature("docstring") cmf::math::HeunIntegrator::get_t "cmf::math::Time get_t() const + +Returns the current model time. "; + +%feature("docstring") cmf::math::HeunIntegrator::set_t "void +set_t(cmf::math::Time val) + +Sets the current model time. "; + +%feature("docstring") cmf::math::HeunIntegrator::get_dt "cmf::math::Time get_dt() const + +Returns the last time step. "; + +%feature("docstring") cmf::math::HeunIntegrator::reset "virtual void +reset() + +Resets any saved history (for multistep methods) "; + +/* Integrate */ + +%feature("docstring") cmf::math::HeunIntegrator::integrate_until "void integrate_until(cmf::math::Time t_max, cmf::math::Time dt=Time(), +bool reset=false) + +Integrates the vector of state variables until t_max. + +Parameters: +----------- + +t_max: Time, the solver should run to + +dt: Time step (may be omitted) + +reset: If true, solver is reseted before integration starts "; + +%feature("docstring") cmf::math::HeunIntegrator::HeunIntegrator "HeunIntegrator(StateVariableOwner &states, real Alpha=0.5) + +Constructs a new PredictCorrectSimple from a pointer to a vector of +state variables. + +The Integrator becomes the owner of states + +Parameters: +----------- + +states: Statevariable owner of the system + +Alpha: Weight factor :math:`\\\\alpha` to weight :math:`f(y^n)` and :math:`f(y^{n+1})` +"; + +%feature("docstring") cmf::math::HeunIntegrator::HeunIntegrator "HeunIntegrator(real Alpha=0.5) + +Constructs a new PredictCorrectSimple. + +Parameters: +----------- + +Alpha: Weight factor :math:`\\\\alpha` to weight :math:`f(y^n)` and :math:`f(y^{n+1})` +"; + +%feature("docstring") cmf::math::HeunIntegrator::HeunIntegrator "HeunIntegrator(const Integrator ©) + +copy constructor "; + +%feature("docstring") cmf::math::HeunIntegrator::~HeunIntegrator "virtual ~HeunIntegrator() "; + +%feature("docstring") cmf::math::HeunIntegrator::add_single_state "virtual void add_single_state(cmf::math::StateVariable::ptr state) + +Adds a single state variable to the integrator. "; + +%feature("docstring") cmf::math::HeunIntegrator::add_states "void +add_states(cmf::math::StateVariableOwner &stateOwner) + +Add state variables from a StateVariableOwner. "; + +%feature("docstring") cmf::math::HeunIntegrator::add_values_to_states +"void add_values_to_states(const num_array &operands) + +Adds the values in operands to the current states. "; + +%feature("docstring") cmf::math::HeunIntegrator::copy "virtual +Integrator* copy() const + +Polymorphic copy constructor. "; + +%feature("docstring") cmf::math::HeunIntegrator::copy_dxdt "void +copy_dxdt(Time time, num_array &destination, real factor=1) const + +Copies the derivatives at time step \"time\" to a numeric vector using +use_OpenMP. + +Parameters: +----------- + +time: Time at which the derivatives should be calculated + +destination: Vector to be overwritten by the results + +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; + +%feature("docstring") cmf::math::HeunIntegrator::copy_dxdt "void +copy_dxdt(Time time, real *destination, real factor=1) const + +Copies the derivatives at time step \"time\" to an preallocated c +array. + +Parameters: +----------- + +time: Time at which the derivatives should be calculated + +destination: Allocated c array + +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; + +%feature("docstring") cmf::math::HeunIntegrator::copy_states "void +copy_states(num_array &destination) const + +Copies the states to a numeric vector using use_OpenMP. "; + +%feature("docstring") cmf::math::HeunIntegrator::copy_states "void +copy_states(real *destination) const "; + +%feature("docstring") cmf::math::HeunIntegrator::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; + +%feature("docstring") cmf::math::HeunIntegrator::get_state "real +get_state(ptrdiff_t position) const + +Returns the statevariable at position Simplifies the assessment of +state variables. "; + +%feature("docstring") cmf::math::HeunIntegrator::get_states "cmf::math::num_array get_states() const "; + +%feature("docstring") cmf::math::HeunIntegrator::get_states "StateVariableList get_states() + +gets the state variables of the integrator "; + +%feature("docstring") cmf::math::HeunIntegrator::integrate "int +integrate(cmf::math::Time MaxTime, cmf::math::Time TimeStep) + +Integrates the vector of state variables. + +Parameters: +----------- + +MaxTime: (ignored) To stop the model (if running in a model +framework) at time steps of value exchange e.g. full hours, the next +value exchange time can be given + +TimeStep: Takes the proposed time step "; + +%feature("docstring") cmf::math::HeunIntegrator::set_state "void +set_state(ptrdiff_t position, real newState) + +Simplifies the assessment of state variables. "; + +%feature("docstring") cmf::math::HeunIntegrator::set_states "void +set_states(const num_array &newStates) + +Copies the new states to the actual states. "; + +%feature("docstring") cmf::math::HeunIntegrator::set_states "void +set_states(real *newStates) "; + +%feature("docstring") cmf::math::HeunIntegrator::size "size_t size() +const + +returns the number of state variables "; + + +// File: classcmf_1_1draw_1_1hillplot_1_1_hill_plot.xml +%feature("docstring") cmf::draw::hillplot::HillPlot " + +Plots a hillslope using colored sheared rectangles for each layer and +arrows (matplotlib.quiver) to show fluxes. Properties: - +evalfunction: a function returning the value of a layer to plot. The +value should be a float between 0..1 for scaling. The default is: +lambda l: l.wetness - q_sub: The matplotlib.Quiver object for +subsurface fluxes - q_surf: The matplotlib.Quiver object for +subsurface fluxes - title: Title of the plot - scale: The scale of +q_sub and q_surf "; + +%feature("docstring") cmf::draw::hillplot::HillPlot::__init__ "def +__init__(self, cells, t, solute=None, cmap=default_color_map) + +Creates a new HillPlot on the active figure, showing the state of each +layer - cells: The a sequence of cmf cells to use in this hill_plot. +You can use the whole project if you like - t: Current time +step. Needed to retrieve the fluxes - solute:The solute concentration +to show. If None, the wetness of the layer will be shown - cmap: a +matplotlib colormap (see module cm) for coloring "; + +%feature("docstring") cmf::draw::hillplot::HillPlot::__call__ "def +__call__(self, t, text='') + +Updates the hill_plot at time t. You can provide a title for the +figure. If bool(title)==False, t is shown. "; + +%feature("docstring") cmf::draw::hillplot::HillPlot::get_animator "def get_animator(self, integration) + +Returns a matplotlib.animation.FuncAnimator object that uses the +integration iteratable to advance your model to animate the HillPlot +Usage example: >>>p=cmf.project() >>>solver = cmf.CVodeIntegrator(p, +1e-9) >>>hp = HillPlot(p, solver.t) >>>animator = +hp.get_animator(solver.run(datetime(2012, 1, 1), datetime(2012, 2, 1), +timedelta(hours=1))) :param integration: An iterable that advances +the model and yields the current time :return: A +matplotlib.animation.FuncAnimator "; + + +// File: classcmf_1_1river_1_1_i_channel.xml +%feature("docstring") cmf::river::IChannel " + +Structure for the description of structural parameters of a reach +Abstract base class for different IChannel geometries. + +C++ includes: ReachType.h "; + +%feature("docstring") cmf::river::IChannel::~IChannel "virtual +~IChannel() "; + +%feature("docstring") cmf::river::IChannel::A "virtual double +A(double V) const + +Returns the area of the surface for a given volume. "; + +%feature("docstring") cmf::river::IChannel::copy "virtual IChannel* +copy() const =0 "; + +%feature("docstring") cmf::river::IChannel::get_channel_width "virtual double get_channel_width(double depth) const =0 + +Calculates the flow width from a given actual depth [m] using the +actual IChannel geometry. "; + +%feature("docstring") cmf::river::IChannel::get_depth "virtual +double get_depth(double area) const =0 + +Calculates the actual depth of the reach using the IChannel geometry. + +get_depth of the reach [m] + +Parameters: +----------- + +area: Wetted area of a river cross section [m2], can be obtained by +V/l, where V is the stored volume and l is the reach length "; + +%feature("docstring") cmf::river::IChannel::get_flux_crossection "virtual double get_flux_crossection(double depth) const =0 + +Calculates the wetted area from a given depth using the IChannel +geometry. + +In most cases use get_flux_crossection=V/l, where V is the stored +volume and l is the reach length Wetted area of a river cross section +[m2] + +Parameters: +----------- + +depth: depth of the reach [m] "; + +%feature("docstring") cmf::river::IChannel::get_length "virtual +double get_length() const =0 + +Length of the reach. "; + +%feature("docstring") cmf::river::IChannel::get_nManning "virtual +double get_nManning() const =0 "; + +%feature("docstring") cmf::river::IChannel::get_wetted_perimeter "virtual double get_wetted_perimeter(double depth) const =0 + +Calculates the wetted perimeter from a given actual depth [m] using +the actual IChannel geometry. "; + +%feature("docstring") cmf::river::IChannel::h "virtual double +h(double V) const + +Returns the depth of a given volume. "; + +%feature("docstring") cmf::river::IChannel::q "virtual double +q(double h, double slope) const "; + +%feature("docstring") cmf::river::IChannel::qManning "virtual double +qManning(double A, double slope) const + +Calculates the flow rate from a given water volume in the reach + + +.. math:: + + q_{Manning}&=& A R^{\\\\frac 2 3} + \\\\sqrt{\\\\frac {\\\\Delta_z} n} \\\\\\\\ A &=& \\\\frac V l + \\\\mbox{, (Crosssectional area of the wetted crossection, Volume per + length)} \\\\\\\\ R &=& \\\\frac A {P(d)} \\\\\\\\ P(d) &=& \\\\mbox{ + the perimeter of the wetted crosssection, a function of reach depth} + \\\\\\\\ d(V) &=& \\\\mbox{ the depth of the reach a function of the + volume} \\\\\\\\ \\\\Delta_z &=& \\\\frac{z_{max} - z_{min}}{l} + \\\\mbox{ Slope of the reach} + +. + +Flow rate [m3/s] + +Parameters: +----------- + +A: The area of the cross section [m2] + +slope: The slope of the reach [m/m] "; + +%feature("docstring") cmf::river::IChannel::set_nManning "virtual +void set_nManning(double val)=0 "; + +%feature("docstring") cmf::river::IChannel::typecode "virtual char +typecode() const =0 "; + +%feature("docstring") cmf::river::IChannel::V "virtual double +V(double h) const "; + + +// File: classcmf__core_1_1_i_channel.xml +%feature("docstring") cmf_core::IChannel " + +Structure for the description of structural parameters of a reach +Abstract base class for different IChannel geometries. C++ includes: +ReachType.h "; + +%feature("docstring") cmf_core::IChannel::__init__ "def +__init__(self, args, kwargs) "; + +%feature("docstring") cmf_core::IChannel::A "def A(self, args, +kwargs) + +A(IVolumeHeightFunction self, double V) -> double virtual double +A(double V) const =0 Returns the area of the surface for a given +volume. "; + +%feature("docstring") cmf_core::IChannel::copy "def copy(self, args, +kwargs) + +copy(IChannel self) -> IChannel virtual IChannel* copy() const =0 "; + +%feature("docstring") cmf_core::IChannel::get_channel_width "def +get_channel_width(self, args, kwargs) + +get_channel_width(IChannel self, double depth) -> double virtual +double get_channel_width(double depth) const =0 Calculates the flow +width from a given actual depth [m] using the actual IChannel +geometry. "; + +%feature("docstring") cmf_core::IChannel::get_depth "def +get_depth(self, args, kwargs) + +get_depth(IChannel self, double area) -> double virtual double +get_depth(double area) const =0 Calculates the actual depth of the +reach using the IChannel geometry. get_depth of the reach [m] +Parameters: ----------- area: Wetted area of a river cross section +[m2], can be obtained by V/l, where V is the stored volume and l is +the reach length "; + +%feature("docstring") cmf_core::IChannel::get_flux_crossection "def +get_flux_crossection(self, args, kwargs) + +get_flux_crossection(IChannel self, double depth) -> double virtual +double get_flux_crossection(double depth) const =0 Calculates the +wetted area from a given depth using the IChannel geometry. In most +cases use get_flux_crossection=V/l, where V is the stored volume and l +is the reach length Wetted area of a river cross section [m2] +Parameters: ----------- depth: depth of the reach [m] "; + +%feature("docstring") cmf_core::IChannel::get_length "def +get_length(self, args, kwargs) + +get_length(IChannel self) -> double virtual double get_length() const +=0 Length of the reach. "; + +%feature("docstring") cmf_core::IChannel::get_nManning "def +get_nManning(self, args, kwargs) + +get_nManning(IChannel self) -> double virtual double get_nManning() +const =0 "; + +%feature("docstring") cmf_core::IChannel::get_wetted_perimeter "def +get_wetted_perimeter(self, args, kwargs) + +get_wetted_perimeter(IChannel self, double depth) -> double virtual +double get_wetted_perimeter(double depth) const =0 Calculates the +wetted perimeter from a given actual depth [m] using the actual +IChannel geometry. "; + +%feature("docstring") cmf_core::IChannel::h "def h(self, args, +kwargs) + +h(IVolumeHeightFunction self, double V) -> double virtual double +h(double V) const =0 Returns the depth of a given volume. "; + +%feature("docstring") cmf_core::IChannel::q "def q(self, args, +kwargs) + +q(IVolumeHeightFunction self, double h, double slope) -> double +virtual double q(double h, double slope) const "; + +%feature("docstring") cmf_core::IChannel::qManning "def +qManning(self, args, kwargs) + +qManning(IChannel self, double A, double slope) -> double virtual +double qManning(double A, double slope) const Calculates the flow +rate from a given water volume in the reach .. math:: q_{Manning}&=& +A R^{\\\\\\\\frac 2 3} \\\\\\\\sqrt{\\\\\\\\frac {\\\\\\\\Delta_z} +n} \\\\\\\\\\\\\\\\ A &=& \\\\\\\\frac V l \\\\\\\\mbox{, +(Crosssectional area of the wetted crossection, Volume per +length)} \\\\\\\\\\\\\\\\ R &=& \\\\\\\\frac A {P(d)} \\\\\\\\\\\\\\\\ +P(d) &=& \\\\\\\\mbox{ the perimeter of the wetted crosssection, a +function of reach depth} \\\\\\\\\\\\\\\\ d(V) &=& \\\\\\\\mbox{ +the depth of the reach a function of the volume} \\\\\\\\\\\\\\\\ +\\\\\\\\Delta_z &=& \\\\\\\\frac{z_{max} - z_{min}}{l} +\\\\\\\\mbox{ Slope of the reach} . Flow rate [m3/s] Parameters: +----------- A: The area of the cross section [m2] slope: The slope +of the reach [m/m] "; + +%feature("docstring") cmf_core::IChannel::set_nManning "def +set_nManning(self, args, kwargs) + +set_nManning(IChannel self, double val) virtual void +set_nManning(double val)=0 "; + +%feature("docstring") cmf_core::IChannel::typecode "def +typecode(self, args, kwargs) + +typecode(IChannel self) -> char virtual char typecode() const =0 "; + +%feature("docstring") cmf_core::IChannel::V "def V(self, args, +kwargs) + +V(IVolumeHeightFunction self, double h) -> double virtual double +V(double h) const =0 "; + + +// File: classcmf_1_1atmosphere_1_1_i_d_w___meteorology.xml +%feature("docstring") cmf::atmosphere::IDW_Meteorology " + +Regionalizes meteorological measurements using a simple inverse +distance weighted (IDW) method. + +See: IDW + +C++ includes: meteorology.h "; + +%feature("docstring") +cmf::atmosphere::IDW_Meteorology::IDW_Meteorology "IDW_Meteorology(const cmf::geometry::point &position, const +MeteoStationList &stations, double z_weight, double power) + +Creates an reference to a list of stations and interpolates the +weather using IDW. + +Parameters: +----------- + +position: Position of reference + +stations: Meteo stations + +z_weight: Weight of height in IDW procedure + +power: Power of IDW procedure "; + +%feature("docstring") +cmf::atmosphere::IDW_Meteorology::IDW_Meteorology "IDW_Meteorology(const IDW_Meteorology ©) + +Copy c'tor. "; + +%feature("docstring") cmf::atmosphere::IDW_Meteorology::copy "virtual IDW_Meteorology* copy() const + +Returns a copy of the meteorology object. Pure virtual function, needs +to be implemented. "; + +%feature("docstring") +cmf::atmosphere::IDW_Meteorology::get_instrument_height "virtual real +get_instrument_height() const + +Returns the height of the instruments above canopy. "; + +%feature("docstring") cmf::atmosphere::IDW_Meteorology::get_weather "virtual Weather get_weather(cmf::math::Time t) const + +Returns the Weather at time t. Pure virtual function. Must get +implemented by child functions. "; + + +// File: classcmf__core_1_1_i_d_w___meteorology.xml +%feature("docstring") cmf_core::IDW_Meteorology " + +Regionalizes meteorological measurements using a simple inverse +distance weighted (IDW) method. See: IDW C++ includes: +meteorology.h "; + +%feature("docstring") cmf_core::IDW_Meteorology::__init__ "def +__init__(self, args) + +__init__(cmf::atmosphere::IDW_Meteorology self, point position, +MeteoStationList stations, double z_weight, double power) -> +IDW_Meteorology __init__(cmf::atmosphere::IDW_Meteorology self, +IDW_Meteorology copy) -> IDW_Meteorology IDW_Meteorology(const +IDW_Meteorology ©) Copy c'tor. "; + +%feature("docstring") cmf_core::IDW_Meteorology::__call__ "def +__call__(self, args, kwargs) + +__call__(Meteorology self, Time t) -> Weather "; + +%feature("docstring") cmf_core::IDW_Meteorology::copy "def +copy(self, args, kwargs) + +copy(IDW_Meteorology self) -> IDW_Meteorology virtual +IDW_Meteorology* copy() const Returns a copy of the meteorology +object. Pure virtual function, needs to be implemented. "; + +%feature("docstring") +cmf_core::IDW_Meteorology::get_instrument_height "def +get_instrument_height(self, args, kwargs) + +get_instrument_height(Meteorology self) -> real virtual real +get_instrument_height() const =0 Returns the height of the +instruments above canopy. "; + +%feature("docstring") cmf_core::IDW_Meteorology::get_weather "def +get_weather(self, args, kwargs) + +get_weather(Meteorology self, Time t) -> Weather virtual +cmf::atmosphere::Weather get_weather(cmf::math::Time t) const =0 +Returns the Weather at time t. Pure virtual function. Must get +implemented by child functions. "; + + +// File: classcmf_1_1atmosphere_1_1_i_d_w_rainfall.xml +%feature("docstring") cmf::atmosphere::IDWRainfall " + +A RainSource using a spatially interpolated rainfall intensity from +all stations. + +Interpolation method is inverse distance weighted (IDW) + +C++ includes: precipitation.h "; + +%feature("docstring") cmf::atmosphere::IDWRainfall::conc "real +conc(cmf::math::Time t, const cmf::water::solute &Solute) const + +Returns the concentration of a solute in the rainfall at time t. "; + +%feature("docstring") cmf::atmosphere::IDWRainfall::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) + +Returns the connection between this and target. "; + +%feature("docstring") cmf::atmosphere::IDWRainfall::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; + +%feature("docstring") cmf::atmosphere::IDWRainfall::flux_to "real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) + +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; + +%feature("docstring") cmf::atmosphere::IDWRainfall::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) + +Returns the sum of all flux vectors. "; + +%feature("docstring") cmf::atmosphere::IDWRainfall::get_connections "cmf::water::connection_list get_connections() const "; + +%feature("docstring") cmf::atmosphere::IDWRainfall::get_intensity "real get_intensity(cmf::math::Time t) const + +Returns the actual rainfall intensity in mm/day. "; + +%feature("docstring") cmf::atmosphere::IDWRainfall::get_potential "virtual real get_potential() const + +Returns the water potential of the node in m waterhead. + +The base class water storage always returns the height of the location +"; + +%feature("docstring") cmf::atmosphere::IDWRainfall::get_project "cmf::project& get_project() const + +Returns the project, this node is part of. "; + +%feature("docstring") cmf::atmosphere::IDWRainfall::is_empty "virtual double is_empty() const + +Returns false. "; + +%feature("docstring") cmf::atmosphere::IDWRainfall::is_storage "virtual bool is_storage() const + +true, if this is a waterstorage "; + +%feature("docstring") cmf::atmosphere::IDWRainfall::RecalcFluxes "virtual bool RecalcFluxes(cmf::math::Time t) + +Pure flux_nodes do not influence fluxes, therefore no recalculation of +fluxes is required by flux_node. + +WaterStorage overrides this, since state changes require an update of +the fluxes "; + +%feature("docstring") cmf::atmosphere::IDWRainfall::remove_connection +"bool remove_connection(cmf::water::flux_node::ptr To) + +Remove the connection. "; + +%feature("docstring") cmf::atmosphere::IDWRainfall::set_potential "virtual void set_potential(real new_potential) + +Sets the potential of this flux node. "; + +%feature("docstring") cmf::atmosphere::IDWRainfall::to_string "virtual std::string to_string() const "; + +%feature("docstring") cmf::atmosphere::IDWRainfall::waterbalance "real waterbalance(cmf::math::Time t, const flux_connection *Without=0) +const + +Returns the sum of all fluxes (positive and negative) at time t. + +Single fluxes can be excluded from the calculation + +Parameters: +----------- + +t: Time of the query + +Without: A flux_connection that is excluded from the waterbalance +(e.g. to prevent closed circuits) "; + + +// File: classcmf__core_1_1_i_d_w_rainfall.xml +%feature("docstring") cmf_core::IDWRainfall " + +A RainSource using a spatially interpolated rainfall intensity from +all stations. Interpolation method is inverse distance weighted (IDW) +C++ includes: precipitation.h "; + +%feature("docstring") cmf_core::IDWRainfall::__init__ "def +__init__(self, args, kwargs) "; + +%feature("docstring") cmf_core::IDWRainfall::__call__ "def +__call__(self, args, kwargs) + +__call__(RainSource self, Time t) -> real "; + +%feature("docstring") cmf_core::IDWRainfall::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_node self, flux_node other) -> bool "; + +%feature("docstring") cmf_core::IDWRainfall::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::IDWRainfall::conc "def conc(self, +args, kwargs) + +conc(flux_node self, Time t, solute Solute) -> real virtual real +conc(cmf::math::Time t, const cmf::water::solute &Solute) const +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; + +%feature("docstring") cmf_core::IDWRainfall::connected_nodes "def +connected_nodes(self) "; + +%feature("docstring") cmf_core::IDWRainfall::connection_to "def +connection_to(self, args, kwargs) + +connection_to(flux_node self, flux_node target) -> flux_connection +cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) Returns the connection between this and target. "; + +%feature("docstring") cmf_core::IDWRainfall::create "def +create(args, kwargs) + +create(project project, point position, double z_weight, double power) +-> cmf::atmosphere::RainSource::ptr "; + +%feature("docstring") cmf_core::IDWRainfall::flux3d_to "def +flux3d_to(self, args, kwargs) + +flux3d_to(flux_node self, flux_node target, Time t) -> point +cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; + +%feature("docstring") cmf_core::IDWRainfall::flux_to "def +flux_to(self, args, kwargs) + +flux_to(flux_node self, flux_node target, Time t) -> real real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; + +%feature("docstring") cmf_core::IDWRainfall::fluxes "def +fluxes(self, t) "; + +%feature("docstring") cmf_core::IDWRainfall::get_3d_flux "def +get_3d_flux(self, args, kwargs) + +get_3d_flux(flux_node self, Time t) -> point cmf::geometry::point +get_3d_flux(cmf::math::Time t) Returns the sum of all flux vectors. +"; + +%feature("docstring") cmf_core::IDWRainfall::get_intensity "def +get_intensity(self, args, kwargs) + +get_intensity(RainSource self, Time t) -> real virtual real +get_intensity(cmf::math::Time t) const =0 Returns the actual rainfall +intensity in mm/day. "; + +%feature("docstring") cmf_core::IDWRainfall::is_empty "def +is_empty(self, args, kwargs) + +is_empty(flux_node self) -> double virtual double is_empty() const +Returns true if the node has no water. "; + +%feature("docstring") cmf_core::IDWRainfall::is_storage "def +is_storage(self, args, kwargs) + +is_storage(flux_node self) -> bool virtual bool is_storage() const +true, if this is a waterstorage "; + +%feature("docstring") cmf_core::IDWRainfall::RecalcFluxes "def +RecalcFluxes(self, args, kwargs) + +RecalcFluxes(flux_node self, Time t) -> bool virtual bool +RecalcFluxes(cmf::math::Time t) Pure flux_nodes do not influence +fluxes, therefore no recalculation of fluxes is required by flux_node. +WaterStorage overrides this, since state changes require an update of +the fluxes "; + +%feature("docstring") cmf_core::IDWRainfall::remove_connection "def +remove_connection(self, args, kwargs) + +remove_connection(flux_node self, cmf::water::flux_node::ptr To) -> +bool bool remove_connection(cmf::water::flux_node::ptr To) Remove +the connection. "; + +%feature("docstring") cmf_core::IDWRainfall::to_string "def +to_string(self, args, kwargs) + +to_string(flux_node self) -> std::string virtual std::string +to_string() const "; + +%feature("docstring") cmf_core::IDWRainfall::waterbalance "def +waterbalance(self, args, kwargs) + +waterbalance(flux_node self, Time t, flux_connection Without=None) -> +real real waterbalance(cmf::math::Time t, const flux_connection +*Without=0) const Returns the sum of all fluxes (positive and +negative) at time t. Single fluxes can be excluded from the +calculation Parameters: ----------- t: Time of the query Without: +A flux_connection that is excluded from the waterbalance (e.g. to +prevent closed circuits) "; + + +// File: classcmf__core_1_1_implicit_euler.xml +%feature("docstring") cmf_core::ImplicitEuler " + +An implicit (backward) Euler integrator using fixpoint iteration. C++ +includes: implicit_euler.h "; + +%feature("docstring") cmf_core::ImplicitEuler::__init__ "def +__init__(self, args) + +__init__(cmf::math::ImplicitEuler self, StateVariableOwner states, +real epsilon=1e-9, Time tStepMin) -> ImplicitEuler +__init__(cmf::math::ImplicitEuler self, real epsilon=1e-9, Time +tStepMin) -> ImplicitEuler __init__(cmf::math::ImplicitEuler self, +Integrator arg2) -> ImplicitEuler ImplicitEuler(const Integrator &) +copy constructor "; + +%feature("docstring") cmf_core::ImplicitEuler::__call__ "def +__call__(self, t, dt=None, reset=False) + +Advances the integration until `t` A shortcut to .integrate_until +Parameters ---------- t : cmf.Time The time step to advance to. If +t < current time, the solver will advance to self.t + t dt : +cmf.Time, optional The timestep for the integration. If not given +try to integrate in one step reset : bool, optional If True, the +solver will perform a reset before starting Returns ------- cmf.Time +The new time stamp "; + +%feature("docstring") cmf_core::ImplicitEuler::__getitem__ "def +__getitem__(self, args, kwargs) + +__getitem__(Integrator self, long position) -> +cmf::math::StateVariable::ptr "; + +%feature("docstring") cmf_core::ImplicitEuler::__len__ "def +__len__(self, args, kwargs) + +__len__(Integrator self) -> size_t "; + +%feature("docstring") cmf_core::ImplicitEuler::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::ImplicitEuler::add_single_state "def +add_single_state(self, args, kwargs) + +add_single_state(Integrator self, cmf::math::StateVariable::ptr state) +virtual void add_single_state(cmf::math::StateVariable::ptr state) +Adds a single state variable to the integrator. "; + +%feature("docstring") cmf_core::ImplicitEuler::add_states "def +add_states(self, args, kwargs) + +add_states(Integrator self, StateVariableOwner stateOwner) virtual +void add_states(cmf::math::StateVariableOwner &stateOwner) Add state +variables from a StateVariableOwner. "; + +%feature("docstring") cmf_core::ImplicitEuler::copy "def copy(self, +args, kwargs) + +copy(Integrator self) -> Integrator virtual Integrator* copy() const +=0 Polymorphic copy constructor. "; + +%feature("docstring") cmf_core::ImplicitEuler::get_dt "def +get_dt(self, args, kwargs) + +get_dt(Integrator self) -> Time cmf::math::Time get_dt() const +Returns the last time step. "; + +%feature("docstring") cmf_core::ImplicitEuler::get_dxdt "def +get_dxdt(self, args, kwargs) + +get_dxdt(Integrator self, Time time) -> cmf::math::num_array +cmf::math::num_array get_dxdt(Time time) const "; + +%feature("docstring") cmf_core::ImplicitEuler::get_state "def +get_state(self, args, kwargs) + +get_state(Integrator self, ptrdiff_t position) -> real real +get_state(ptrdiff_t position) const Returns the statevariable at +position Simplifies the assessment of state variables. "; + +%feature("docstring") cmf_core::ImplicitEuler::get_states "def +get_states(self, args) + +get_states(Integrator self) -> cmf::math::num_array +get_states(Integrator self) -> StateVariableList StateVariableList +get_states() gets the state variables of the integrator "; + +%feature("docstring") cmf_core::ImplicitEuler::get_t "def +get_t(self, args, kwargs) + +get_t(Integrator self) -> Time cmf::math::Time get_t() const Returns +the current model time. "; + +%feature("docstring") cmf_core::ImplicitEuler::integrate "def +integrate(self, args, kwargs) + +integrate(Integrator self, Time t_max, Time dt) -> int virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt)=0 Integrates the +vector of state variables. Parameters: ----------- t_max: To stop +the model (if running in a model framework) at time steps of value +exchange e.g. full hours, the next value exchange time can be given +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; + +%feature("docstring") cmf_core::ImplicitEuler::integrate_until "def +integrate_until(self, args, kwargs) + +integrate_until(Integrator self, Time t_max, Time dt, bool +reset=False) void integrate_until(cmf::math::Time t_max, +cmf::math::Time dt=Time(), bool reset=false) Integrates the vector of +state variables until t_max. Parameters: ----------- t_max: Time, +the solver should run to dt: Time step (may be omitted) reset: If +true, solver is reseted before integration starts "; + +%feature("docstring") cmf_core::ImplicitEuler::reset "def +reset(self, args, kwargs) + +reset(Integrator self) virtual void reset() Resets any saved history +(for multistep methods) "; + +%feature("docstring") cmf_core::ImplicitEuler::run "def run(self, +start=None, end=None, step=day *1, max_errors=0, reset=False) + +Returns an iterator over the timesteps start..end **Examples:** >>> +solver=cmf.CVodeIntegrator(...) >>> for t in solver.run(solver.t, +solver.t + cmf.week, cmf.h): >>> print(t, solver[0].state) or with +list comprehension >>> states = [solver[0].state for t in +solver.run(solver.t, solver.t + cmf.week, cmf.h)] Parameters +---------- start : cmf.Time, optional Start time for the solver +iteration end : cmf.Time, optional End time of the iteration step : +cmf.Time, optional Step size for the integration max_errors: int +Number of tolerated errors. If >0, up to these number of runtime +errors will be saved with their time and the integration proceeds +after a reset of the solver. Some systems operate with values close to +their physical limits and inifinite values in the integration can +easily occur. For these kind of systems set max_errors to eg. 10. A +larger number of errors should be eliminated usually. reset: bool If +True, the solver performs a `reset` at every time step Yields ------ +cmf.Time the actual timestep "; + +%feature("docstring") cmf_core::ImplicitEuler::set_state "def +set_state(self, args, kwargs) + +set_state(Integrator self, ptrdiff_t position, real newState) void +set_state(ptrdiff_t position, real newState) Simplifies the +assessment of state variables. "; + +%feature("docstring") cmf_core::ImplicitEuler::set_t "def +set_t(self, args, kwargs) + +set_t(Integrator self, Time val) void set_t(cmf::math::Time val) Sets +the current model time. "; + +%feature("docstring") cmf_core::ImplicitEuler::size "def size(self, +args, kwargs) + +size(Integrator self) -> size_t size_t size() const returns the +number of state variables "; + + +// File: classcmf_1_1math_1_1_implicit_euler.xml +%feature("docstring") cmf::math::ImplicitEuler " + +An implicit (backward) Euler integrator using fixpoint iteration. + +C++ includes: implicit_euler.h "; + +/* Internal data storages */ + +/* Accuracy parameters */ + +/* model time */ + +%feature("docstring") cmf::math::ImplicitEuler::get_t "cmf::math::Time get_t() const + +Returns the current model time. "; + +%feature("docstring") cmf::math::ImplicitEuler::set_t "void +set_t(cmf::math::Time val) + +Sets the current model time. "; + +%feature("docstring") cmf::math::ImplicitEuler::get_dt "cmf::math::Time get_dt() const + +Returns the last time step. "; + +%feature("docstring") cmf::math::ImplicitEuler::reset "virtual void +reset() + +Resets any saved history (for multistep methods) "; + +/* Integrate */ + +%feature("docstring") cmf::math::ImplicitEuler::integrate_until "void integrate_until(cmf::math::Time t_max, cmf::math::Time dt=Time(), +bool reset=false) + +Integrates the vector of state variables until t_max. + +Parameters: +----------- + +t_max: Time, the solver should run to + +dt: Time step (may be omitted) + +reset: If true, solver is reseted before integration starts "; + +%feature("docstring") cmf::math::ImplicitEuler::ImplicitEuler "ImplicitEuler(StateVariableOwner &states, real epsilon=1e-9, +cmf::math::Time tStepMin=cmf::math::timespan(10)) + +Constructs a new FixPointImplicitEuler from a pointer to a vector of +state variables. + +The Integrator becomes the owner of states + +Parameters: +----------- + +states: Statevariables of the system + +epsilon: relative error tolerance per time step (default=1e-9) + +tStepMin: minimum time step (default=10s) "; + +%feature("docstring") cmf::math::ImplicitEuler::ImplicitEuler "ImplicitEuler(real epsilon=1e-9, cmf::math::Time +tStepMin=cmf::math::timespan(10)) + +Constructs a new FixPointImplicitEuler. + +Parameters: +----------- + +epsilon: relative error tolerance per time step (default=1e-9) + +tStepMin: minimum time step (default=10s) "; + +%feature("docstring") cmf::math::ImplicitEuler::ImplicitEuler "ImplicitEuler(const Integrator &) + +copy constructor "; + +%feature("docstring") cmf::math::ImplicitEuler::add_single_state "virtual void add_single_state(cmf::math::StateVariable::ptr state) + +Adds a single state variable to the integrator. "; + +%feature("docstring") cmf::math::ImplicitEuler::add_states "void +add_states(cmf::math::StateVariableOwner &stateOwner) + +Add state variables from a StateVariableOwner. "; + +%feature("docstring") cmf::math::ImplicitEuler::add_values_to_states +"void add_values_to_states(const num_array &operands) + +Adds the values in operands to the current states. "; + +%feature("docstring") cmf::math::ImplicitEuler::copy "virtual +Integrator* copy() const + +Polymorphic copy constructor. "; + +%feature("docstring") cmf::math::ImplicitEuler::copy_dxdt "void +copy_dxdt(Time time, num_array &destination, real factor=1) const + +Copies the derivatives at time step \"time\" to a numeric vector using +use_OpenMP. + +Parameters: +----------- + +time: Time at which the derivatives should be calculated + +destination: Vector to be overwritten by the results + +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; + +%feature("docstring") cmf::math::ImplicitEuler::copy_dxdt "void +copy_dxdt(Time time, real *destination, real factor=1) const + +Copies the derivatives at time step \"time\" to an preallocated c +array. + +Parameters: +----------- + +time: Time at which the derivatives should be calculated + +destination: Allocated c array + +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; + +%feature("docstring") cmf::math::ImplicitEuler::copy_states "void +copy_states(num_array &destination) const + +Copies the states to a numeric vector using use_OpenMP. "; + +%feature("docstring") cmf::math::ImplicitEuler::copy_states "void +copy_states(real *destination) const "; + +%feature("docstring") cmf::math::ImplicitEuler::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; + +%feature("docstring") cmf::math::ImplicitEuler::get_state "real +get_state(ptrdiff_t position) const + +Returns the statevariable at position Simplifies the assessment of +state variables. "; + +%feature("docstring") cmf::math::ImplicitEuler::get_states "cmf::math::num_array get_states() const "; + +%feature("docstring") cmf::math::ImplicitEuler::get_states "StateVariableList get_states() + +gets the state variables of the integrator "; + +%feature("docstring") cmf::math::ImplicitEuler::integrate "int +integrate(cmf::math::Time MaxTime, cmf::math::Time TimeStep) + +Integrates the vector of state variables. + +Parameters: +----------- + +MaxTime: To stop the model (if running in a model framework) at time +steps of value exchange e.g. full hours, the next value exchange time +can be given + +TimeStep: Takes the proposed timestep, and changes it into the +effictivly used timestep according to the local stiffness of the +problem and MaxTime "; + +%feature("docstring") cmf::math::ImplicitEuler::set_state "void +set_state(ptrdiff_t position, real newState) + +Simplifies the assessment of state variables. "; + +%feature("docstring") cmf::math::ImplicitEuler::set_states "void +set_states(const num_array &newStates) + +Copies the new states to the actual states. "; + +%feature("docstring") cmf::math::ImplicitEuler::set_states "void +set_states(real *newStates) "; + +%feature("docstring") cmf::math::ImplicitEuler::size "size_t size() +const + +returns the number of state variables "; + + +// File: classcmf__core_1_1integratable.xml +%feature("docstring") cmf_core::integratable " + +integratable is a functionality for different classes for integrating +values over time. Main usage of an integratable is the calculation of +average fluxes over time e.g. .. math:: +\\\\\\\\int_{t_0}^{t_{end}}q\\\\\\\\left(t,V_i,V_j\\\\\\\\right)dt C++ +includes: statevariable.h "; + +%feature("docstring") cmf_core::integratable::__init__ "def +__init__(self, args, kwargs) "; + +%feature("docstring") cmf_core::integratable::avg "def avg(self, +args, kwargs) + +avg(integratable self) -> double virtual double avg() const =0 +Returns average of the integrated variable (eg. flux) from the last +reset until the last call of integrate. "; + +%feature("docstring") cmf_core::integratable::integrate "def +integrate(self, args, kwargs) + +integrate(integratable self, Time t) virtual void integrate(Time t)=0 +Integrates the variable until time t. "; + +%feature("docstring") cmf_core::integratable::reset "def reset(self, +args, kwargs) + +reset(integratable self, Time t) virtual void reset(Time t)=0 Sets +the start time of the integral. "; + +%feature("docstring") cmf_core::integratable::sum "def sum(self, +args, kwargs) + +sum(integratable self) -> double virtual double sum() const =0 Get +the integral from the last reset until the last call of integrate. "; + + +// File: classcmf_1_1math_1_1integratable.xml +%feature("docstring") cmf::math::integratable " + +integratable is a functionality for different classes for integrating +values over time. + +Main usage of an integratable is the calculation of average fluxes +over time e.g. + +.. math:: + + + \\\\int_{t_0}^{t_{end}}q\\\\left(t,V_i,V_j\\\\right)dt + +C++ includes: statevariable.h "; + +%feature("docstring") cmf::math::integratable::avg "virtual double +avg() const =0 + +Returns average of the integrated variable (eg. flux) from the last +reset until the last call of integrate. "; + +%feature("docstring") cmf::math::integratable::integrate "virtual +void integrate(Time t)=0 + +Integrates the variable until time t. "; + +%feature("docstring") cmf::math::integratable::reset "virtual void +reset(Time t)=0 + +Sets the start time of the integral. "; + +%feature("docstring") cmf::math::integratable::sum "virtual double +sum() const =0 + +Get the integral from the last reset until the last call of integrate. +"; + + +// File: classcmf__core_1_1integratable__list.xml +%feature("docstring") cmf_core::integratable_list " + +A list of cmf::math::integratable objects. Todo TODO: Complete +collection interface (getitem with slicing etc.) C++ includes: +statevariable.h "; + +%feature("docstring") cmf_core::integratable_list::__init__ "def +__init__(self, args) + +__init__(cmf::math::integratable_list self) -> integratable_list +__init__(cmf::math::integratable_list self, integratable_list +for_copy) -> integratable_list integratable_list(const +integratable_list &for_copy) "; + +%feature("docstring") cmf_core::integratable_list::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::integratable_list::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::integratable_list::__len__ "def +__len__(self, args, kwargs) + +__len__(integratable_list self) -> size_t "; + +%feature("docstring") cmf_core::integratable_list::append "def +append(self, args, kwargs) + +append(integratable_list self, cmf::math::integratable::ptr add) void +append(cmf::math::integratable::ptr add) Adds an integratable to the +list. "; + +%feature("docstring") cmf_core::integratable_list::avg "def +avg(self, args, kwargs) + +avg(integratable_list self) -> cmf::math::num_array +cmf::math::num_array avg() const "; + +%feature("docstring") cmf_core::integratable_list::integrate "def +integrate(self, args, kwargs) + +integrate(integratable_list self, Time t) void integrate(Time t) "; + +%feature("docstring") cmf_core::integratable_list::remove "def +remove(self, args, kwargs) + +remove(integratable_list self, cmf::math::integratable::ptr rm) void +remove(cmf::math::integratable::ptr rm) Removes an integratable from +the list. "; + +%feature("docstring") cmf_core::integratable_list::reset "def +reset(self, args, kwargs) + +reset(integratable_list self, Time t) void reset(Time t) "; + +%feature("docstring") cmf_core::integratable_list::size "def +size(self, args, kwargs) + +size(integratable_list self) -> size_t size_t size() const Number of +integratables in the list. "; + +%feature("docstring") cmf_core::integratable_list::sum "def +sum(self, args, kwargs) + +sum(integratable_list self) -> cmf::math::num_array +cmf::math::num_array sum() const "; + + +// File: classcmf_1_1math_1_1integratable__list.xml +%feature("docstring") cmf::math::integratable_list " + +A list of cmf::math::integratable objects. + +Todo TODO: Complete collection interface (getitem with slicing etc.) + +C++ includes: statevariable.h "; + +%feature("docstring") cmf::math::integratable_list::integratable_list +"integratable_list() "; + +%feature("docstring") cmf::math::integratable_list::integratable_list +"integratable_list(const integratable_list &for_copy) "; + +%feature("docstring") cmf::math::integratable_list::append "void +append(cmf::math::integratable::ptr add) + +Adds an integratable to the list. "; + +%feature("docstring") cmf::math::integratable_list::avg "cmf::math::num_array avg() const "; + +%feature("docstring") cmf::math::integratable_list::integrate "void +integrate(Time t) "; + +%feature("docstring") cmf::math::integratable_list::remove "void +remove(cmf::math::integratable::ptr rm) + +Removes an integratable from the list. "; + +%feature("docstring") cmf::math::integratable_list::reset "void +reset(Time t) "; + +%feature("docstring") cmf::math::integratable_list::size "size_t +size() const + +Number of integratables in the list. "; + +%feature("docstring") cmf::math::integratable_list::sum "cmf::math::num_array sum() const "; + + +// File: classcmf__core_1_1_integrator.xml +%feature("docstring") cmf_core::Integrator " + +Base class for any kind of integrator. Pure virtual functions: +Integrate copy Please provide a custom copy constructor C++ +includes: integrator.h "; + +%feature("docstring") cmf_core::Integrator::__init__ "def +__init__(self, args, kwargs) "; + +%feature("docstring") cmf_core::Integrator::__call__ "def +__call__(self, t, dt=None, reset=False) + +Advances the integration until `t` A shortcut to .integrate_until +Parameters ---------- t : cmf.Time The time step to advance to. If +t < current time, the solver will advance to self.t + t dt : +cmf.Time, optional The timestep for the integration. If not given +try to integrate in one step reset : bool, optional If True, the +solver will perform a reset before starting Returns ------- cmf.Time +The new time stamp "; + +%feature("docstring") cmf_core::Integrator::__getitem__ "def +__getitem__(self, args, kwargs) + +__getitem__(Integrator self, long position) -> +cmf::math::StateVariable::ptr "; + +%feature("docstring") cmf_core::Integrator::__len__ "def +__len__(self, args, kwargs) + +__len__(Integrator self) -> size_t "; + +%feature("docstring") cmf_core::Integrator::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::Integrator::add_single_state "def +add_single_state(self, args, kwargs) + +add_single_state(Integrator self, cmf::math::StateVariable::ptr state) +virtual void add_single_state(cmf::math::StateVariable::ptr state) +Adds a single state variable to the integrator. "; + +%feature("docstring") cmf_core::Integrator::add_states "def +add_states(self, args, kwargs) + +add_states(Integrator self, StateVariableOwner stateOwner) virtual +void add_states(cmf::math::StateVariableOwner &stateOwner) Add state +variables from a StateVariableOwner. "; + +%feature("docstring") cmf_core::Integrator::copy "def copy(self, +args, kwargs) + +copy(Integrator self) -> Integrator virtual Integrator* copy() const +=0 Polymorphic copy constructor. "; + +%feature("docstring") cmf_core::Integrator::get_dt "def get_dt(self, +args, kwargs) + +get_dt(Integrator self) -> Time cmf::math::Time get_dt() const +Returns the last time step. "; + +%feature("docstring") cmf_core::Integrator::get_dxdt "def +get_dxdt(self, args, kwargs) + +get_dxdt(Integrator self, Time time) -> cmf::math::num_array +cmf::math::num_array get_dxdt(Time time) const "; + +%feature("docstring") cmf_core::Integrator::get_state "def +get_state(self, args, kwargs) + +get_state(Integrator self, ptrdiff_t position) -> real real +get_state(ptrdiff_t position) const Returns the statevariable at +position Simplifies the assessment of state variables. "; + +%feature("docstring") cmf_core::Integrator::get_states "def +get_states(self, args) + +get_states(Integrator self) -> cmf::math::num_array +get_states(Integrator self) -> StateVariableList StateVariableList +get_states() gets the state variables of the integrator "; + +%feature("docstring") cmf_core::Integrator::get_t "def get_t(self, +args, kwargs) + +get_t(Integrator self) -> Time cmf::math::Time get_t() const Returns +the current model time. "; + +%feature("docstring") cmf_core::Integrator::integrate "def +integrate(self, args, kwargs) + +integrate(Integrator self, Time t_max, Time dt) -> int virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt)=0 Integrates the +vector of state variables. Parameters: ----------- t_max: To stop +the model (if running in a model framework) at time steps of value +exchange e.g. full hours, the next value exchange time can be given +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; + +%feature("docstring") cmf_core::Integrator::integrate_until "def +integrate_until(self, args, kwargs) + +integrate_until(Integrator self, Time t_max, Time dt, bool +reset=False) void integrate_until(cmf::math::Time t_max, +cmf::math::Time dt=Time(), bool reset=false) Integrates the vector of +state variables until t_max. Parameters: ----------- t_max: Time, +the solver should run to dt: Time step (may be omitted) reset: If +true, solver is reseted before integration starts "; + +%feature("docstring") cmf_core::Integrator::reset "def reset(self, +args, kwargs) + +reset(Integrator self) virtual void reset() Resets any saved history +(for multistep methods) "; + +%feature("docstring") cmf_core::Integrator::run "def run(self, +start=None, end=None, step=day *1, max_errors=0, reset=False) + +Returns an iterator over the timesteps start..end **Examples:** >>> +solver=cmf.CVodeIntegrator(...) >>> for t in solver.run(solver.t, +solver.t + cmf.week, cmf.h): >>> print(t, solver[0].state) or with +list comprehension >>> states = [solver[0].state for t in +solver.run(solver.t, solver.t + cmf.week, cmf.h)] Parameters +---------- start : cmf.Time, optional Start time for the solver +iteration end : cmf.Time, optional End time of the iteration step : +cmf.Time, optional Step size for the integration max_errors: int +Number of tolerated errors. If >0, up to these number of runtime +errors will be saved with their time and the integration proceeds +after a reset of the solver. Some systems operate with values close to +their physical limits and inifinite values in the integration can +easily occur. For these kind of systems set max_errors to eg. 10. A +larger number of errors should be eliminated usually. reset: bool If +True, the solver performs a `reset` at every time step Yields ------ +cmf.Time the actual timestep "; + +%feature("docstring") cmf_core::Integrator::set_state "def +set_state(self, args, kwargs) + +set_state(Integrator self, ptrdiff_t position, real newState) void +set_state(ptrdiff_t position, real newState) Simplifies the +assessment of state variables. "; + +%feature("docstring") cmf_core::Integrator::set_t "def set_t(self, +args, kwargs) + +set_t(Integrator self, Time val) void set_t(cmf::math::Time val) Sets +the current model time. "; + +%feature("docstring") cmf_core::Integrator::size "def size(self, +args, kwargs) + +size(Integrator self) -> size_t size_t size() const returns the +number of state variables "; + + +// File: classcmf_1_1math_1_1_integrator.xml +%feature("docstring") cmf::math::Integrator " + +Base class for any kind of integrator. + +Pure virtual functions: Integrate + +copy Please provide a custom copy constructor + +C++ includes: integrator.h "; + +/* Accuracy parameters */ + +/* model time */ + +%feature("docstring") cmf::math::Integrator::get_t "cmf::math::Time +get_t() const + +Returns the current model time. "; + +%feature("docstring") cmf::math::Integrator::set_t "void +set_t(cmf::math::Time val) + +Sets the current model time. "; + +%feature("docstring") cmf::math::Integrator::get_dt "cmf::math::Time +get_dt() const + +Returns the last time step. "; + +%feature("docstring") cmf::math::Integrator::reset "virtual void +reset() + +Resets any saved history (for multistep methods) "; + +/* Constructors and Destructors */ + +%feature("docstring") cmf::math::Integrator::Integrator "Integrator(real epsilon=1e-9) + +Constructs a new Integrator with a new own state vector. + +Parameters: +----------- + +epsilon: relative error tolerance per time step (default=1e-9) "; + +%feature("docstring") cmf::math::Integrator::Integrator "Integrator(cmf::math::StateVariableOwner &states, real epsilon=1e-9) +"; + +%feature("docstring") cmf::math::Integrator::Integrator "Integrator(const cmf::math::Integrator &other) "; + +%feature("docstring") cmf::math::Integrator::copy "virtual +Integrator* copy() const =0 + +Polymorphic copy constructor. "; + +/* Integrate */ + +%feature("docstring") cmf::math::Integrator::integrate "virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt)=0 + +Integrates the vector of state variables. + +Parameters: +----------- + +t_max: To stop the model (if running in a model framework) at time +steps of value exchange e.g. full hours, the next value exchange time +can be given + +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; + +%feature("docstring") cmf::math::Integrator::integrate_until "void +integrate_until(cmf::math::Time t_max, cmf::math::Time dt=Time(), bool +reset=false) + +Integrates the vector of state variables until t_max. + +Parameters: +----------- + +t_max: Time, the solver should run to + +dt: Time step (may be omitted) + +reset: If true, solver is reseted before integration starts "; + +%feature("docstring") cmf::math::Integrator::~Integrator "virtual +~Integrator() "; + +%feature("docstring") cmf::math::Integrator::add_single_state "virtual void add_single_state(cmf::math::StateVariable::ptr state) + +Adds a single state variable to the integrator. "; + +%feature("docstring") cmf::math::Integrator::add_states "virtual +void add_states(cmf::math::StateVariableOwner &stateOwner) + +Add state variables from a StateVariableOwner. "; + +%feature("docstring") cmf::math::Integrator::add_values_to_states "void add_values_to_states(const num_array &operands) + +Adds the values in operands to the current states. "; + +%feature("docstring") cmf::math::Integrator::copy_dxdt "void +copy_dxdt(Time time, num_array &destination, real factor=1) const + +Copies the derivatives at time step \"time\" to a numeric vector using +use_OpenMP. + +Parameters: +----------- + +time: Time at which the derivatives should be calculated + +destination: Vector to be overwritten by the results + +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; + +%feature("docstring") cmf::math::Integrator::copy_dxdt "void +copy_dxdt(Time time, real *destination, real factor=1) const + +Copies the derivatives at time step \"time\" to an preallocated c +array. + +Parameters: +----------- + +time: Time at which the derivatives should be calculated + +destination: Allocated c array + +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; + +%feature("docstring") cmf::math::Integrator::copy_states "void +copy_states(num_array &destination) const + +Copies the states to a numeric vector using use_OpenMP. "; + +%feature("docstring") cmf::math::Integrator::copy_states "void +copy_states(real *destination) const "; + +%feature("docstring") cmf::math::Integrator::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; + +%feature("docstring") cmf::math::Integrator::get_state "real +get_state(ptrdiff_t position) const + +Returns the statevariable at position Simplifies the assessment of +state variables. "; + +%feature("docstring") cmf::math::Integrator::get_states "cmf::math::num_array get_states() const "; + +%feature("docstring") cmf::math::Integrator::get_states "StateVariableList get_states() + +gets the state variables of the integrator "; + +%feature("docstring") cmf::math::Integrator::set_state "void +set_state(ptrdiff_t position, real newState) + +Simplifies the assessment of state variables. "; + +%feature("docstring") cmf::math::Integrator::set_states "void +set_states(const num_array &newStates) + +Copies the new states to the actual states. "; + +%feature("docstring") cmf::math::Integrator::set_states "void +set_states(real *newStates) "; + +%feature("docstring") cmf::math::Integrator::size "size_t size() +const + +returns the number of state variables "; + + +// File: classcmf_1_1math_1_1root__finding_1_1iteration__error.xml +%feature("docstring") cmf::math::root_finding::iteration_error ""; + +%feature("docstring") +cmf::math::root_finding::iteration_error::iteration_error "iteration_error(const std::string &msg) "; + + +// File: classcmf_1_1river_1_1_i_volume_height_function.xml +%feature("docstring") cmf::river::IVolumeHeightFunction " + +Volume height relations are functional objects, which return a height +and a crosssectional area of a volume for different geometric bodies. + +This is the abstract base class, where the geometries derive from + +C++ includes: ReachType.h "; + +%feature("docstring") +cmf::river::IVolumeHeightFunction::~IVolumeHeightFunction "virtual +~IVolumeHeightFunction() "; + +%feature("docstring") cmf::river::IVolumeHeightFunction::A "virtual +double A(double V) const =0 + +Returns the area of the surface for a given volume. "; + +%feature("docstring") cmf::river::IVolumeHeightFunction::copy "virtual IVolumeHeightFunction* copy() const =0 "; + +%feature("docstring") cmf::river::IVolumeHeightFunction::h "virtual +double h(double V) const =0 + +Returns the depth of a given volume. "; + +%feature("docstring") cmf::river::IVolumeHeightFunction::q "virtual +double q(double h, double slope) const "; + +%feature("docstring") cmf::river::IVolumeHeightFunction::V "virtual +double V(double h) const =0 "; + + +// File: classcmf__core_1_1_i_volume_height_function.xml +%feature("docstring") cmf_core::IVolumeHeightFunction " + +Volume height relations are functional objects, which return a height +and a crosssectional area of a volume for different geometric bodies. +This is the abstract base class, where the geometries derive from C++ +includes: ReachType.h "; + +%feature("docstring") cmf_core::IVolumeHeightFunction::__init__ "def +__init__(self, args, kwargs) "; + +%feature("docstring") cmf_core::IVolumeHeightFunction::A "def +A(self, args, kwargs) + +A(IVolumeHeightFunction self, double V) -> double virtual double +A(double V) const =0 Returns the area of the surface for a given +volume. "; + +%feature("docstring") cmf_core::IVolumeHeightFunction::copy "def +copy(self, args, kwargs) + +copy(IVolumeHeightFunction self) -> IVolumeHeightFunction virtual +IVolumeHeightFunction* copy() const =0 "; + +%feature("docstring") cmf_core::IVolumeHeightFunction::h "def +h(self, args, kwargs) + +h(IVolumeHeightFunction self, double V) -> double virtual double +h(double V) const =0 Returns the depth of a given volume. "; + +%feature("docstring") cmf_core::IVolumeHeightFunction::q "def +q(self, args, kwargs) + +q(IVolumeHeightFunction self, double h, double slope) -> double +virtual double q(double h, double slope) const "; + +%feature("docstring") cmf_core::IVolumeHeightFunction::V "def +V(self, args, kwargs) + +V(IVolumeHeightFunction self, double h) -> double virtual double +V(double h) const =0 "; + + +// File: classcmf_1_1jacobian_1_1_jacobian.xml +%feature("docstring") cmf::jacobian::Jacobian " + +Approximates the jacobian for a cmf solver J[i,j] = +(dxdt(S_i,t)[j]-dxdt(S,t)[j])/delta S is the state vector S_i equals +S, except for S_i[i]=S[i]+delta delta is the finite difference to +approximate the Jacobian. delta should be a small number, but big +enough to avoid floating point errors. 1e-6 to 1e-9 should be +nice values Usage to show the jacobian: # Allocate memory for the +jacobian jac = Jacobian(solver,delta) # Calculate the Jacobian +J = jac() # Show the Jacobian +imshow(jac(),interpolation='nearest') "; + +%feature("docstring") cmf::jacobian::Jacobian::__init__ "def +__init__(self, solver, delta=1e-6) + +solver is a cmf integrator, delta is the amount the state should be +changed "; + +%feature("docstring") cmf::jacobian::Jacobian::__call__ "def +__call__(self) "; + +%feature("docstring") cmf::jacobian::Jacobian::__len__ "def +__len__(self) "; + +%feature("docstring") cmf::jacobian::Jacobian::dxdt "def dxdt(self) + +Returns the current right hand side of the ODE for the current states +and the current time "; + +%feature("docstring") cmf::jacobian::Jacobian::t "def t(self) "; + + +// File: classcmf_1_1upslope_1_1connections_1_1_jarvis_macro_flow.xml +%feature("docstring") cmf::upslope::connections::JarvisMacroFlow " + +A physically based macropore to macropore connection according to +Jarvis & Leeds-Harrison 1987, JSS. + + + +.. math:: + + q_{i->j} [m/s]= \\\\rho \\\\frac G {12\\\\eta} w^2 \\\\frac{e_v- + e_r}{1-e_r} S_{c,i}^\\\\beta\\\\ (1-S_{c,j}) + +where: :math:`q_{i->j}` +the flow from macro pore layer i to macropore layer j + +:math:`\\\\rho=10^{-3} kg/m^3` - the density of water + +:math:`G=9.81 m/s^2` the earth acceleration + +:math:`\\\\eta=1.0 kg/(m s)` the viscosity of water (at 20 degC) + +:math:`w [m]` the crack width, a function of water content and crack +distance + +:math:`e_v [-]` the crack porosity + +:math:`e_r [-]` crack por + +:math:`S_c [-]` the crack saturation of layer i resp. j + +:math:`\\\\beta [-]` a conceptional exponent to shape the flow reaction + +C++ includes: macropore.h "; + +%feature("docstring") +cmf::upslope::connections::JarvisMacroFlow::JarvisMacroFlow "JarvisMacroFlow(cmf::water::WaterStorage::ptr left, +cmf::water::flux_node::ptr right, real beta=1., real +porefraction_r=0.0) + +Constructs the connection. + +Parameters: +----------- + +left: right: the connected macropores + +beta: User defined parameter for the swelling reaction + +porefraction_r: Porefraction at which flow starts. For swelling soils +that are closing completely th "; + +%feature("docstring") +cmf::upslope::connections::JarvisMacroFlow::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") +cmf::upslope::connections::JarvisMacroFlow::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") +cmf::upslope::connections::JarvisMacroFlow::get_ptr "ptr get_ptr() +const "; + +%feature("docstring") +cmf::upslope::connections::JarvisMacroFlow::get_target "flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") +cmf::upslope::connections::JarvisMacroFlow::get_target "flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") +cmf::upslope::connections::JarvisMacroFlow::get_tracer_filter "real +get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::JarvisMacroFlow::get_tracer_filter "real +get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") +cmf::upslope::connections::JarvisMacroFlow::kill_me "bool kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") +cmf::upslope::connections::JarvisMacroFlow::left_node "flux_node::ptr +left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") cmf::upslope::connections::JarvisMacroFlow::q "real q(const flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") +cmf::upslope::connections::JarvisMacroFlow::refresh "void +refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") +cmf::upslope::connections::JarvisMacroFlow::right_node "flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") +cmf::upslope::connections::JarvisMacroFlow::set_tracer_filter "void +set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::JarvisMacroFlow::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf::upslope::connections::JarvisMacroFlow::short_string "virtual +std::string short_string() const "; + +%feature("docstring") +cmf::upslope::connections::JarvisMacroFlow::to_string "virtual +std::string to_string() const "; + + +// File: classcmf__core_1_1_jarvis_macro_flow.xml +%feature("docstring") cmf_core::JarvisMacroFlow " + +A physically based macropore to macropore connection according to +Jarvis & Leeds-Harrison 1987, JSS. .. math:: q_{i->j} [m/s]= +\\\\\\\\rho \\\\\\\\frac G {12\\\\\\\\eta} w^2 \\\\\\\\frac{e_v- +e_r}{1-e_r} S_{c,i}^\\\\\\\\beta\\\\\\\\ (1-S_{c,j}) where: +:math:`q_{i->j}` the flow from macro pore layer i to macropore layer j +:math:`\\\\\\\\rho=10^{-3} kg/m^3` - the density of water +:math:`G=9.81 m/s^2` the earth acceleration :math:`\\\\\\\\eta=1.0 +kg/(m s)` the viscosity of water (at 20 degC) :math:`w [m]` the crack +width, a function of water content and crack distance :math:`e_v [-]` +the crack porosity :math:`e_r [-]` crack por :math:`S_c [-]` the +crack saturation of layer i resp. j :math:`\\\\\\\\beta [-]` a +conceptional exponent to shape the flow reaction C++ includes: +macropore.h "; + +%feature("docstring") cmf_core::JarvisMacroFlow::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::connections::JarvisMacroFlow self, +cmf::water::WaterStorage::ptr left, cmf::water::flux_node::ptr right, +real beta=1., real porefraction_r=0.0) -> JarvisMacroFlow +JarvisMacroFlow(cmf::water::WaterStorage::ptr left, +cmf::water::flux_node::ptr right, real beta=1., real +porefraction_r=0.0) Constructs the connection. Parameters: +----------- left: right: the connected macropores beta: User +defined parameter for the swelling reaction porefraction_r: +Porefraction at which flow starts. For swelling soils that are closing +completely th "; + +%feature("docstring") cmf_core::JarvisMacroFlow::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::JarvisMacroFlow::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::JarvisMacroFlow::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::JarvisMacroFlow::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::JarvisMacroFlow::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::JarvisMacroFlow::conc "def +conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") cmf_core::JarvisMacroFlow::exchange_target "def exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::JarvisMacroFlow::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::JarvisMacroFlow::get_tracer_filter "def get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::JarvisMacroFlow::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::JarvisMacroFlow::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::JarvisMacroFlow::q "def q(self, +args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::JarvisMacroFlow::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::JarvisMacroFlow::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::JarvisMacroFlow::set_tracer_filter "def set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::JarvisMacroFlow::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::JarvisMacroFlow::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf__core_1_1kinematic__wave.xml +%feature("docstring") cmf_core::kinematic_wave " + +Calculates flux out of a storage as a linear function of its volume to +a power. Deprecated kinematic_wave is superseeded by +LinearStorageConnection and PowerLawConnection .. math:: q = +\\\\\\\\frac 1 {t_r} {\\\\\\\\left(\\\\\\\\frac{V - V_{residual}}{V_0} +\\\\\\\\right)^\\\\\\\\beta} where: :math:`V_{residual} [m^3]` The +volume of water not flowing out (default = 0) :math:`V_0` The +reference volume to scale the exponent (default = 1m3/day) +:math:`\\\\\\\\beta` A parameter to shape the response curve. In case +of :math:`\\\\\\\\beta \\\\\\\\neq 1`, :math:`t_r` is not a residence +time, but just a parameter. :math:`t_r [days]` The residence time of +the water in this storage in days WARNING: :math:`\\\\\\\\beta < +0.5` may lead to numerical troubles and have a dubious hydrological +meaning. Please avoid. C++ includes: simple_connections.h "; + +%feature("docstring") cmf_core::kinematic_wave::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::water::kinematic_wave self, +cmf::water::WaterStorage::ptr source, cmf::water::flux_node::ptr +target, real residencetime, real exponent=1.0, real residual=0.0, real +V0=1.0) -> kinematic_wave kinematic_wave(WaterStorage::ptr source, +flux_node::ptr target, real residencetime, real exponent=1.0, real +residual=0.0, real V0=1.0) Creates a kinematic wave connection. .. +math:: q = \\\\\\\\frac 1 {t_r} {\\\\\\\\left(\\\\\\\\frac{V - +V_{residual}}{V_0} \\\\\\\\right)^\\\\\\\\beta} Parameters: +----------- source: Water storage from which the water flows out. +Flux is a function of source.volume target: Target node (boundary +condition or storage). Does not influence the strength of the flow +residencetime: :math:`t_r [days]` The residence time of the water in +this storage exponent: :math:`\\\\\\\\beta [-]` An empirical +exponent to shape the flux function (default = 1 (linear function)) +residual: :math:`V_{residual} [m^3]` The volume of water not flowing +out (default = 0) V0: :math:`V_0` The reference volume to scale the +exponent "; + +%feature("docstring") cmf_core::kinematic_wave::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::kinematic_wave::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::kinematic_wave::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::kinematic_wave::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::kinematic_wave::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::kinematic_wave::conc "def conc(self, +args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") cmf_core::kinematic_wave::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::kinematic_wave::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::kinematic_wave::get_tracer_filter "def get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::kinematic_wave::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::kinematic_wave::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::kinematic_wave::q "def q(self, args, +kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::kinematic_wave::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::kinematic_wave::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::kinematic_wave::set_tracer_filter "def set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::kinematic_wave::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::kinematic_wave::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf_1_1water_1_1kinematic__wave.xml +%feature("docstring") cmf::water::kinematic_wave " + +Calculates flux out of a storage as a linear function of its volume to +a power. + +Deprecated kinematic_wave is superseeded by LinearStorageConnection +and PowerLawConnection + + + +.. math:: + + q = \\\\frac 1 {t_r} {\\\\left(\\\\frac{V - V_{residual}}{V_0} + \\\\right)^\\\\beta} + +where: :math:`V_{residual} [m^3]` The volume of +water not flowing out (default = 0) + +:math:`V_0` The reference volume to scale the exponent (default = 1m3/day) + +:math:`\\\\beta` A parameter to shape the response curve. In case of +:math:`\\\\beta \\\\neq 1`, :math:`t_r` is not a residence time, but just a +parameter. + +:math:`t_r [days]` The residence time of the water in this storage in days + +WARNING: :math:`\\\\beta < 0.5` may lead to numerical troubles and have a +dubious hydrological meaning. Please avoid. + +C++ includes: simple_connections.h "; + +%feature("docstring") cmf::water::kinematic_wave::kinematic_wave "kinematic_wave(WaterStorage::ptr source, flux_node::ptr target, real +residencetime, real exponent=1.0, real residual=0.0, real V0=1.0) + +Creates a kinematic wave connection. + + + +.. math:: + + q = \\\\frac 1 {t_r} {\\\\left(\\\\frac{V - V_{residual}}{V_0} + \\\\right)^\\\\beta} + +Parameters: +----------- + +source: Water storage from which the water flows out. Flux is a +function of source.volume + +target: Target node (boundary condition or storage). Does not +influence the strength of the flow + +residencetime: :math:`t_r [days]` The residence time of the water in this +storage + +exponent: :math:`\\\\beta [-]` An empirical exponent to shape the flux +function (default = 1 (linear function)) + +residual: :math:`V_{residual} [m^3]` The volume of water not flowing out +(default = 0) + +V0: :math:`V_0` The reference volume to scale the exponent "; + +%feature("docstring") cmf::water::kinematic_wave::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") cmf::water::kinematic_wave::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr +newTarget) "; + +%feature("docstring") cmf::water::kinematic_wave::get_ptr "ptr +get_ptr() const "; + +%feature("docstring") cmf::water::kinematic_wave::get_target "flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") cmf::water::kinematic_wave::get_target "flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") cmf::water::kinematic_wave::get_tracer_filter "real get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") cmf::water::kinematic_wave::get_tracer_filter "real get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") cmf::water::kinematic_wave::kill_me "bool +kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") cmf::water::kinematic_wave::left_node "flux_node::ptr left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") cmf::water::kinematic_wave::q "real q(const +flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") cmf::water::kinematic_wave::refresh "void +refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") cmf::water::kinematic_wave::right_node "flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") cmf::water::kinematic_wave::set_tracer_filter "void set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") cmf::water::kinematic_wave::set_tracer_filter "void set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf::water::kinematic_wave::short_string "virtual std::string short_string() const "; + +%feature("docstring") cmf::water::kinematic_wave::to_string "virtual +std::string to_string() const "; + + +// File: classcmf__core_1_1_kinematic_macro_flow.xml +%feature("docstring") cmf_core::KinematicMacroFlow " + +Linear storage based flux from macro pore to macro pore. Deprecated +The MacroPore model is still very experimental and not stable. Only +for tryouts! .. math:: q = A_{cell} K_{macro} +\\\\\\\\left(\\\\\\\\frac{V_{upper}}{C_{upper}}\\\\\\\\right)^\\\\\\\\beta +\\\\\\\\left(1-\\\\\\\\frac{V_{lower}}{C_{lower}}\\\\\\\\right) where: +:math:`A_{cell}` is the area of the owning cell in m2 +:math:`K_{macro}` is the conductivity of the macro pore storage +:math:`V` is the actual stored water volume in the upper resp. lower +macro pore storage :math:`C` is the capacity of the upper resp. lower +macro pore storage C++ includes: macropore.h "; + +%feature("docstring") cmf_core::KinematicMacroFlow::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::connections::KinematicMacroFlow self, +cmf::water::WaterStorage::ptr left, cmf::water::flux_node::ptr right, +real beta=1.) -> KinematicMacroFlow +KinematicMacroFlow(cmf::water::WaterStorage::ptr left, +cmf::water::flux_node::ptr right, real beta=1.) Creates the +connection. Parameters: ----------- left: right: the nodes between +the connection should be created. beta: a conceptional curve shape +parameter for the relation between storage and outflow Either left or +right needs to be a MacroPore, left needs to be a water storage "; + +%feature("docstring") cmf_core::KinematicMacroFlow::__contains__ "def __contains__(self, cmp) "; + +%feature("docstring") cmf_core::KinematicMacroFlow::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::KinematicMacroFlow::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::KinematicMacroFlow::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::KinematicMacroFlow::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::KinematicMacroFlow::conc "def +conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") cmf_core::KinematicMacroFlow::exchange_target "def exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::KinematicMacroFlow::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::KinematicMacroFlow::get_tracer_filter +"def get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::KinematicMacroFlow::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::KinematicMacroFlow::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::KinematicMacroFlow::q "def q(self, +args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::KinematicMacroFlow::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::KinematicMacroFlow::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::KinematicMacroFlow::set_tracer_filter +"def set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::KinematicMacroFlow::short_string "def short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::KinematicMacroFlow::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf_1_1upslope_1_1connections_1_1_kinematic_macro_flow.xml +%feature("docstring") cmf::upslope::connections::KinematicMacroFlow " + +Linear storage based flux from macro pore to macro pore. + +Deprecated The MacroPore model is still very experimental and not +stable. Only for tryouts! + + + +.. math:: + + q = A_{cell} K_{macro} + \\\\left(\\\\frac{V_{upper}}{C_{upper}}\\\\right)^\\\\beta + \\\\left(1-\\\\frac{V_{lower}}{C_{lower}}\\\\right) + +where: +:math:`A_{cell}` is the area of the owning cell in m2 + +:math:`K_{macro}` is the conductivity of the macro pore storage + +:math:`V` is the actual stored water volume in the upper resp. lower macro +pore storage + +:math:`C` is the capacity of the upper resp. lower macro pore storage + +C++ includes: macropore.h "; + +%feature("docstring") +cmf::upslope::connections::KinematicMacroFlow::KinematicMacroFlow "KinematicMacroFlow(cmf::water::WaterStorage::ptr left, +cmf::water::flux_node::ptr right, real beta=1.) + +Creates the connection. + +Parameters: +----------- + +left: right: the nodes between the connection should be created. + +beta: a conceptional curve shape parameter for the relation between +storage and outflow + +Either left or right needs to be a MacroPore, left needs to be a water +storage "; + +%feature("docstring") +cmf::upslope::connections::KinematicMacroFlow::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") +cmf::upslope::connections::KinematicMacroFlow::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") +cmf::upslope::connections::KinematicMacroFlow::get_ptr "ptr get_ptr() +const "; + +%feature("docstring") +cmf::upslope::connections::KinematicMacroFlow::get_target "flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") +cmf::upslope::connections::KinematicMacroFlow::get_target "flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") +cmf::upslope::connections::KinematicMacroFlow::get_tracer_filter "real get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::KinematicMacroFlow::get_tracer_filter "real get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") +cmf::upslope::connections::KinematicMacroFlow::kill_me "bool +kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") +cmf::upslope::connections::KinematicMacroFlow::left_node "flux_node::ptr left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") +cmf::upslope::connections::KinematicMacroFlow::q "real q(const +flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") +cmf::upslope::connections::KinematicMacroFlow::refresh "void +refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") +cmf::upslope::connections::KinematicMacroFlow::right_node "flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") +cmf::upslope::connections::KinematicMacroFlow::set_tracer_filter "void set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::KinematicMacroFlow::set_tracer_filter "void set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf::upslope::connections::KinematicMacroFlow::short_string "virtual +std::string short_string() const "; + +%feature("docstring") +cmf::upslope::connections::KinematicMacroFlow::to_string "virtual +std::string to_string() const "; + + +// File: classcmf_1_1upslope_1_1connections_1_1_kinematic_surface_runoff.xml +%feature("docstring") +cmf::upslope::connections::KinematicSurfaceRunoff " + +A connection to route water from a SurfaceWater storage to another +node following a topographic gradient. + + + +.. math:: + + q_{runoff} = A_{cross} d_{eff}^{2/3} + \\\\frac{\\\\sqrt{S}}{n} + +where: :math:`q_{runoff}` is the surface +runoff + +:math:`A_{cross}` is the wetted crossectional flux area, given as :math:`d_{eff} \\\\cdot w` + +:math:`w` is the width of the shared boundary between the surface water +storage and the target node + +:math:`d_{eff}` is the effective flow depth of the surface water.The +effective flow depth is defined as + +.. math:: + + d_{eff} = \\\\begin{cases} + V/A-d_{puddle}\\\\ & V/A>d_{puddle} \\\\\\\\ 0.0 & V/A<=d_{puddle} + \\\\end{cases} + +:math:`V` the volume of stored water in the surface in :math:`m^3` + +:math:`A` the area of the cell in :math:`m^2` + +:math:`d_{puddle}=V_{puddle}/A` the average depth of water in the surface +water needed to start run off + +:math:`S = \\\\|\\\\frac{\\\\Delta z\\\\|}{d}` the slope between +surfacewater center and the target node + +:math:`n` the manning roughness + +The KinematicSurfaceRunoff can be used as a cell connecting flux as +in: This results in a connection of the surfacewater storage of each +cell with the surface water storages of its neighborssee + +C++ includes: surfacewater.h "; + +%feature("docstring") +cmf::upslope::connections::KinematicSurfaceRunoff::KinematicSurfaceRunoff +"KinematicSurfaceRunoff(cmf::upslope::SurfaceWater::ptr left, +cmf::water::flux_node::ptr right, real flowwidth, real distance=-1) + +Creates a KinematicSurfaceRunoff between a SurfaceWater (left) with +another (right) node. + +Parameters: +----------- + +left: A surfacewater storage + +right: The target node + +flowwidth: the length of the shared boundary between left and right +in m + +distance: the distance between left and right in m. If d<=0m, the +distance is calculated according to the position of left and right "; + +%feature("docstring") +cmf::upslope::connections::KinematicSurfaceRunoff::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") +cmf::upslope::connections::KinematicSurfaceRunoff::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr +newTarget) "; + +%feature("docstring") +cmf::upslope::connections::KinematicSurfaceRunoff::get_ptr "ptr +get_ptr() const "; + +%feature("docstring") +cmf::upslope::connections::KinematicSurfaceRunoff::get_target "flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") +cmf::upslope::connections::KinematicSurfaceRunoff::get_target "flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") +cmf::upslope::connections::KinematicSurfaceRunoff::get_tracer_filter "real get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::KinematicSurfaceRunoff::get_tracer_filter "real get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") +cmf::upslope::connections::KinematicSurfaceRunoff::kill_me "bool +kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") +cmf::upslope::connections::KinematicSurfaceRunoff::left_node "flux_node::ptr left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") +cmf::upslope::connections::KinematicSurfaceRunoff::q "real q(const +flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") +cmf::upslope::connections::KinematicSurfaceRunoff::refresh "void +refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") +cmf::upslope::connections::KinematicSurfaceRunoff::right_node "flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") +cmf::upslope::connections::KinematicSurfaceRunoff::set_tracer_filter "void set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::KinematicSurfaceRunoff::set_tracer_filter "void set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf::upslope::connections::KinematicSurfaceRunoff::short_string "virtual std::string short_string() const "; + +%feature("docstring") +cmf::upslope::connections::KinematicSurfaceRunoff::to_string "virtual +std::string to_string() const "; + + +// File: classcmf__core_1_1_kinematic_surface_runoff.xml +%feature("docstring") cmf_core::KinematicSurfaceRunoff " + +A connection to route water from a SurfaceWater storage to another +node following a topographic gradient. .. math:: q_{runoff} = +A_{cross} d_{eff}^{2/3} \\\\\\\\frac{\\\\\\\\sqrt{S}}{n} where: +:math:`q_{runoff}` is the surface runoff :math:`A_{cross}` is the +wetted crossectional flux area, given as :math:`d_{eff} \\\\\\\\cdot +w` :math:`w` is the width of the shared boundary between the surface +water storage and the target node :math:`d_{eff}` is the effective +flow depth of the surface water.The effective flow depth is defined as +.. math:: d_{eff} = \\\\\\\\begin{cases} V/A-d_{puddle}\\\\\\\\ & +V/A>d_{puddle} \\\\\\\\\\\\\\\\ 0.0 & V/A<=d_{puddle} +\\\\\\\\end{cases} :math:`V` the volume of stored water in the +surface in :math:`m^3` :math:`A` the area of the cell in :math:`m^2` +:math:`d_{puddle}=V_{puddle}/A` the average depth of water in the +surface water needed to start run off :math:`S = +\\\\\\\\|\\\\\\\\frac{\\\\\\\\Delta z\\\\\\\\|}{d}` the slope between +surfacewater center and the target node :math:`n` the manning +roughness The KinematicSurfaceRunoff can be used as a cell connecting +flux as in: This results in a connection of the surfacewater storage +of each cell with the surface water storages of its neighborssee C++ +includes: surfacewater.h "; + +%feature("docstring") cmf_core::KinematicSurfaceRunoff::__init__ "def __init__(self, args, kwargs) + +__init__(cmf::upslope::connections::KinematicSurfaceRunoff self, +cmf::upslope::SurfaceWater::ptr left, cmf::water::flux_node::ptr +right, real flowwidth, real distance=-1) -> KinematicSurfaceRunoff +KinematicSurfaceRunoff(cmf::upslope::SurfaceWater::ptr left, +cmf::water::flux_node::ptr right, real flowwidth, real distance=-1) +Creates a KinematicSurfaceRunoff between a SurfaceWater (left) with +another (right) node. Parameters: ----------- left: A surfacewater +storage right: The target node flowwidth: the length of the shared +boundary between left and right in m distance: the distance between +left and right in m. If d<=0m, the distance is calculated according to +the position of left and right "; + +%feature("docstring") cmf_core::KinematicSurfaceRunoff::__contains__ +"def __contains__(self, cmp) "; + +%feature("docstring") cmf_core::KinematicSurfaceRunoff::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::KinematicSurfaceRunoff::__getitem__ "def __getitem__(self, index) "; + +%feature("docstring") cmf_core::KinematicSurfaceRunoff::__iter__ "def __iter__(self) "; + +%feature("docstring") cmf_core::KinematicSurfaceRunoff::__repr__ "def __repr__(self) "; + +%feature("docstring") cmf_core::KinematicSurfaceRunoff::conc "def +conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") +cmf_core::KinematicSurfaceRunoff::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::KinematicSurfaceRunoff::get_target "def get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") +cmf_core::KinematicSurfaceRunoff::get_tracer_filter "def +get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::KinematicSurfaceRunoff::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::KinematicSurfaceRunoff::left_node "def left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::KinematicSurfaceRunoff::q "def +q(self, args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::KinematicSurfaceRunoff::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::KinematicSurfaceRunoff::right_node "def right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") +cmf_core::KinematicSurfaceRunoff::set_tracer_filter "def +set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::KinematicSurfaceRunoff::short_string +"def short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::KinematicSurfaceRunoff::to_string "def to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf__core_1_1_langmuir_adsorption.xml +%feature("docstring") cmf_core::LangmuirAdsorption " + +This class calculates the adsorption equilibrium between sorbat and +sorbent using the Langmuir isotherme. Langmuir Adsorption: .. +math:: \\\\\\\\frac{x_{ad}}{m} = q = \\\\\\\\frac{K c}{1 + K c} +where :math:`x_{ad} = x_{tot} - x_{free}` is the adsorbed tracer mass +:math:`x_{tot}` is the total tracer mass :math:`x_{free}` is the +dissolved tracer mass :math:`m` is the mass of the sorbent in the +same unit as the tracer mass :math:`K` is the Langmuir sorption +coefficient :math:`c = \\\\\\\\frac{x_{free}}{V}` is the +concentration of the tracer in tracer mass per m3 CMF stores in a +solute storage the total mass of a tracer and needs to calculate the +free tracer mass. The analytical solution for :math:`x_{free}` from +:math:`x_{tot}` is implemented in freesolute and derived usingsympy. +If you really want to see it, look in the code. +http://en.wikipedia.org/wiki/Langmuir_equation C++ includes: +adsorption.h "; + +%feature("docstring") cmf_core::LangmuirAdsorption::__init__ "def +__init__(self, args) + +__init__(cmf::water::LangmuirAdsorption self, real K, real m) -> +LangmuirAdsorption __init__(cmf::water::LangmuirAdsorption self, +LangmuirAdsorption other) -> LangmuirAdsorption +LangmuirAdsorption(const LangmuirAdsorption &other) "; + +%feature("docstring") cmf_core::LangmuirAdsorption::copy "def +copy(self, args, kwargs) + +copy(LangmuirAdsorption self, real m=-1) -> LangmuirAdsorption +LangmuirAdsorption* copy(real m=-1) const returns a copy of the +Adsorption object. If the adsorption is depending on the sorbent +mass, you can give a positive value for the sorbent mass m. If the +value is not given or negative, m is used from the original object. "; + +%feature("docstring") cmf_core::LangmuirAdsorption::freesolute "def +freesolute(self, args, kwargs) + +freesolute(Adsorption self, real xt, real V) -> real virtual real +freesolute(real xt, real V) const =0 Returns the mass of dissolved +tracer as a function of the total tracer mass in the solute storage +and the water volume. Parameters: ----------- xt: :math:`x_t` the +total tracer mass in the storage V: :math:`V m^3` the water volume +in the storage :math:`x_f` the dissolved mass of the tracer "; + +%feature("docstring") cmf_core::LangmuirAdsorption::totalsolute "def +totalsolute(self, args, kwargs) + +totalsolute(Adsorption self, real xf, real V) -> real virtual real +totalsolute(real xf, real V) const =0 Returns the total mass of the +tracer from the dissolved concetration in tracer unit/m3. Parameters: +----------- xf: :math:`x_f` the dissolved tracer mass in the +storage V: :math:`V m^3` the water volume in the storage +:math:`x_t` the total mass of the tracer "; + + +// File: classcmf_1_1water_1_1_langmuir_adsorption.xml +%feature("docstring") cmf::water::LangmuirAdsorption " + +This class calculates the adsorption equilibrium between sorbat and +sorbent using the Langmuir isotherme. + +Langmuir Adsorption: + + + +.. math:: + + \\\\frac{x_{ad}}{m} = q = \\\\frac{K c}{1 + K c} + +where +:math:`x_{ad} = x_{tot} - x_{free}` is the adsorbed tracer mass :math:`x_{tot}` +is the total tracer mass + +:math:`x_{free}` is the dissolved tracer mass + +:math:`m` is the mass of the sorbent in the same unit as the tracer mass + +:math:`K` is the Langmuir sorption coefficient + +:math:`c = \\\\frac{x_{free}}{V}` is the concentration of the tracer in +tracer mass per m3 + +CMF stores in a solute storage the total mass of a tracer and needs to +calculate the free tracer mass. The analytical solution for :math:`x_{free}` +from :math:`x_{tot}` is implemented in freesolute and derived usingsympy. If +you really want to see it, look in the code. + +http://en.wikipedia.org/wiki/Langmuir_equation + +C++ includes: adsorption.h "; + +%feature("docstring") +cmf::water::LangmuirAdsorption::LangmuirAdsorption "LangmuirAdsorption(real K, real m) "; + +%feature("docstring") +cmf::water::LangmuirAdsorption::LangmuirAdsorption "LangmuirAdsorption(const LangmuirAdsorption &other) "; + +%feature("docstring") +cmf::water::LangmuirAdsorption::~LangmuirAdsorption "virtual +~LangmuirAdsorption() "; + +%feature("docstring") cmf::water::LangmuirAdsorption::copy "LangmuirAdsorption* copy(real m=-1) const + +returns a copy of the Adsorption object. + +If the adsorption is depending on the sorbent mass, you can give a +positive value for the sorbent mass m. If the value is not given or +negative, m is used from the original object. "; + +%feature("docstring") cmf::water::LangmuirAdsorption::freesolute "real freesolute(real xt, real V) const + +Returns the mass of dissolved tracer as a function of the total tracer +mass in the solute storage and the water volume. + +Parameters: +----------- + +xt: :math:`x_t` the total tracer mass in the storage + +V: :math:`V m^3` the water volume in the storage + +:math:`x_f` the dissolved mass of the tracer "; + +%feature("docstring") cmf::water::LangmuirAdsorption::totalsolute "real totalsolute(real xf, real V) const + +Returns the total mass of the tracer from the dissolved concetration +in tracer unit/m3. + +Parameters: +----------- + +xf: :math:`x_f` the dissolved tracer mass in the storage + +V: :math:`V m^3` the water volume in the storage + +:math:`x_t` the total mass of the tracer "; + + +// File: classcmf__core_1_1lateral__sub__surface__flux.xml +%feature("docstring") cmf_core::lateral_sub_surface_flux " + +An abstract base class for lateral subsurface fluxes. C++ includes: +subsurfacefluxes.h "; + +%feature("docstring") cmf_core::lateral_sub_surface_flux::__init__ "def __init__(self, args, kwargs) "; + +%feature("docstring") +cmf_core::lateral_sub_surface_flux::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::lateral_sub_surface_flux::__eq__ "def __eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::lateral_sub_surface_flux::__getitem__ +"def __getitem__(self, index) "; + +%feature("docstring") cmf_core::lateral_sub_surface_flux::__iter__ "def __iter__(self) "; + +%feature("docstring") cmf_core::lateral_sub_surface_flux::__repr__ "def __repr__(self) "; + +%feature("docstring") cmf_core::lateral_sub_surface_flux::conc "def +conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") +cmf_core::lateral_sub_surface_flux::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::lateral_sub_surface_flux::get_target +"def get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") +cmf_core::lateral_sub_surface_flux::get_tracer_filter "def +get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::lateral_sub_surface_flux::kill_me "def kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::lateral_sub_surface_flux::left_node "def left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::lateral_sub_surface_flux::q "def +q(self, args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::lateral_sub_surface_flux::refresh "def refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::lateral_sub_surface_flux::right_node +"def right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") +cmf_core::lateral_sub_surface_flux::set_tracer_filter "def +set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf_core::lateral_sub_surface_flux::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::lateral_sub_surface_flux::to_string "def to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf_1_1upslope_1_1connections_1_1lateral__sub__surface__flux.xml +%feature("docstring") +cmf::upslope::connections::lateral_sub_surface_flux " + +An abstract base class for lateral subsurface fluxes. + +C++ includes: subsurfacefluxes.h "; + +%feature("docstring") +cmf::upslope::connections::lateral_sub_surface_flux::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") +cmf::upslope::connections::lateral_sub_surface_flux::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr +newTarget) "; + +%feature("docstring") +cmf::upslope::connections::lateral_sub_surface_flux::get_ptr "ptr +get_ptr() const "; + +%feature("docstring") +cmf::upslope::connections::lateral_sub_surface_flux::get_target "flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") +cmf::upslope::connections::lateral_sub_surface_flux::get_target "flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") +cmf::upslope::connections::lateral_sub_surface_flux::get_tracer_filter +"real get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::lateral_sub_surface_flux::get_tracer_filter +"real get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") +cmf::upslope::connections::lateral_sub_surface_flux::kill_me "bool +kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") +cmf::upslope::connections::lateral_sub_surface_flux::left_node "flux_node::ptr left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") +cmf::upslope::connections::lateral_sub_surface_flux::q "real q(const +flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") +cmf::upslope::connections::lateral_sub_surface_flux::refresh "void +refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") +cmf::upslope::connections::lateral_sub_surface_flux::right_node "flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") +cmf::upslope::connections::lateral_sub_surface_flux::set_tracer_filter +"void set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::lateral_sub_surface_flux::set_tracer_filter +"void set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf::upslope::connections::lateral_sub_surface_flux::short_string "virtual std::string short_string() const "; + +%feature("docstring") +cmf::upslope::connections::lateral_sub_surface_flux::to_string "virtual std::string to_string() const "; + + +// File: classcmf_1_1upslope_1_1layer__list.xml +%feature("docstring") cmf::upslope::layer_list " + +A vector of layers, with array access to the properties of the layers, +for fast data exchange. + +C++ includes: layer_list.h "; + +%feature("docstring") cmf::upslope::layer_list::layer_list "layer_list(const layer_list &for_copy) + +Copy constructor. "; + +%feature("docstring") cmf::upslope::layer_list::layer_list "layer_list() + +Creates an empty layer list. "; + +%feature("docstring") cmf::upslope::layer_list::layer_list "layer_list(const cmf::water::node_list &for_copy) + +Creates a list of all soil layers from a node_list. "; + +%feature("docstring") cmf::upslope::layer_list::append "layer_list& +append(SoilLayer::ptr l) + +Appends a soil layer to the list. "; + +%feature("docstring") cmf::upslope::layer_list::begin "iterator +begin() "; + +%feature("docstring") cmf::upslope::layer_list::begin "const_iterator begin() const "; + +%feature("docstring") cmf::upslope::layer_list::clear "void clear() + +Clears the list. "; + +%feature("docstring") cmf::upslope::layer_list::end "iterator end() +"; + +%feature("docstring") cmf::upslope::layer_list::end "const_iterator +end() const "; + +%feature("docstring") cmf::upslope::layer_list::extend "layer_list& +extend(const layer_list &ll) + +Appends all soil layers of layer_list to this. "; + +%feature("docstring") cmf::upslope::layer_list::extend "layer_list& +extend(const cmf::water::node_list &nl) + +Appends all soil layers from a node_list to this. "; + +%feature("docstring") +cmf::upslope::layer_list::get_gravitational_potential "cmf::math::num_array get_gravitational_potential() const + +Returns an array containing the gravitational potential in m of all +layers in the list. "; + +%feature("docstring") cmf::upslope::layer_list::get_ice_fraction "cmf::math::num_array get_ice_fraction() const "; + +%feature("docstring") cmf::upslope::layer_list::get_K "cmf::math::num_array get_K() const + +Returns an array containing the conductivity in m/day of all layers in +the list. "; + +%feature("docstring") cmf::upslope::layer_list::get_Ksat "cmf::math::num_array get_Ksat() const + +Returns an array containing the saturated conductivity in m/day of all +layers in the list. "; + +%feature("docstring") cmf::upslope::layer_list::get_lower_boundary "cmf::math::num_array get_lower_boundary() const + +Returns an array containing the lower boundary in m below surface of +all layers in the list. "; + +%feature("docstring") cmf::upslope::layer_list::get_matrix_potential +"cmf::math::num_array get_matrix_potential() const + +Returns an array containing the matrix potential in m of all layers in +the list. "; + +%feature("docstring") cmf::upslope::layer_list::get_percolation "cmf::math::num_array get_percolation(cmf::math::Time t) const + +Returns the flux to each layer from the upper layer, or, in case of +the first layer from the surface water. "; + +%feature("docstring") cmf::upslope::layer_list::get_porosity "cmf::math::num_array get_porosity() const + +Returns an array containing the porosity in m3/m3 of all layers in the +list. "; + +%feature("docstring") cmf::upslope::layer_list::get_potential "cmf::math::num_array get_potential() const + +Returns an array containing the potentials of all layers in the list. +"; + +%feature("docstring") cmf::upslope::layer_list::get_rootfraction "cmf::math::num_array get_rootfraction() const + +Returns an array containing the rootfraction of each layer. "; + +%feature("docstring") cmf::upslope::layer_list::get_slice "layer_list get_slice(size_t first=0, size_t last=1000000, size_t +step=1) "; + +%feature("docstring") cmf::upslope::layer_list::get_theta "cmf::math::num_array get_theta() const "; + +%feature("docstring") cmf::upslope::layer_list::get_thickness "cmf::math::num_array get_thickness() const + +Returns an array containing the thickness in m of all layers in the +list. "; + +%feature("docstring") cmf::upslope::layer_list::get_upper_boundary "cmf::math::num_array get_upper_boundary() const + +Returns an array containing the upper boundary in m below surface of +all layers in the list. "; + +%feature("docstring") cmf::upslope::layer_list::get_volume "cmf::math::num_array get_volume() const Returns an array containing the volume in m3 of stored water of all layers in the list. "; -%feature("docstring") cmf::upslope::layer_list::get_wetness "cmf::math::num_array get_wetness() const +%feature("docstring") cmf::upslope::layer_list::get_wetness "cmf::math::num_array get_wetness() const + +Returns an array containing the wetness in m3 H2O/m3 pore space of all +layers in the list. "; + +%feature("docstring") cmf::upslope::layer_list::pop "SoilLayer::ptr +pop() + +Deletes the last layer from the list and returns it. "; + +%feature("docstring") cmf::upslope::layer_list::set_ice_fraction "void set_ice_fraction(const cmf::math::num_array &Value, size_t +offset=0) + +Sets the fraction of the ice content of the soil water. "; + +%feature("docstring") cmf::upslope::layer_list::set_potential "void +set_potential(const cmf::math::num_array &Value, size_t offset=0) + +Sets the potential (head) in m of layers [offset : arraysize]. "; + +%feature("docstring") cmf::upslope::layer_list::set_rootfraction "void set_rootfraction(const cmf::math::num_array &Value, size_t +offset=0) + +Sets the fraction of roots in each layer. "; + +%feature("docstring") cmf::upslope::layer_list::set_theta "void +set_theta(const cmf::math::num_array &Value, size_t offset=0) + +Sets the volumetric water content of the soil. "; + +%feature("docstring") cmf::upslope::layer_list::set_volume "void +set_volume(const cmf::math::num_array &Value, size_t offset=0) + +Sets the Volume in m3 of layers [offset : arraysize]. "; + +%feature("docstring") cmf::upslope::layer_list::set_wetness "void +set_wetness(const cmf::math::num_array &Value, size_t offset=0) + +Sets the wetness in m3/m3 of layers [offset : arraysize]. "; + +%feature("docstring") cmf::upslope::layer_list::size "size_t size() +const + +Number of layers in the list. "; + + +// File: classcmf__core_1_1layer__list.xml +%feature("docstring") cmf_core::layer_list " + +A vector of layers, with array access to the properties of the layers, +for fast data exchange. C++ includes: layer_list.h "; + +%feature("docstring") cmf_core::layer_list::__init__ "def +__init__(self, args) + +__init__(cmf::upslope::layer_list self, layer_list for_copy) -> +layer_list __init__(cmf::upslope::layer_list self) -> layer_list +__init__(cmf::upslope::layer_list self, node_list for_copy) -> +layer_list layer_list(const cmf::water::node_list &for_copy) Creates +a list of all soil layers from a node_list. "; + +%feature("docstring") cmf_core::layer_list::__add__ "def +__add__(self, other) "; + +%feature("docstring") cmf_core::layer_list::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::layer_list::__iadd__ "def +__iadd__(self, other) "; + +%feature("docstring") cmf_core::layer_list::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::layer_list::append "def append(self, +args, kwargs) + +append(layer_list self, cmf::upslope::SoilLayer::ptr l) -> layer_list +layer_list& append(SoilLayer::ptr l) Appends a soil layer to the +list. "; + +%feature("docstring") cmf_core::layer_list::clear "def clear(self, +args, kwargs) + +clear(layer_list self) void clear() Clears the list. "; + +%feature("docstring") cmf_core::layer_list::extend "def extend(self, +args) + +extend(layer_list self, layer_list ll) -> layer_list extend(layer_list +self, node_list nl) -> layer_list layer_list& extend(const +cmf::water::node_list &nl) Appends all soil layers from a node_list +to this. "; + +%feature("docstring") cmf_core::layer_list::get_percolation "def +get_percolation(self, args, kwargs) + +get_percolation(layer_list self, Time t) -> cmf::math::num_array +cmf::math::num_array get_percolation(cmf::math::Time t) const Returns +the flux to each layer from the upper layer, or, in case of the first +layer from the surface water. "; + +%feature("docstring") cmf_core::layer_list::get_slice "def +get_slice(self, args, kwargs) + +get_slice(layer_list self, size_t first=0, size_t last=1000000, size_t +step=1) -> layer_list layer_list get_slice(size_t first=0, size_t +last=1000000, size_t step=1) "; + +%feature("docstring") cmf_core::layer_list::pop "def pop(self, args, +kwargs) + +pop(layer_list self) -> cmf::upslope::SoilLayer::ptr SoilLayer::ptr +pop() Deletes the last layer from the list and returns it. "; + +%feature("docstring") cmf_core::layer_list::set_ice_fraction "def +set_ice_fraction(self, args, kwargs) + +set_ice_fraction(layer_list self, cmf::math::num_array const & Value, +size_t offset=0) void set_ice_fraction(const cmf::math::num_array +&Value, size_t offset=0) Sets the fraction of the ice content of the +soil water. "; + +%feature("docstring") cmf_core::layer_list::set_potential "def +set_potential(self, args, kwargs) + +set_potential(layer_list self, cmf::math::num_array const & Value, +size_t offset=0) void set_potential(const cmf::math::num_array +&Value, size_t offset=0) Sets the potential (head) in m of layers +[offset : arraysize]. "; + +%feature("docstring") cmf_core::layer_list::set_rootfraction "def +set_rootfraction(self, args, kwargs) + +set_rootfraction(layer_list self, cmf::math::num_array const & Value, +size_t offset=0) void set_rootfraction(const cmf::math::num_array +&Value, size_t offset=0) Sets the fraction of roots in each layer. "; + +%feature("docstring") cmf_core::layer_list::set_theta "def +set_theta(self, args, kwargs) + +set_theta(layer_list self, cmf::math::num_array const & Value, size_t +offset=0) void set_theta(const cmf::math::num_array &Value, size_t +offset=0) Sets the volumetric water content of the soil. "; + +%feature("docstring") cmf_core::layer_list::set_volume "def +set_volume(self, args, kwargs) + +set_volume(layer_list self, cmf::math::num_array const & Value, size_t +offset=0) void set_volume(const cmf::math::num_array &Value, size_t +offset=0) Sets the Volume in m3 of layers [offset : arraysize]. "; + +%feature("docstring") cmf_core::layer_list::set_wetness "def +set_wetness(self, args, kwargs) + +set_wetness(layer_list self, cmf::math::num_array const & Value, +size_t offset=0) void set_wetness(const cmf::math::num_array &Value, +size_t offset=0) Sets the wetness in m3/m3 of layers [offset : +arraysize]. "; + +%feature("docstring") cmf_core::layer_list::size "def size(self, +args, kwargs) + +size(layer_list self) -> size_t size_t size() const Number of layers +in the list. "; + + +// File: classcmf__core_1_1_layer_bypass.xml +%feature("docstring") cmf_core::LayerBypass " + +A simplification of macro pore flux for swelling soils. Connects the +surfacewater of the cell with deeper layers, assuming the presence of +cracks. At saturation level of the target layer, the cracks are closed +.. math:: q_{crack} = K_{max,crack} +\\\\\\\\left(1-\\\\\\\\left(\\\\\\\\frac{w-w_0}{1-w_0}\\\\\\\\right)^\\\\\\\\beta\\\\\\\\right) +A where: :math:`q_{crack}` is the flux from the surface water to the +target layer in m3/day :math:`K_{max,crack}` is the maximum +conductivity of the cracks in m/day :math:`w` is the actual wetness +of the target layer :math:`w_0` is saturation, where the shrinkage of +the cracks starts :math:`\\\\\\\\beta` is an empirical shape +parameter of the crack size/wetness relation :math:`A` is the area of +the cell C++ includes: Percolation.h "; + +%feature("docstring") cmf_core::LayerBypass::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::connections::LayerBypass self, +cmf::water::flux_node::ptr left, cmf::upslope::SoilLayer::ptr right, +real Kmax=100., real w0=0.0, real beta=1.0) -> LayerBypass +LayerBypass(cmf::water::flux_node::ptr left, +cmf::upslope::SoilLayer::ptr right, real Kmax=100., real w0=0.0, real +beta=1.0) Creates a layer bypass connection. Parameters: ----------- +left: The source of the flux, usually the surfacewater of the cell +right: The target soil layer Kmax: maximum conductivity of the +cracks in m/day w0: is the actual wetness of the target layer beta: +is an empirical shape parameter of the crack size/wetness relation "; + +%feature("docstring") cmf_core::LayerBypass::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::LayerBypass::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::LayerBypass::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::LayerBypass::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::LayerBypass::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::LayerBypass::conc "def conc(self, +args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") cmf_core::LayerBypass::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::LayerBypass::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::LayerBypass::get_tracer_filter "def +get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::LayerBypass::K "def K(self, args, +kwargs) + +K(LayerBypass self, real w) -> real real K(real w) the actual crack +conductivity Parameters: ----------- w: the wetness of the target +layer "; + +%feature("docstring") cmf_core::LayerBypass::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::LayerBypass::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::LayerBypass::q "def q(self, args, +kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::LayerBypass::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::LayerBypass::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::LayerBypass::set_tracer_filter "def +set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::LayerBypass::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::LayerBypass::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf_1_1upslope_1_1connections_1_1_layer_bypass.xml +%feature("docstring") cmf::upslope::connections::LayerBypass " + +A simplification of macro pore flux for swelling soils. + +Connects the surfacewater of the cell with deeper layers, assuming the +presence of cracks. At saturation level of the target layer, the +cracks are closed + +.. math:: + + q_{crack} = K_{max,crack} + \\\\left(1-\\\\left(\\\\frac{w-w_0}{1-w_0}\\\\right)^\\\\beta\\\\right) + A + +where: :math:`q_{crack}` is the flux from the surface water to the +target layer in m3/day + +:math:`K_{max,crack}` is the maximum conductivity of the cracks in m/day + +:math:`w` is the actual wetness of the target layer + +:math:`w_0` is saturation, where the shrinkage of the cracks starts + +:math:`\\\\beta` is an empirical shape parameter of the crack size/wetness +relation + +:math:`A` is the area of the cell + +C++ includes: Percolation.h "; + +%feature("docstring") +cmf::upslope::connections::LayerBypass::LayerBypass "LayerBypass(cmf::water::flux_node::ptr left, +cmf::upslope::SoilLayer::ptr right, real Kmax=100., real w0=0.0, real +beta=1.0) + +Creates a layer bypass connection. + +Parameters: +----------- + +left: The source of the flux, usually the surfacewater of the cell + +right: The target soil layer + +Kmax: maximum conductivity of the cracks in m/day + +w0: is the actual wetness of the target layer + +beta: is an empirical shape parameter of the crack size/wetness +relation "; + +%feature("docstring") cmf::upslope::connections::LayerBypass::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") +cmf::upslope::connections::LayerBypass::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf::upslope::connections::LayerBypass::get_ptr +"ptr get_ptr() const "; + +%feature("docstring") +cmf::upslope::connections::LayerBypass::get_target "flux_node::ptr +get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") +cmf::upslope::connections::LayerBypass::get_target "flux_node::ptr +get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") +cmf::upslope::connections::LayerBypass::get_tracer_filter "real +get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::LayerBypass::get_tracer_filter "real +get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") cmf::upslope::connections::LayerBypass::K "real K(real w) + +the actual crack conductivity + +Parameters: +----------- + +w: the wetness of the target layer "; + +%feature("docstring") cmf::upslope::connections::LayerBypass::kill_me +"bool kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") +cmf::upslope::connections::LayerBypass::left_node "flux_node::ptr +left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") cmf::upslope::connections::LayerBypass::q "real q(const flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") cmf::upslope::connections::LayerBypass::refresh +"void refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") +cmf::upslope::connections::LayerBypass::right_node "flux_node::ptr +right_node() const + +returns the right node of this connection "; + +%feature("docstring") +cmf::upslope::connections::LayerBypass::set_tracer_filter "void +set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::LayerBypass::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf::upslope::connections::LayerBypass::short_string "virtual +std::string short_string() const "; + +%feature("docstring") +cmf::upslope::connections::LayerBypass::to_string "virtual +std::string to_string() const "; + + +// File: classcmf__core_1_1linear__scale.xml +%feature("docstring") cmf_core::linear_scale " + +A linear scaling functor, with slope and displacement. C++ includes: +boundary_condition.h "; + +%feature("docstring") cmf_core::linear_scale::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::water::linear_scale self, real _slope=1, real +_displacement=0) -> linear_scale linear_scale(real _slope=1, real +_displacement=0) Creates a linear scale (by default it is a unity +scale, :math:`a=1; b=0`) "; + +%feature("docstring") cmf_core::linear_scale::__call__ "def +__call__(self, args, kwargs) + +__call__(linear_scale self, real value) -> real "; + + +// File: classcmf_1_1water_1_1linear__scale.xml +%feature("docstring") cmf::water::linear_scale " + +A linear scaling functor, with slope and displacement. + +C++ includes: boundary_condition.h "; + +%feature("docstring") cmf::water::linear_scale::linear_scale "linear_scale(real _slope=1, real _displacement=0) + +Creates a linear scale (by default it is a unity scale, :math:`a=1; b=0`) "; + + +// File: classcmf__core_1_1_linear_adsorption.xml +%feature("docstring") cmf_core::LinearAdsorption " + +This class calculates the adsorption equilibrium between sorbat and +sorbent using the linear (Henry) isotherme. Linear (Henry) isotherme: +.. math:: \\\\\\\\frac{x_{ad}}{m} = K c where :math:`x_{ad} = +x_{tot} - x_{free}` is the adsorbed tracer mass :math:`x_{tot}` is +the total tracer mass :math:`x_{free}` is the dissolved tracer mass +:math:`m` is the mass of the sorbent in the same unit as the tracer +mass :math:`K` is the Henry sorption coefficient :math:`c = +\\\\\\\\frac{x_{free}}{V}` is the concentration of the tracer in +tracer mass per m3 CMF stores in a solute storage the total mass of a +tracer and needs to calculate the free tracer mass. Calculating +:math:`x_{free}` from :math:`x_{tot}` gives from the eq. above: .. +math:: x_{free} = x_{tot} \\\\\\\\frac{V}{K m + V} C++ +includes: adsorption.h "; + +%feature("docstring") cmf_core::LinearAdsorption::__init__ "def +__init__(self, args) + +__init__(cmf::water::LinearAdsorption self, real K, real m) -> +LinearAdsorption __init__(cmf::water::LinearAdsorption self, +LinearAdsorption other) -> LinearAdsorption LinearAdsorption(const +LinearAdsorption &other) "; + +%feature("docstring") cmf_core::LinearAdsorption::copy "def +copy(self, args, kwargs) + +copy(LinearAdsorption self, real m=-1) -> LinearAdsorption +LinearAdsorption* copy(real m=-1) const returns a copy of the +Adsorption object. If the adsorption is depending on the sorbent +mass, you can give a positive value for the sorbent mass m. If the +value is not given or negative, m is used from the original object. "; + +%feature("docstring") cmf_core::LinearAdsorption::freesolute "def +freesolute(self, args, kwargs) + +freesolute(Adsorption self, real xt, real V) -> real virtual real +freesolute(real xt, real V) const =0 Returns the mass of dissolved +tracer as a function of the total tracer mass in the solute storage +and the water volume. Parameters: ----------- xt: :math:`x_t` the +total tracer mass in the storage V: :math:`V m^3` the water volume +in the storage :math:`x_f` the dissolved mass of the tracer "; + +%feature("docstring") cmf_core::LinearAdsorption::totalsolute "def +totalsolute(self, args, kwargs) + +totalsolute(Adsorption self, real xf, real V) -> real virtual real +totalsolute(real xf, real V) const =0 Returns the total mass of the +tracer from the dissolved concetration in tracer unit/m3. Parameters: +----------- xf: :math:`x_f` the dissolved tracer mass in the +storage V: :math:`V m^3` the water volume in the storage +:math:`x_t` the total mass of the tracer "; + + +// File: classcmf_1_1water_1_1_linear_adsorption.xml +%feature("docstring") cmf::water::LinearAdsorption " + +This class calculates the adsorption equilibrium between sorbat and +sorbent using the linear (Henry) isotherme. + +Linear (Henry) isotherme: + + + +.. math:: + + \\\\frac{x_{ad}}{m} = K c + +where :math:`x_{ad} = x_{tot} - x_{free}` is the adsorbed tracer mass :math:`x_{tot}` is the total tracer +mass + +:math:`x_{free}` is the dissolved tracer mass + +:math:`m` is the mass of the sorbent in the same unit as the tracer mass + +:math:`K` is the Henry sorption coefficient + +:math:`c = \\\\frac{x_{free}}{V}` is the concentration of the tracer in +tracer mass per m3 + +CMF stores in a solute storage the total mass of a tracer and needs to +calculate the free tracer mass. Calculating :math:`x_{free}` from :math:`x_{tot}` +gives from the eq. above: + +.. math:: + + x_{free} = x_{tot} \\\\frac{V}{K m + + V} + +C++ includes: adsorption.h "; + +%feature("docstring") cmf::water::LinearAdsorption::LinearAdsorption +"LinearAdsorption(real K, real m) "; + +%feature("docstring") cmf::water::LinearAdsorption::LinearAdsorption +"LinearAdsorption(const LinearAdsorption &other) "; + +%feature("docstring") cmf::water::LinearAdsorption::~LinearAdsorption +"virtual ~LinearAdsorption() "; + +%feature("docstring") cmf::water::LinearAdsorption::copy "LinearAdsorption* copy(real m=-1) const + +returns a copy of the Adsorption object. + +If the adsorption is depending on the sorbent mass, you can give a +positive value for the sorbent mass m. If the value is not given or +negative, m is used from the original object. "; + +%feature("docstring") cmf::water::LinearAdsorption::freesolute "real +freesolute(real xt, real V) const + +Returns the mass of dissolved tracer as a function of the total tracer +mass in the solute storage and the water volume. + +Parameters: +----------- + +xt: :math:`x_t` the total tracer mass in the storage + +V: :math:`V m^3` the water volume in the storage + +:math:`x_f` the dissolved mass of the tracer "; + +%feature("docstring") cmf::water::LinearAdsorption::totalsolute "real totalsolute(real xf, real V) const + +Returns the total mass of the tracer from the dissolved concetration +in tracer unit/m3. + +Parameters: +----------- + +xf: :math:`x_f` the dissolved tracer mass in the storage + +V: :math:`V m^3` the water volume in the storage + +:math:`x_t` the total mass of the tracer "; + + +// File: classcmf__core_1_1_linear_retention.xml +%feature("docstring") cmf_core::LinearRetention " + +The linear retention curve provides a simple linear relationship +between storage and head. Head function (head in m, calculated from +upper side control volume) .. math:: h(\\\\\\\\theta) = +-\\\\\\\\Delta z \\\\\\\\left( 1 - \\\\\\\\frac{\\\\\\\\theta - +\\\\\\\\theta_r}{\\\\\\\\theta_s - \\\\\\\\theta_r} \\\\\\\\right) +Conductivity function .. math:: K(\\\\\\\\theta) = K_{sat} +\\\\\\\\left(\\\\\\\\frac{\\\\\\\\theta - +\\\\\\\\theta_r}{\\\\\\\\theta_s - +\\\\\\\\theta_r}\\\\\\\\right)^\\\\\\\\beta C++ includes: +RetentionCurve.h "; + +%feature("docstring") cmf_core::LinearRetention::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::LinearRetention self, real ksat, real phi, real +thickness, real residual_wetness=0.1) -> LinearRetention +LinearRetention(real ksat, real phi, real thickness, real +residual_wetness=0.1) "; + +%feature("docstring") cmf_core::LinearRetention::copy "def +copy(self, args, kwargs) + +copy(LinearRetention self) -> LinearRetention LinearRetention* copy() +const "; + +%feature("docstring") cmf_core::LinearRetention::Diffusivity "def +Diffusivity(self, args) + +Diffusivity(RetentionCurve self, real wetness) -> real +Diffusivity(RetentionCurve self, cmf::math::num_array & wetness) -> +cmf::math::num_array cmf::math::num_array +Diffusivity(cmf::math::num_array &wetness) "; + +%feature("docstring") cmf_core::LinearRetention::dPsiM_dW "def +dPsiM_dW(self, args) + +dPsiM_dW(RetentionCurve self, real wetness) -> real +dPsiM_dW(RetentionCurve self, cmf::math::num_array const & wetness) -> +cmf::math::num_array cmf::math::num_array dPsiM_dW(const +cmf::math::num_array &wetness) const "; + +%feature("docstring") cmf_core::LinearRetention::FillHeight "def +FillHeight(self, args, kwargs) + +FillHeight(RetentionCurve self, real lowerDepth, real Area, real +Volume) -> real virtual real FillHeight(real lowerDepth, real Area, +real Volume) const Returns the thickness of a soil column with a +certain pore volume. "; + +%feature("docstring") cmf_core::LinearRetention::K "def K(self, +args) + +K(RetentionCurve self, real wetness) -> real K(RetentionCurve self, +cmf::math::num_array const & wetness) -> cmf::math::num_array +cmf::math::num_array K(const cmf::math::num_array &wetness) const "; + +%feature("docstring") cmf_core::LinearRetention::MatricPotential "def MatricPotential(self, args) + +MatricPotential(RetentionCurve self, real wetness) -> real +MatricPotential(RetentionCurve self, cmf::math::num_array const & +wetness) -> cmf::math::num_array cmf::math::num_array +MatricPotential(const cmf::math::num_array &wetness) const "; + +%feature("docstring") cmf_core::LinearRetention::Porosity "def +Porosity(self, args, kwargs) + +Porosity(RetentionCurve self, real depth=0.0) -> real virtual real +Porosity(real depth=0.0) const =0 Returns the porosity at a certain +depth. "; + +%feature("docstring") cmf_core::LinearRetention::theta "def +theta(self, args) + +theta(RetentionCurve self, real wetness) -> real theta(RetentionCurve +self, cmf::math::num_array const & wetness) -> cmf::math::num_array +cmf::math::num_array theta(const cmf::math::num_array &wetness) const +"; + +%feature("docstring") cmf_core::LinearRetention::Transmissivity "def +Transmissivity(self, args, kwargs) + +Transmissivity(LinearRetention self, real upperDepth, real lowerDepth, +real wetness) -> real virtual real Transmissivity(real upperDepth, +real lowerDepth, real wetness) const "; + +%feature("docstring") cmf_core::LinearRetention::VoidVolume "def +VoidVolume(self, args, kwargs) + +VoidVolume(RetentionCurve self, real upperDepth, real lowerDepth, real +Area) -> real virtual real VoidVolume(real upperDepth, real +lowerDepth, real Area) const Returns the void volume of a soil +column. "; + +%feature("docstring") cmf_core::LinearRetention::Wetness "def +Wetness(self, args) + +Wetness(RetentionCurve self, real suction) -> real +Wetness(RetentionCurve self, cmf::math::num_array const & suction) -> +cmf::math::num_array cmf::math::num_array Wetness(const +cmf::math::num_array &suction) const "; + +%feature("docstring") cmf_core::LinearRetention::Wetness_eff "def +Wetness_eff(self, args, kwargs) + +Wetness_eff(RetentionCurve self, real wetness, real pF_r=4.2) -> real +virtual real Wetness_eff(real wetness, real pF_r=4.2) const Returns +the effective wetness, using a residual pF value .. math:: w_{eff} += +\\\\\\\\frac{w_{act}-w\\\\\\\\left(pF_r\\\\\\\\right)}{1-w\\\\\\\\left(pF_r\\\\\\\\right)} +. "; + +%feature("docstring") cmf_core::LinearRetention::Wetness_pF "def +Wetness_pF(self, args) + +Wetness_pF(RetentionCurve self, real pF) -> real +Wetness_pF(RetentionCurve self, cmf::math::num_array const & pF) -> +cmf::math::num_array cmf::math::num_array Wetness_pF(const +cmf::math::num_array &pF) const "; + + +// File: classcmf_1_1upslope_1_1_linear_retention.xml +%feature("docstring") cmf::upslope::LinearRetention " + +The linear retention curve provides a simple linear relationship +between storage and head. + +Head function (head in m, calculated from upper side control volume) + + +.. math:: + + h(\\\\theta) = -\\\\Delta z \\\\left( 1 - \\\\frac{\\\\theta - + \\\\theta_r}{\\\\theta_s - \\\\theta_r} \\\\right) + +Conductivity +function + +.. math:: + + K(\\\\theta) = K_{sat} \\\\left(\\\\frac{\\\\theta - + \\\\theta_r}{\\\\theta_s - \\\\theta_r}\\\\right)^\\\\beta + +C++ includes: RetentionCurve.h "; + +%feature("docstring") cmf::upslope::LinearRetention::LinearRetention +"LinearRetention(real ksat, real phi, real thickness, real +residual_wetness=0.1) "; + +%feature("docstring") cmf::upslope::LinearRetention::~LinearRetention +"virtual ~LinearRetention() "; + +%feature("docstring") cmf::upslope::LinearRetention::copy "LinearRetention* copy() const "; + +%feature("docstring") cmf::upslope::LinearRetention::Diffusivity "virtual real Diffusivity(real wetness) const + +Returns the Diffusivity of the soil. + +Not implemented for all retention curves. Diffusivity is used by +MACROlikeMacroMicroExchange "; + +%feature("docstring") cmf::upslope::LinearRetention::Diffusivity "cmf::math::num_array Diffusivity(cmf::math::num_array &wetness) "; + +%feature("docstring") cmf::upslope::LinearRetention::dPsiM_dW "virtual real dPsiM_dW(real wetness) const "; + +%feature("docstring") cmf::upslope::LinearRetention::dPsiM_dW "cmf::math::num_array dPsiM_dW(const cmf::math::num_array &wetness) +const "; + +%feature("docstring") cmf::upslope::LinearRetention::FillHeight "virtual real FillHeight(real lowerDepth, real Area, real Volume) const + +Returns the thickness of a soil column with a certain pore volume. "; + +%feature("docstring") cmf::upslope::LinearRetention::K "cmf::math::num_array K(const cmf::math::num_array &wetness) const "; + +%feature("docstring") cmf::upslope::LinearRetention::K "virtual real +K(real wetness) const + +Returns the conductivity in m/day at a certain depth and water +content. "; + +%feature("docstring") cmf::upslope::LinearRetention::MatricPotential +"cmf::math::num_array MatricPotential(const cmf::math::num_array +&wetness) const "; + +%feature("docstring") cmf::upslope::LinearRetention::MatricPotential +"virtual real MatricPotential(real wetness) const + +Returns the potential below upper side of the control volume in m. "; + +%feature("docstring") cmf::upslope::LinearRetention::Porosity "virtual real Porosity(real depth) const + +Returns the porosity at a certain depth. "; + +%feature("docstring") cmf::upslope::LinearRetention::theta "virtual +real theta(real wetness) const + +returns the water content :math:`theta` for a given wetness "; + +%feature("docstring") cmf::upslope::LinearRetention::theta "cmf::math::num_array theta(const cmf::math::num_array &wetness) const +"; + +%feature("docstring") cmf::upslope::LinearRetention::Transmissivity "virtual real Transmissivity(real upperDepth, real lowerDepth, real +wetness) const "; + +%feature("docstring") cmf::upslope::LinearRetention::VoidVolume "virtual real VoidVolume(real upperDepth, real lowerDepth, real Area) +const + +Returns the void volume of a soil column. "; + +%feature("docstring") cmf::upslope::LinearRetention::Wetness "cmf::math::num_array Wetness(const cmf::math::num_array &suction) +const "; + +%feature("docstring") cmf::upslope::LinearRetention::Wetness "virtual real Wetness(real suction) const + +Returns the wetness (water content per pore volume) at a given head. +"; + +%feature("docstring") cmf::upslope::LinearRetention::Wetness_eff "virtual real Wetness_eff(real wetness, real pF_r=4.2) const + +Returns the effective wetness, using a residual pF value + +.. math:: + + w_{eff} + = + \\\\frac{w_{act}-w\\\\left(pF_r\\\\right)}{1-w\\\\left(pF_r\\\\right)} + +. +"; + +%feature("docstring") cmf::upslope::LinearRetention::Wetness_pF "real Wetness_pF(real pF) const + +returns the volumetric water content at a given pF value "; + +%feature("docstring") cmf::upslope::LinearRetention::Wetness_pF "cmf::math::num_array Wetness_pF(const cmf::math::num_array &pF) const +"; + + +// File: classcmf__core_1_1_linear_storage_connection.xml +%feature("docstring") cmf_core::LinearStorageConnection " + +Calculates flux out of a storage as a linear function of its volume. +This connection serves the same purpose as the old kinematic_wave +connection, but the parameters are easier to explain .. math:: q = +\\\\\\\\frac{V - V_{residual}}{t_r} where: :math:`V` The actual +volume of water stored in source :math:`V_{residual} [m^3]` The +volume of water not flowing out (default = 0) :math:`t_r` is the +residence time in the source. C++ includes: simple_connections.h "; + +%feature("docstring") cmf_core::LinearStorageConnection::__init__ "def __init__(self, args, kwargs) + +__init__(cmf::water::LinearStorageConnection self, +cmf::water::WaterStorage::ptr source, cmf::water::flux_node::ptr +target, real residencetime, real residual=0.0) -> +LinearStorageConnection LinearStorageConnection(WaterStorage::ptr +source, flux_node::ptr target, real residencetime, real residual=0.0) +Creates a linear storage connection or Nash-box. .. math:: q += \\\\\\\\frac{V - V_{residual}}{t_r}} Parameters: ----------- +source: Water storage from which the water flows out. Flux is a +function of source.volume target: Target node (boundary condition or +storage). Does not influence the strength of the flow residencetime: +:math:`t_r [days]` The residence time of the water in this storage +residual: :math:`V_{residual} [m^3]` The volume of water not flowing +out (default = 0) "; + +%feature("docstring") cmf_core::LinearStorageConnection::__contains__ +"def __contains__(self, cmp) "; + +%feature("docstring") cmf_core::LinearStorageConnection::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::LinearStorageConnection::__getitem__ +"def __getitem__(self, index) "; + +%feature("docstring") cmf_core::LinearStorageConnection::__iter__ "def __iter__(self) "; + +%feature("docstring") cmf_core::LinearStorageConnection::__repr__ "def __repr__(self) "; + +%feature("docstring") cmf_core::LinearStorageConnection::conc "def +conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") +cmf_core::LinearStorageConnection::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::LinearStorageConnection::get_target "def get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") +cmf_core::LinearStorageConnection::get_tracer_filter "def +get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::LinearStorageConnection::kill_me "def kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::LinearStorageConnection::left_node "def left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::LinearStorageConnection::q "def +q(self, args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::LinearStorageConnection::refresh "def refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::LinearStorageConnection::right_node "def right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") +cmf_core::LinearStorageConnection::set_tracer_filter "def +set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::LinearStorageConnection::short_string +"def short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::LinearStorageConnection::to_string "def to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf_1_1water_1_1_linear_storage_connection.xml +%feature("docstring") cmf::water::LinearStorageConnection " + +Calculates flux out of a storage as a linear function of its volume. + +This connection serves the same purpose as the old kinematic_wave +connection, but the parameters are easier to explain + + + +.. math:: + + q = \\\\frac{V - V_{residual}}{t_r} + +where: :math:`V` The actual +volume of water stored in source + +:math:`V_{residual} [m^3]` The volume of water not flowing out (default = 0) +:math:`t_r` is the residence time in the source. + +C++ includes: simple_connections.h "; + +%feature("docstring") +cmf::water::LinearStorageConnection::LinearStorageConnection "LinearStorageConnection(WaterStorage::ptr source, flux_node::ptr +target, real residencetime, real residual=0.0) + +Creates a linear storage connection or Nash-box. + + + +.. math:: + + q = \\\\frac{V - V_{residual}}{t_r}} + +Parameters: +----------- + +source: Water storage from which the water flows out. Flux is a +function of source.volume + +target: Target node (boundary condition or storage). Does not +influence the strength of the flow + +residencetime: :math:`t_r [days]` The residence time of the water in this +storage + +residual: :math:`V_{residual} [m^3]` The volume of water not flowing out +(default = 0) "; + +%feature("docstring") cmf::water::LinearStorageConnection::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") +cmf::water::LinearStorageConnection::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf::water::LinearStorageConnection::get_ptr "ptr get_ptr() const "; + +%feature("docstring") cmf::water::LinearStorageConnection::get_target +"flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") cmf::water::LinearStorageConnection::get_target +"flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") +cmf::water::LinearStorageConnection::get_tracer_filter "real +get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::water::LinearStorageConnection::get_tracer_filter "real +get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") cmf::water::LinearStorageConnection::kill_me "bool kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") cmf::water::LinearStorageConnection::left_node +"flux_node::ptr left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") cmf::water::LinearStorageConnection::q "real +q(const flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") cmf::water::LinearStorageConnection::refresh "void refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") cmf::water::LinearStorageConnection::right_node +"flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") +cmf::water::LinearStorageConnection::set_tracer_filter "void +set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::water::LinearStorageConnection::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf::water::LinearStorageConnection::short_string "virtual +std::string short_string() const "; + +%feature("docstring") cmf::water::LinearStorageConnection::to_string +"virtual std::string to_string() const "; + + +// File: classcmf__core_1_1log__wind__profile.xml +%feature("docstring") cmf_core::log_wind_profile " + +, A logarithmic wind profile Todo Cite literature for this +windprofile and insert equation C++ includes: ET.h "; + +%feature("docstring") cmf_core::log_wind_profile::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::atmosphere::log_wind_profile self, Cell _cell) -> +log_wind_profile log_wind_profile(cmf::upslope::Cell &_cell) "; + +%feature("docstring") +cmf_core::log_wind_profile::get_aerodynamic_resistance "def +get_aerodynamic_resistance(self, args, kwargs) + +get_aerodynamic_resistance(aerodynamic_resistance self, double & r_ag, +double & r_ac, Time t) virtual void get_aerodynamic_resistance(double +&r_ag, double &r_ac, cmf::math::Time t) const =0 aerodynamic +resistance from ground to atmosphere (r_ag) and from canopy to +atmosphere (r_ac) "; + + +// File: classcmf_1_1atmosphere_1_1log__wind__profile.xml +%feature("docstring") cmf::atmosphere::log_wind_profile " + +, A logarithmic wind profile + +Todo Cite literature for this windprofile and insert equation + +C++ includes: ET.h "; + +%feature("docstring") +cmf::atmosphere::log_wind_profile::log_wind_profile "log_wind_profile(cmf::upslope::Cell &_cell) "; + +%feature("docstring") +cmf::atmosphere::log_wind_profile::~log_wind_profile "virtual +~log_wind_profile() "; + +%feature("docstring") +cmf::atmosphere::log_wind_profile::get_aerodynamic_resistance "virtual void get_aerodynamic_resistance(double &r_ag, double &r_ac, +cmf::math::Time t) const + +aerodynamic resistance from ground to atmosphere (r_ag) and from +canopy to atmosphere (r_ac) "; + + +// File: classcmf_1_1upslope_1_1connections_1_1_m_a_c_r_olike_macro_micro_exchange.xml +%feature("docstring") +cmf::upslope::connections::MACROlikeMacroMicroExchange " + +This connection models the water exchange between macropores and +micropores as in the MACRO Model (Larsbo & Jarvis, 2003), which +follows Gerke & van Genuchten 1996. + +WARNING: Deprecated This connection uses the diffusivity of a soil +given by its retention curve. Since no retention curve provides a +valid value for Diffusivity in case of saturation this connection will +blow up the numerical solution for sure. + +The exchange between Macropore and matrix is defined as follows: +(MACRO 5 Tech report, Larsbo & Jarvis 2003) + + + +.. math:: + + q = \\\\frac{G_f D_w \\\\gamma_w}{d^2}(\\\\theta_b - + \\\\theta_{mi}) V_{layer} + +where: :math:`G_f` is the geometry factor. +Use 3 for a rectangular slab geometry + +:math:`gamma_w` A scaling factor to fit analytical and numerical solution +(0.4) + +:math:`d` is an effective diffusive path length related to aggregate size +and the influence of coatings on the aggregate surfaces in m + +:math:`\\\\theta_b` the saturated water content of the matrix + +:math:`\\\\theta_{mi}` the actual water content of the matrix + +:math:`D_w = \\\\frac12(D(\\\\theta_b)+D(\\\\theta_{mi})W_{ma})` is the +effective water diffusivity in m2/day, as defined below :math:`W_{ma}` is +the saturation of the macropores + +C++ includes: macropore.h "; + +%feature("docstring") +cmf::upslope::connections::MACROlikeMacroMicroExchange::MACROlikeMacroMicroExchange +"MACROlikeMacroMicroExchange(cmf::upslope::SoilLayer::ptr left, +cmf::upslope::MacroPore::ptr right, real _gamma_w=0.4, real _Gf=3) "; + +%feature("docstring") +cmf::upslope::connections::MACROlikeMacroMicroExchange::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") +cmf::upslope::connections::MACROlikeMacroMicroExchange::exchange_target +"void exchange_target(flux_node::ptr oldtarget, flux_node::ptr +newTarget) "; + +%feature("docstring") +cmf::upslope::connections::MACROlikeMacroMicroExchange::get_ptr "ptr +get_ptr() const "; + +%feature("docstring") +cmf::upslope::connections::MACROlikeMacroMicroExchange::get_target "flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") +cmf::upslope::connections::MACROlikeMacroMicroExchange::get_target "flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") +cmf::upslope::connections::MACROlikeMacroMicroExchange::get_tracer_filter +"real get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::MACROlikeMacroMicroExchange::get_tracer_filter +"real get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") +cmf::upslope::connections::MACROlikeMacroMicroExchange::kill_me "bool +kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") +cmf::upslope::connections::MACROlikeMacroMicroExchange::left_node "flux_node::ptr left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") +cmf::upslope::connections::MACROlikeMacroMicroExchange::q "real +q(const flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") +cmf::upslope::connections::MACROlikeMacroMicroExchange::refresh "void +refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") +cmf::upslope::connections::MACROlikeMacroMicroExchange::right_node "flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") +cmf::upslope::connections::MACROlikeMacroMicroExchange::set_tracer_filter +"void set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::MACROlikeMacroMicroExchange::set_tracer_filter +"void set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf::upslope::connections::MACROlikeMacroMicroExchange::short_string "virtual std::string short_string() const "; + +%feature("docstring") +cmf::upslope::connections::MACROlikeMacroMicroExchange::to_string "virtual std::string to_string() const "; + + +// File: classcmf__core_1_1_m_a_c_r_olike_macro_micro_exchange.xml +%feature("docstring") cmf_core::MACROlikeMacroMicroExchange " + +This connection models the water exchange between macropores and +micropores as in the MACRO Model (Larsbo & Jarvis, 2003), which +follows Gerke & van Genuchten 1996. WARNING: Deprecated This +connection uses the diffusivity of a soil given by its retention +curve. Since no retention curve provides a valid value for Diffusivity +in case of saturation this connection will blow up the numerical +solution for sure. The exchange between Macropore and matrix is +defined as follows: (MACRO 5 Tech report, Larsbo & Jarvis 2003) .. +math:: q = \\\\\\\\frac{G_f D_w +\\\\\\\\gamma_w}{d^2}(\\\\\\\\theta_b - \\\\\\\\theta_{mi}) +V_{layer} where: :math:`G_f` is the geometry factor. Use 3 for a +rectangular slab geometry :math:`gamma_w` A scaling factor to fit +analytical and numerical solution (0.4) :math:`d` is an effective +diffusive path length related to aggregate size and the influence of +coatings on the aggregate surfaces in m :math:`\\\\\\\\theta_b` the +saturated water content of the matrix :math:`\\\\\\\\theta_{mi}` the +actual water content of the matrix :math:`D_w = +\\\\\\\\frac12(D(\\\\\\\\theta_b)+D(\\\\\\\\theta_{mi})W_{ma})` is the +effective water diffusivity in m2/day, as defined below :math:`W_{ma}` +is the saturation of the macropores C++ includes: macropore.h "; + +%feature("docstring") cmf_core::MACROlikeMacroMicroExchange::__init__ +"def __init__(self, args, kwargs) + +__init__(cmf::upslope::connections::MACROlikeMacroMicroExchange self, +cmf::upslope::SoilLayer::ptr left, cmf::upslope::MacroPore::ptr right, +real _gamma_w=0.4, real _Gf=3) -> MACROlikeMacroMicroExchange +MACROlikeMacroMicroExchange(cmf::upslope::SoilLayer::ptr left, +cmf::upslope::MacroPore::ptr right, real _gamma_w=0.4, real _Gf=3) "; + +%feature("docstring") +cmf_core::MACROlikeMacroMicroExchange::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::MACROlikeMacroMicroExchange::__eq__ "def __eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") +cmf_core::MACROlikeMacroMicroExchange::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::MACROlikeMacroMicroExchange::__iter__ +"def __iter__(self) "; + +%feature("docstring") cmf_core::MACROlikeMacroMicroExchange::__repr__ +"def __repr__(self) "; + +%feature("docstring") cmf_core::MACROlikeMacroMicroExchange::conc "def conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") +cmf_core::MACROlikeMacroMicroExchange::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") +cmf_core::MACROlikeMacroMicroExchange::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") +cmf_core::MACROlikeMacroMicroExchange::get_tracer_filter "def +get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::MACROlikeMacroMicroExchange::kill_me +"def kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") +cmf_core::MACROlikeMacroMicroExchange::left_node "def left_node(self, +args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::MACROlikeMacroMicroExchange::q "def +q(self, args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::MACROlikeMacroMicroExchange::refresh +"def refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") +cmf_core::MACROlikeMacroMicroExchange::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") +cmf_core::MACROlikeMacroMicroExchange::set_tracer_filter "def +set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf_core::MACROlikeMacroMicroExchange::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") +cmf_core::MACROlikeMacroMicroExchange::to_string "def to_string(self, +args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf__core_1_1_macro_pore.xml +%feature("docstring") cmf_core::MacroPore " + +An additional water storage for a soil layer to model matrix water and +macro pore water seperately. Deprecated The MacroPore model is still +very experimental and not stable. Only for tryouts! If present, the +soil layer water storage holds the matrix water and the MacroPore +holds the water in the macro pore. Use cmf::upslope::Macropore::create +to create a macropore storage. Use +cmf::upslope::connections::GradientMacroFlow or +cmf::upslope::connections::KinematicMacroFlow to model water flow +between macro pores and a lateral connection ( lateral subsurface +fluxes) like cmf::upslope::connections::Richards_lateral to connect +the macro pore with the matrix. C++ includes: macropore.h "; + +%feature("docstring") cmf_core::MacroPore::__init__ "def +__init__(self, args, kwargs) "; + +%feature("docstring") cmf_core::MacroPore::__call__ "def +__call__(self, args, kwargs) + +__call__(flux_node self, Time t) -> real "; + +%feature("docstring") cmf_core::MacroPore::__eq__ "def __eq__(self, +args, kwargs) + +__eq__(flux_node self, flux_node other) -> bool "; + +%feature("docstring") cmf_core::MacroPore::__getitem__ "def +__getitem__(self, args, kwargs) + +__getitem__(WaterStorage self, solute X) -> SoluteStorage "; + +%feature("docstring") cmf_core::MacroPore::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::MacroPore::cast "def cast(args, +kwargs) + +cast(cmf::water::flux_node::ptr node) -> cmf::upslope::MacroPore::ptr +"; + +%feature("docstring") cmf_core::MacroPore::conc "def conc(self, +args, kwargs) + +conc(flux_node self, Time t, solute Solute) -> real virtual real +conc(cmf::math::Time t, const cmf::water::solute &Solute) const +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; + +%feature("docstring") cmf_core::MacroPore::conc "def conc(self, +args) + +conc(WaterStorage self, solute _Solute) -> real conc(WaterStorage +self, Time t, solute _Solute) -> real conc(WaterStorage self, solute +_Solute, real NewConcetration) void conc(const cmf::water::solute +&_Solute, real NewConcetration) Sets a new concentration. "; + +%feature("docstring") cmf_core::MacroPore::connected_nodes "def +connected_nodes(self) "; + +%feature("docstring") cmf_core::MacroPore::connection_to "def +connection_to(self, args, kwargs) + +connection_to(flux_node self, flux_node target) -> flux_connection +cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) Returns the connection between this and target. "; + +%feature("docstring") cmf_core::MacroPore::create "def create(args, +kwargs) + +create(cmf::upslope::SoilLayer::ptr layer, real porefraction=0.05, +real Ksat=10, real density=0.05, real porefraction_wilt=-1., real +K_shape=0.0) -> cmf::upslope::MacroPore::ptr "; + +%feature("docstring") cmf_core::MacroPore::dxdt "def dxdt(self, +args, kwargs) + +dxdt(StateVariable self, Time time) -> real virtual real dxdt(const +cmf::math::Time &time)=0 Returns the derivate of the state variable +at time time. "; + +%feature("docstring") cmf_core::MacroPore::flux3d_to "def +flux3d_to(self, args, kwargs) + +flux3d_to(flux_node self, flux_node target, Time t) -> point +cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; + +%feature("docstring") cmf_core::MacroPore::flux_to "def +flux_to(self, args, kwargs) + +flux_to(flux_node self, flux_node target, Time t) -> real real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; + +%feature("docstring") cmf_core::MacroPore::fluxes "def fluxes(self, +t) "; + +%feature("docstring") cmf_core::MacroPore::from_node "def +from_node(args, kwargs) + +from_node(cmf::water::flux_node::ptr node) -> std::shared_ptr< +cmf::water::WaterStorage > "; + +%feature("docstring") cmf_core::MacroPore::get_3d_flux "def +get_3d_flux(self, args, kwargs) + +get_3d_flux(flux_node self, Time t) -> point cmf::geometry::point +get_3d_flux(cmf::math::Time t) Returns the sum of all flux vectors. +"; + +%feature("docstring") cmf_core::MacroPore::get_abs_errtol "def +get_abs_errtol(self, args, kwargs) + +get_abs_errtol(StateVariable self, real rel_errtol) -> real virtual +real get_abs_errtol(real rel_errtol) const "; + +%feature("docstring") cmf_core::MacroPore::get_crackwidth "def +get_crackwidth(self, args, kwargs) + +get_crackwidth(MacroPore self) -> real virtual real get_crackwidth() +const Returns the crack width for a prismatic crackstructure. For a +prismatic crack structure, the porefraction in m3/m3 equals the +vertical crack area in m2/m2. The length of equally spaced cracks is +in one direction the inverse of the density and twice the length for +two directions. .. math:: l_{crack} [m/m^2]= 2 \\\\\\\\frac +{1}{d[m]} If we again ignore the fact that the spacing of the +cracking crossings is counted double, the crack width is: .. math:: +w_{crack}[m] = \\\\\\\\frac{A_{crack}[m^2/m^2]}{l_{crack}[m/m^2]} +Combining both eq. above: .. math:: w_{crack}[m] = +A_{crack}[m^2/m^2]\\\\\\\\frac{d[m]}{2} "; + +%feature("docstring") cmf_core::MacroPore::get_flowwidth "def +get_flowwidth(self, args, kwargs) + +get_flowwidth(MacroPore self) -> real real get_flowwidth() const The +approximate length of the aggregate boundaries. .. math:: l = +\\\\\\\\frac{2}{d_{macro}} A where: :math:`l` is the length of the +aggregate boundaries (in m) :math:`2` is the number of directions +:math:`d_{macro}` is the mean distance between macropores (density) in +m :math:`A` is the area of the cell "; + +%feature("docstring") cmf_core::MacroPore::get_K "def get_K(self, +args, kwargs) + +get_K(MacroPore self, point direction) -> real virtual real +get_K(cmf::geometry::point direction) const Returns the actual +anisotropic conductivity along a direction :math:`K = (k_f +\\\\\\\\cdot d) K`. "; + +%feature("docstring") cmf_core::MacroPore::get_porefraction "def +get_porefraction(self, args, kwargs) + +get_porefraction(MacroPore self) -> real real get_porefraction() +const The fraction of the macro pores in m3/m3. This adds to the +porosity of the layer. "; + +%feature("docstring") cmf_core::MacroPore::get_states "def +get_states(self, args, kwargs) + +get_states(StateVariableOwner self) -> StateVariableList virtual +StateVariableList get_states()=0 Add the state variables, owned by an +object derived from StateVariableOwner, to the given vector. "; + +%feature("docstring") cmf_core::MacroPore::is_connected "def +is_connected(self, args, kwargs) + +is_connected(StateVariable self, StateVariable other) -> bool virtual +bool is_connected(const cmf::math::StateVariable &other) const "; + +%feature("docstring") cmf_core::MacroPore::is_empty "def +is_empty(self, args, kwargs) + +is_empty(flux_node self) -> double virtual double is_empty() const +Returns true if the node has no water. "; + +%feature("docstring") cmf_core::MacroPore::is_storage "def +is_storage(self, args, kwargs) + +is_storage(flux_node self) -> bool virtual bool is_storage() const +true, if this is a waterstorage "; + +%feature("docstring") cmf_core::MacroPore::RecalcFluxes "def +RecalcFluxes(self, args, kwargs) + +RecalcFluxes(flux_node self, Time t) -> bool virtual bool +RecalcFluxes(cmf::math::Time t) Pure flux_nodes do not influence +fluxes, therefore no recalculation of fluxes is required by flux_node. +WaterStorage overrides this, since state changes require an update of +the fluxes "; + +%feature("docstring") cmf_core::MacroPore::remove_connection "def +remove_connection(self, args, kwargs) + +remove_connection(flux_node self, cmf::water::flux_node::ptr To) -> +bool bool remove_connection(cmf::water::flux_node::ptr To) Remove +the connection. "; + +%feature("docstring") cmf_core::MacroPore::Solute "def Solute(self, +args) + +Solute(WaterStorage self, solute _Solute) -> SoluteStorage +Solute(WaterStorage self, solute _Solute) -> SoluteStorage const +SoluteStorage& Solute(const cmf::water::solute _Solute) const "; + +%feature("docstring") cmf_core::MacroPore::to_string "def +to_string(self, args, kwargs) + +to_string(StateVariable self) -> std::string virtual std::string +to_string() const =0 "; + +%feature("docstring") cmf_core::MacroPore::to_string "def +to_string(self, args, kwargs) + +to_string(flux_node self) -> std::string virtual std::string +to_string() const "; + +%feature("docstring") cmf_core::MacroPore::waterbalance "def +waterbalance(self, args, kwargs) + +waterbalance(flux_node self, Time t, flux_connection Without=None) -> +real real waterbalance(cmf::math::Time t, const flux_connection +*Without=0) const Returns the sum of all fluxes (positive and +negative) at time t. Single fluxes can be excluded from the +calculation Parameters: ----------- t: Time of the query Without: +A flux_connection that is excluded from the waterbalance (e.g. to +prevent closed circuits) "; + + +// File: classcmf_1_1upslope_1_1_macro_pore.xml +%feature("docstring") cmf::upslope::MacroPore " + +An additional water storage for a soil layer to model matrix water and +macro pore water seperately. + +Deprecated The MacroPore model is still very experimental and not +stable. Only for tryouts! + +If present, the soil layer water storage holds the matrix water and +the MacroPore holds the water in the macro pore. Use +cmf::upslope::Macropore::create to create a macropore storage. + +Use cmf::upslope::connections::GradientMacroFlow or +cmf::upslope::connections::KinematicMacroFlow to model water flow +between macro pores and a lateral connection ( lateral subsurface +fluxes) like cmf::upslope::connections::Richards_lateral to connect +the macro pore with the matrix. + +C++ includes: macropore.h "; + +/* Overrides of flux_node */ + +%feature("docstring") cmf::upslope::MacroPore::RecalcFluxes "virtual +bool RecalcFluxes(cmf::math::Time t) + +Pure flux_nodes do not influence fluxes, therefore no recalculation of +fluxes is required by flux_node. + +WaterStorage overrides this, since state changes require an update of +the fluxes "; + +%feature("docstring") cmf::upslope::MacroPore::is_empty "virtual +double is_empty() const + +Returns true if the node has no water. "; + +%feature("docstring") cmf::upslope::MacroPore::to_string "virtual +std::string to_string() const "; + +%feature("docstring") cmf::upslope::MacroPore::add_connected_states "virtual void add_connected_states(cmf::math::StateVariable::list +&states) "; + +%feature("docstring") cmf::upslope::MacroPore::conc "real conc(const +cmf::water::solute &_Solute) const + +Returns the concentration of the given solute. "; + +%feature("docstring") cmf::upslope::MacroPore::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) const + +Returns the current WaterQuality (concentration of all solutes) "; + +%feature("docstring") cmf::upslope::MacroPore::conc "void conc(const +cmf::water::solute &_Solute, real NewConcetration) + +Sets a new concentration. "; + +%feature("docstring") cmf::upslope::MacroPore::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) + +Returns the connection between this and target. "; + +%feature("docstring") cmf::upslope::MacroPore::dxdt "virtual real +dxdt(const cmf::math::Time &time) "; + +%feature("docstring") cmf::upslope::MacroPore::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; + +%feature("docstring") cmf::upslope::MacroPore::flux_to "real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) + +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; + +%feature("docstring") cmf::upslope::MacroPore::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) + +Returns the sum of all flux vectors. "; + +%feature("docstring") cmf::upslope::MacroPore::get_abs_errtol "virtual real get_abs_errtol(real rel_errtol) const "; + +%feature("docstring") cmf::upslope::MacroPore::get_capacity "real +get_capacity() const + +Returns the capacity of the macropores in m3. + + + +.. math:: + + V_{max} = \\\\Phi_{macro} A \\\\Delta z + +where: :math:`V_{max}` is +the water capacity of the macropore + +:math:`\\\\Phi_{macro}` is the fraction of macro pores in the soil in :math:`m^3 macro pores/m^3 soil` + +:math:`A \\\\Delta z` is the total volume of the soil layer (including all +pores) in :math:`m^3` "; + +%feature("docstring") cmf::upslope::MacroPore::get_cell "cmf::upslope::Cell& get_cell() const + +The cell of this macropore. "; + +%feature("docstring") cmf::upslope::MacroPore::get_connections "cmf::water::connection_list get_connections() const "; + +%feature("docstring") cmf::upslope::MacroPore::get_crackwidth "virtual real get_crackwidth() const + +Returns the crack width for a prismatic crackstructure. + +For a prismatic crack structure, the porefraction in m3/m3 equals the +vertical crack area in m2/m2. The length of equally spaced cracks is +in one direction the inverse of the density and twice the length for +two directions. + +.. math:: + + l_{crack} [m/m^2]= 2 \\\\frac {1}{d[m]} + +If +we again ignore the fact that the spacing of the cracking crossings is +counted double, the crack width is: + +.. math:: + + w_{crack}[m] = + \\\\frac{A_{crack}[m^2/m^2]}{l_{crack}[m/m^2]} + +Combining both +eq. above: + +.. math:: + + w_{crack}[m] = A_{crack}[m^2/m^2]\\\\frac{d[m]}{2} + + +"; + +%feature("docstring") cmf::upslope::MacroPore::get_filled_fraction "real get_filled_fraction() const + +Get the relative water content in the macro pore :math:`\\\\theta_{macro} = V_{macro}/V_{max}`. "; + +%feature("docstring") cmf::upslope::MacroPore::get_flowwidth "real +get_flowwidth() const + +The approximate length of the aggregate boundaries. + + + +.. math:: + + l = \\\\frac{2}{d_{macro}} A + +where: :math:`l` is the length of +the aggregate boundaries (in m) + +:math:`2` is the number of directions + +:math:`d_{macro}` is the mean distance between macropores (density) in m + +:math:`A` is the area of the cell "; + +%feature("docstring") cmf::upslope::MacroPore::get_K "virtual real +get_K() const + +Returns the actual conductivity. "; + +%feature("docstring") cmf::upslope::MacroPore::get_K "virtual real +get_K(cmf::geometry::point direction) const + +Returns the actual anisotropic conductivity along a direction :math:`K = (k_f \\\\cdot d) K`. "; + +%feature("docstring") cmf::upslope::MacroPore::get_layer "SoilLayer::ptr get_layer() const + +Gets the soil layer (matrix water storage) for this macropore storage. +"; + +%feature("docstring") cmf::upslope::MacroPore::get_porefraction "real get_porefraction() const + +The fraction of the macro pores in m3/m3. This adds to the porosity of +the layer. "; + +%feature("docstring") cmf::upslope::MacroPore::get_potential "real +get_potential() const + +Returns the actual water level in the macropore in m above reference. +"; + +%feature("docstring") cmf::upslope::MacroPore::get_project "cmf::project& get_project() const + +Returns the project, this node is part of. "; + +%feature("docstring") cmf::upslope::MacroPore::get_state "real +get_state() const "; + +%feature("docstring") +cmf::upslope::MacroPore::get_state_variable_content "char +get_state_variable_content() const + +A character indicating the integrated variable (either 'V' for Volume +or 'h' for head) "; + +%feature("docstring") cmf::upslope::MacroPore::get_states "cmf::math::StateVariableList get_states() + +Add the state variables, owned by an object derived from +StateVariableOwner, to the given vector. "; + +%feature("docstring") cmf::upslope::MacroPore::get_volume "real +get_volume() const + +Returns the actual stored volume in this macropore in m3. "; + +%feature("docstring") cmf::upslope::MacroPore::is_connected "virtual +bool is_connected(const cmf::math::StateVariable &other) const + +Returns True if this waterstorage is effected by another state. "; + +%feature("docstring") cmf::upslope::MacroPore::is_storage "virtual +bool is_storage() const + +Returns true, since this is a storage. "; + +%feature("docstring") cmf::upslope::MacroPore::remove_connection "bool remove_connection(cmf::water::flux_node::ptr To) + +Remove the connection. "; + +%feature("docstring") cmf::upslope::MacroPore::set_potential "void +set_potential(real waterhead) + +Sets the water level in the macropore. Be aware of not setting it +below the lower boundary. "; + +%feature("docstring") cmf::upslope::MacroPore::set_state "void +set_state(real newState) "; + +%feature("docstring") +cmf::upslope::MacroPore::set_state_variable_content "void +set_state_variable_content(char content) + +A character indicating the integrated variable (either 'V' for Volume +or 'h' for head) "; + +%feature("docstring") cmf::upslope::MacroPore::set_volume "void +set_volume(real volume) + +Sets the volume of stored water in m3. "; + +%feature("docstring") cmf::upslope::MacroPore::Solute "SoluteStorage& Solute(const cmf::water::solute _Solute) + +Returns the water quality of the water storage. "; + +%feature("docstring") cmf::upslope::MacroPore::Solute "const +SoluteStorage& Solute(const cmf::water::solute _Solute) const "; + +%feature("docstring") cmf::upslope::MacroPore::waterbalance "real +waterbalance(cmf::math::Time t, const flux_connection *Without=0) +const + +Returns the sum of all fluxes (positive and negative) at time t. + +Single fluxes can be excluded from the calculation + +Parameters: +----------- + +t: Time of the query + +Without: A flux_connection that is excluded from the waterbalance +(e.g. to prevent closed circuits) "; + + +// File: classcmf__core_1_1_manning.xml +%feature("docstring") cmf_core::Manning " + +Calculates the flux between two open water bodies, using Manning's +equation. This is the base class for a kinematic wave approach +(topography driven) and a diffusive wave approach (water table +driven). The only difference between both approaches is the +calculation of the flux driving slope. For the model, one of +ManningKinematic or ManningDiffusive connection is selected .. +math:: v = R^{\\\\\\\\frac 2 3} +\\\\\\\\frac{\\\\\\\\sqrt{\\\\\\\\Delta_z}}{n} \\\\\\\\\\\\\\\\ q = v +\\\\\\\\cdot A Where: :math:`A = \\\\\\\\frac V l`: Crosssectional +area of the wetted crossection, Volume per length :math:`R = +\\\\\\\\frac A{P(d)}`: The hydraulic radius :math:`P(d)`: the +perimeter of the wetted crosssection, a function of reach depth +:math:`d(V)`: the depth of the reach, a function of the volume +:math:`\\\\\\\\Delta_z = \\\\\\\\frac{|z_1 - z_2|}{l}`: Slope of the +reach :math:`n`: Manning friction number For the kinematic wave the +slope of the river bed is used as slope: .. math:: \\\\\\\\Delta_z = +\\\\\\\\frac{|z_1 - z_2|}{l} while for the diffusive wave the slope +is calculated from the actual water head: .. math:: +\\\\\\\\Delta_z = \\\\\\\\frac{|h_1 - h_2|}{l} C++ includes: +ManningConnection.h "; + +%feature("docstring") cmf_core::Manning::__init__ "def +__init__(self, args, kwargs) "; + +%feature("docstring") cmf_core::Manning::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::Manning::__eq__ "def __eq__(self, +args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::Manning::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::Manning::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::Manning::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::Manning::conc "def conc(self, args, +kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") cmf_core::Manning::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::Manning::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::Manning::get_tracer_filter "def +get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::Manning::kill_me "def kill_me(self, +args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::Manning::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::Manning::q "def q(self, args, +kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::Manning::refresh "def refresh(self, +args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::Manning::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::Manning::set_tracer_filter "def +set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::Manning::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::Manning::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf_1_1river_1_1_manning.xml +%feature("docstring") cmf::river::Manning " + +Calculates the flux between two open water bodies, using Manning's +equation. + +This is the base class for a kinematic wave approach (topography +driven) and a diffusive wave approach (water table driven). The only +difference between both approaches is the calculation of the flux +driving slope. For the model, one of ManningKinematic or +ManningDiffusive connection is selected + +.. math:: + + v = R^{\\\\frac 2 3} + \\\\frac{\\\\sqrt{\\\\Delta_z}}{n} \\\\\\\\ q = v \\\\cdot A + +Where: :math:`A = \\\\frac V l`: Crosssectional area of the wetted +crossection, Volume per length + +:math:`R = \\\\frac A{P(d)}`: The hydraulic radius + +:math:`P(d)`: the perimeter of the wetted crosssection, a function of reach +depth + +:math:`d(V)`: the depth of the reach, a function of the volume + +:math:`\\\\Delta_z = \\\\frac{|z_1 - z_2|}{l}`: Slope of the reach + +:math:`n`: Manning friction number + +For the kinematic wave the slope of the river bed is used as slope: + + +.. math:: + + \\\\Delta_z = \\\\frac{|z_1 - z_2|}{l} + +while for the diffusive wave the slope is calculated from the actual +water head: + +.. math:: + + \\\\Delta_z = \\\\frac{|h_1 - h_2|}{l} + +C++ includes: ManningConnection.h "; + +%feature("docstring") cmf::river::Manning::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") cmf::river::Manning::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf::river::Manning::get_ptr "ptr get_ptr() +const "; + +%feature("docstring") cmf::river::Manning::get_target "flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") cmf::river::Manning::get_target "flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") cmf::river::Manning::get_tracer_filter "real +get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") cmf::river::Manning::get_tracer_filter "real +get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") cmf::river::Manning::kill_me "bool kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") cmf::river::Manning::left_node "flux_node::ptr +left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") cmf::river::Manning::q "real q(const flux_node +&inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") cmf::river::Manning::refresh "void +refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") cmf::river::Manning::right_node "flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") cmf::river::Manning::set_tracer_filter "void +set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") cmf::river::Manning::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf::river::Manning::short_string "virtual +std::string short_string() const "; + +%feature("docstring") cmf::river::Manning::to_string "virtual +std::string to_string() const "; + + +// File: classcmf__core_1_1_manning___diffusive.xml +%feature("docstring") cmf_core::Manning_Diffusive " + +Connecting surface water bodies using a diffusive wave. This approach +might not be numerical stable for deep water with small gradient cmf +for experimental reasons .. math:: q_{Manning}&=& A +R^{\\\\\\\\frac 2 3} \\\\\\\\sqrt{\\\\\\\\frac {\\\\\\\\Delta_z} n} +\\\\\\\\\\\\\\\\ A &=& \\\\\\\\frac V l \\\\\\\\mbox{, (Crosssectional +area of the wetted crossection, Volume per length)} +\\\\\\\\\\\\\\\\ R &=& \\\\\\\\frac A {P(d)} \\\\\\\\\\\\\\\\ P(d) +&=& \\\\\\\\mbox{ the perimeter of the wetted crosssection, a +function of reach depth} \\\\\\\\\\\\\\\\ d(V) &=& \\\\\\\\mbox{ the +depth of the reach a function of the volume} \\\\\\\\\\\\\\\\ +\\\\\\\\Delta_z = \\\\\\\\|\\\\\\\\frac{h_1 - h_2}{l} +\\\\\\\\mbox{ Slope of the reach waterlevels} \\\\\\\\\\\\\\\\ +n&=&\\\\\\\\mbox{Manning friction number} C++ includes: +ManningConnection.h "; + +%feature("docstring") cmf_core::Manning_Diffusive::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::river::Manning_Diffusive self, +cmf::river::OpenWaterStorage::ptr left, cmf::water::flux_node::ptr +right, IChannel reachtype) -> Manning_Diffusive +Manning_Diffusive(cmf::river::OpenWaterStorage::ptr left, +cmf::water::flux_node::ptr right, const cmf::river::IChannel +&reachtype) Creates a diffusive wave connection between to open water +storages. Parameters: ----------- left: right: The nodes to be +connected by the diffusive wave. Left needs to be an open water +storage reachtype: The channel geometry "; + +%feature("docstring") cmf_core::Manning_Diffusive::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::Manning_Diffusive::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::Manning_Diffusive::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::Manning_Diffusive::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::Manning_Diffusive::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::Manning_Diffusive::conc "def +conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") cmf_core::Manning_Diffusive::exchange_target "def exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::Manning_Diffusive::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::Manning_Diffusive::get_tracer_filter +"def get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::Manning_Diffusive::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::Manning_Diffusive::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::Manning_Diffusive::q "def q(self, +args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::Manning_Diffusive::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::Manning_Diffusive::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::Manning_Diffusive::set_tracer_filter +"def set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::Manning_Diffusive::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::Manning_Diffusive::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf_1_1river_1_1_manning___diffusive.xml +%feature("docstring") cmf::river::Manning_Diffusive " + +Connecting surface water bodies using a diffusive wave. + +This approach might not be numerical stable for deep water with small +gradient cmf for experimental reasons + +.. math:: + + + q_{Manning}&=& A R^{\\\\frac 2 3} \\\\sqrt{\\\\frac {\\\\Delta_z} n} + \\\\\\\\ A &=& \\\\frac V l \\\\mbox{, (Crosssectional area of the + wetted crossection, Volume per length)} \\\\\\\\ R &=& \\\\frac A + {P(d)} \\\\\\\\ P(d) &=& \\\\mbox{ the perimeter of the wetted + crosssection, a function of reach depth} \\\\\\\\ d(V) &=& \\\\mbox{ + the depth of the reach a function of the volume} \\\\\\\\ \\\\Delta_z + = \\\\|\\\\frac{h_1 - h_2}{l} \\\\mbox{ Slope of the reach + waterlevels} \\\\\\\\ n&=&\\\\mbox{Manning friction number} + + + + +C++ includes: ManningConnection.h "; + +%feature("docstring") +cmf::river::Manning_Diffusive::Manning_Diffusive "Manning_Diffusive(cmf::river::OpenWaterStorage::ptr left, +cmf::water::flux_node::ptr right, const cmf::river::IChannel +&reachtype) + +Creates a diffusive wave connection between to open water storages. + +Parameters: +----------- + +left: right: The nodes to be connected by the diffusive wave. Left +needs to be an open water storage + +reachtype: The channel geometry "; + +%feature("docstring") cmf::river::Manning_Diffusive::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") cmf::river::Manning_Diffusive::exchange_target +"void exchange_target(flux_node::ptr oldtarget, flux_node::ptr +newTarget) "; + +%feature("docstring") cmf::river::Manning_Diffusive::get_ptr "ptr +get_ptr() const "; + +%feature("docstring") cmf::river::Manning_Diffusive::get_target "flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") cmf::river::Manning_Diffusive::get_target "flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") +cmf::river::Manning_Diffusive::get_tracer_filter "real +get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::river::Manning_Diffusive::get_tracer_filter "real +get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") cmf::river::Manning_Diffusive::kill_me "bool +kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") cmf::river::Manning_Diffusive::left_node "flux_node::ptr left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") cmf::river::Manning_Diffusive::q "real q(const +flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") cmf::river::Manning_Diffusive::refresh "void +refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") cmf::river::Manning_Diffusive::right_node "flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") +cmf::river::Manning_Diffusive::set_tracer_filter "void +set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::river::Manning_Diffusive::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf::river::Manning_Diffusive::short_string "virtual std::string short_string() const "; + +%feature("docstring") cmf::river::Manning_Diffusive::to_string "virtual std::string to_string() const "; + + +// File: classcmf__core_1_1_manning___kinematic.xml +%feature("docstring") cmf_core::Manning_Kinematic " + +Connecting surface water bodies using a kinematic wave. Note the +fixed gradient :math:`\\\\\\\\Delta_z` .. math:: q_{Manning}&=& A +R^{\\\\\\\\frac 2 3} \\\\\\\\sqrt{\\\\\\\\frac {\\\\\\\\Delta_z} n} +\\\\\\\\\\\\\\\\ A &=& \\\\\\\\frac V l \\\\\\\\mbox{, (Crosssectional +area of the wetted crossection, Volume per length)} +\\\\\\\\\\\\\\\\ R &=& \\\\\\\\frac A {P(d)} \\\\\\\\\\\\\\\\ P(d) +&=& \\\\\\\\mbox{ the perimeter of the wetted crosssection, a function +of reach depth} \\\\\\\\\\\\\\\\ d(V) &=& \\\\\\\\mbox{ the depth +of the reach a function of the volume} \\\\\\\\\\\\\\\\ +\\\\\\\\Delta_z &=& \\\\\\\\frac{\\\\\\\\|z_1 - z_2\\\\\\\\|}{l} +\\\\\\\\mbox{ Slope of the reach} \\\\\\\\\\\\\\\\ +n&=&\\\\\\\\mbox{Manning friction number} C++ includes: +ManningConnection.h "; + +%feature("docstring") cmf_core::Manning_Kinematic::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::river::Manning_Kinematic self, +cmf::river::OpenWaterStorage::ptr left, cmf::water::flux_node::ptr +right, IChannel reachtype) -> Manning_Kinematic +Manning_Kinematic(cmf::river::OpenWaterStorage::ptr left, +cmf::water::flux_node::ptr right, const cmf::river::IChannel +&reachtype) Creates a kinematic wave connection between to open water +storages. Parameters: ----------- left: right: The nodes to be +connected by the kinematic wave. Left needs to be an open water +storage reachtype: The channel geometry "; + +%feature("docstring") cmf_core::Manning_Kinematic::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::Manning_Kinematic::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::Manning_Kinematic::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::Manning_Kinematic::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::Manning_Kinematic::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::Manning_Kinematic::conc "def +conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") cmf_core::Manning_Kinematic::exchange_target "def exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::Manning_Kinematic::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::Manning_Kinematic::get_tracer_filter +"def get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::Manning_Kinematic::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::Manning_Kinematic::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::Manning_Kinematic::q "def q(self, +args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::Manning_Kinematic::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::Manning_Kinematic::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::Manning_Kinematic::set_tracer_filter +"def set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::Manning_Kinematic::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::Manning_Kinematic::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf_1_1river_1_1_manning___kinematic.xml +%feature("docstring") cmf::river::Manning_Kinematic " + +Connecting surface water bodies using a kinematic wave. + +Note the fixed gradient :math:`\\\\Delta_z` + +.. math:: + + + q_{Manning}&=& A R^{\\\\frac 2 3} \\\\sqrt{\\\\frac {\\\\Delta_z} n} + \\\\\\\\ A &=& \\\\frac V l \\\\mbox{, (Crosssectional area of the + wetted crossection, Volume per length)} \\\\\\\\ R &=& \\\\frac A + {P(d)} \\\\\\\\ P(d) &=& \\\\mbox{ the perimeter of the wetted + crosssection, a function of reach depth} \\\\\\\\ d(V) &=& \\\\mbox{ + the depth of the reach a function of the volume} \\\\\\\\ \\\\Delta_z + &=& \\\\frac{\\\\|z_1 - z_2\\\\|}{l} \\\\mbox{ Slope of the reach} + \\\\\\\\ n&=&\\\\mbox{Manning friction number} + + + +C++ includes: ManningConnection.h "; + +%feature("docstring") +cmf::river::Manning_Kinematic::Manning_Kinematic "Manning_Kinematic(cmf::river::OpenWaterStorage::ptr left, +cmf::water::flux_node::ptr right, const cmf::river::IChannel +&reachtype) + +Creates a kinematic wave connection between to open water storages. + +Parameters: +----------- + +left: right: The nodes to be connected by the kinematic wave. Left +needs to be an open water storage + +reachtype: The channel geometry "; + +%feature("docstring") cmf::river::Manning_Kinematic::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") cmf::river::Manning_Kinematic::exchange_target +"void exchange_target(flux_node::ptr oldtarget, flux_node::ptr +newTarget) "; + +%feature("docstring") cmf::river::Manning_Kinematic::get_ptr "ptr +get_ptr() const "; + +%feature("docstring") cmf::river::Manning_Kinematic::get_target "flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") cmf::river::Manning_Kinematic::get_target "flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") +cmf::river::Manning_Kinematic::get_tracer_filter "real +get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::river::Manning_Kinematic::get_tracer_filter "real +get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") cmf::river::Manning_Kinematic::kill_me "bool +kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") cmf::river::Manning_Kinematic::left_node "flux_node::ptr left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") cmf::river::Manning_Kinematic::q "real q(const +flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") cmf::river::Manning_Kinematic::refresh "void +refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") cmf::river::Manning_Kinematic::right_node "flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") +cmf::river::Manning_Kinematic::set_tracer_filter "void +set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::river::Manning_Kinematic::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf::river::Manning_Kinematic::short_string "virtual std::string short_string() const "; + +%feature("docstring") cmf::river::Manning_Kinematic::to_string "virtual std::string to_string() const "; + + +// File: classcmf_1_1maps_1_1_map.xml +%feature("docstring") cmf::maps::Map " + +A Map is the base class for different spatial data distributions. The +base version contains returns always the default value A Map should +implement the following functions: __iter__, returns an iterator over +the items of a map values(), returns an iterator over the different +objects of a map __call__(x,y,z), returns the object belonging to the +position x,y,z "; + +%feature("docstring") cmf::maps::Map::__init__ "def __init__(self, +default=None) "; + +%feature("docstring") cmf::maps::Map::__call__ "def __call__(self, +x, y, z=0) + +returns default, regardless of the position given "; + +%feature("docstring") cmf::maps::Map::__iter__ "def __iter__(self) +"; + +%feature("docstring") cmf::maps::Map::__nonzero__ "def +__nonzero__(self) "; + +%feature("docstring") cmf::maps::Map::values "def values(self) "; + + +// File: classcmf__core_1_1_matrix_infiltration.xml +%feature("docstring") cmf_core::MatrixInfiltration " + +Connects the surfacewater and the most upper layer using a Richards +equation like infiltration model. The potential infiltration is +calculated according to the Richards equation. The gradient is from +the cell surface to the center of the first layer and the conductivity +is the geometric mean of the wetted surface ( :math:`K_{sat}`) and the +conductivity of the layer center ( :math:`K(\\\\\\\\theta_{layer})` .. +math:: q_{max} &=& \\\\\\\\frac{\\\\\\\\Psi_{surface} - +\\\\\\\\Psi_{soil}}{\\\\\\\\Delta z} K A_{cell} \\\\\\\\\\\\\\\\ K +&=& +\\\\\\\\sqrt{K\\\\\\\\left(\\\\\\\\theta_{layer}\\\\\\\\right)K_{sat}} +\\\\\\\\\\\\\\\\ \\\\\\\\Delta z &=& z_{cell} - z_{layer center} If +the surface water is modeled by a distinct water storage, the actual +infiltration is given as the product of the potential infiltration +with the coverage of the surface water +cmf::upslope::Cell::surface_water_coverage .. math:: q_{act} = +q_{max} \\\\\\\\frac{A_{water}}{A_{cell}} If the surface water is +no storage on its own, but just a water distribution node, the actual +infiltration is the minimum of the potential infiltration and the +current inflow (rain, snow melt) to the surface .. math:: q_{act} = +\\\\\\\\min\\\\\\\\left(q_{max}, +\\\\\\\\sum{q_{in,surfacewater}}\\\\\\\\right) C++ includes: +infiltration.h "; + +%feature("docstring") cmf_core::MatrixInfiltration::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::connections::MatrixInfiltration self, +cmf::upslope::SoilLayer::ptr soilwater, cmf::water::flux_node::ptr +surfacewater) -> MatrixInfiltration +MatrixInfiltration(cmf::upslope::SoilLayer::ptr soilwater, +cmf::water::flux_node::ptr surfacewater) "; + +%feature("docstring") cmf_core::MatrixInfiltration::__contains__ "def __contains__(self, cmp) "; + +%feature("docstring") cmf_core::MatrixInfiltration::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::MatrixInfiltration::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::MatrixInfiltration::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::MatrixInfiltration::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::MatrixInfiltration::conc "def +conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") cmf_core::MatrixInfiltration::exchange_target "def exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::MatrixInfiltration::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::MatrixInfiltration::get_tracer_filter +"def get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::MatrixInfiltration::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::MatrixInfiltration::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::MatrixInfiltration::q "def q(self, +args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::MatrixInfiltration::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::MatrixInfiltration::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::MatrixInfiltration::set_tracer_filter +"def set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::MatrixInfiltration::short_string "def short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::MatrixInfiltration::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + +%feature("docstring") cmf_core::MatrixInfiltration::use_for_cell "def use_for_cell(args, kwargs) + +use_for_cell(Cell c) "; + + +// File: classcmf_1_1upslope_1_1connections_1_1_matrix_infiltration.xml +%feature("docstring") cmf::upslope::connections::MatrixInfiltration " + +Connects the surfacewater and the most upper layer using a Richards +equation like infiltration model. + +The potential infiltration is calculated according to the Richards +equation. The gradient is from the cell surface to the center of the +first layer and the conductivity is the geometric mean of the wetted +surface ( :math:`K_{sat}`) and the conductivity of the layer center ( +:math:`K(\\\\theta_{layer})` + +.. math:: + + q_{max} &=& + \\\\frac{\\\\Psi_{surface} - \\\\Psi_{soil}}{\\\\Delta z} K A_{cell} + \\\\\\\\ K &=& \\\\sqrt{K\\\\left(\\\\theta_{layer}\\\\right)K_{sat}} + \\\\\\\\ \\\\Delta z &=& z_{cell} - z_{layer center} + + + + +If the surface water is modeled by a distinct water storage, the +actual infiltration is given as the product of the potential +infiltration with the coverage of the surface water +cmf::upslope::Cell::surface_water_coverage + +.. math:: + + q_{act} = q_{max} + \\\\frac{A_{water}}{A_{cell}} + +If the surface water is no storage on its own, but just a water +distribution node, the actual infiltration is the minimum of the +potential infiltration and the current inflow (rain, snow melt) to the +surface + +.. math:: + + q_{act} = \\\\min\\\\left(q_{max}, + \\\\sum{q_{in,surfacewater}}\\\\right) + +C++ includes: infiltration.h "; + +%feature("docstring") +cmf::upslope::connections::MatrixInfiltration::MatrixInfiltration "MatrixInfiltration(cmf::upslope::SoilLayer::ptr soilwater, +cmf::water::flux_node::ptr surfacewater) "; + +%feature("docstring") +cmf::upslope::connections::MatrixInfiltration::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") +cmf::upslope::connections::MatrixInfiltration::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") +cmf::upslope::connections::MatrixInfiltration::get_ptr "ptr get_ptr() +const "; + +%feature("docstring") +cmf::upslope::connections::MatrixInfiltration::get_target "flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") +cmf::upslope::connections::MatrixInfiltration::get_target "flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") +cmf::upslope::connections::MatrixInfiltration::get_tracer_filter "real get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::MatrixInfiltration::get_tracer_filter "real get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") +cmf::upslope::connections::MatrixInfiltration::kill_me "bool +kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") +cmf::upslope::connections::MatrixInfiltration::left_node "flux_node::ptr left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") +cmf::upslope::connections::MatrixInfiltration::q "real q(const +flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") +cmf::upslope::connections::MatrixInfiltration::refresh "void +refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") +cmf::upslope::connections::MatrixInfiltration::right_node "flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") +cmf::upslope::connections::MatrixInfiltration::set_tracer_filter "void set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::connections::MatrixInfiltration::set_tracer_filter "void set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf::upslope::connections::MatrixInfiltration::short_string "virtual +std::string short_string() const "; + +%feature("docstring") +cmf::upslope::connections::MatrixInfiltration::to_string "virtual +std::string to_string() const "; + + +// File: classcmf_1_1river_1_1_mean_channel.xml +%feature("docstring") cmf::river::MeanChannel " + +A combination of two channel geometries. + +C++ includes: ReachType.h "; + +%feature("docstring") cmf::river::MeanChannel::MeanChannel "MeanChannel(const IChannel &channel1, const IChannel &channel2) + +Creates the mean geometry from the two channel geometries. "; + +%feature("docstring") cmf::river::MeanChannel::MeanChannel "MeanChannel(const MeanChannel &meanChannel) "; + +%feature("docstring") cmf::river::MeanChannel::~MeanChannel "virtual +~MeanChannel() "; + +%feature("docstring") cmf::river::MeanChannel::A "virtual double +A(double V) const + +Returns the area of the surface for a given volume. "; + +%feature("docstring") cmf::river::MeanChannel::copy "MeanChannel* +copy() const "; + +%feature("docstring") cmf::river::MeanChannel::get_channel_width "double get_channel_width(double depth) const + +Calculates the flow width from a given actual depth [m] using the +actual IChannel geometry. "; + +%feature("docstring") cmf::river::MeanChannel::get_depth "double +get_depth(double area) const + +Calculates the actual depth of the reach using the IChannel geometry. + +get_depth of the reach [m] + +Parameters: +----------- + +area: Wetted area of a river cross section [m2], can be obtained by +V/l, where V is the stored volume and l is the reach length "; + +%feature("docstring") cmf::river::MeanChannel::get_flux_crossection "double get_flux_crossection(double depth) const + +Calculates the wetted area from a given depth using the IChannel +geometry. + +In most cases use get_flux_crossection=V/l, where V is the stored +volume and l is the reach length Wetted area of a river cross section +[m2] + +Parameters: +----------- + +depth: depth of the reach [m] "; + +%feature("docstring") cmf::river::MeanChannel::get_length "double +get_length() const + +Length of the reach. "; + +%feature("docstring") cmf::river::MeanChannel::get_nManning "virtual +double get_nManning() const "; + +%feature("docstring") cmf::river::MeanChannel::get_wetted_perimeter "double get_wetted_perimeter(double depth) const + +Calculates the wetted perimeter from a given actual depth [m] using +the actual IChannel geometry. "; + +%feature("docstring") cmf::river::MeanChannel::h "virtual double +h(double V) const + +Returns the depth of a given volume. "; + +%feature("docstring") cmf::river::MeanChannel::q "virtual double +q(double h, double slope) const "; + +%feature("docstring") cmf::river::MeanChannel::qManning "virtual +double qManning(double A, double slope) const + +Calculates the flow rate from a given water volume in the reach + + +.. math:: + + q_{Manning}&=& A R^{\\\\frac 2 3} + \\\\sqrt{\\\\frac {\\\\Delta_z} n} \\\\\\\\ A &=& \\\\frac V l + \\\\mbox{, (Crosssectional area of the wetted crossection, Volume per + length)} \\\\\\\\ R &=& \\\\frac A {P(d)} \\\\\\\\ P(d) &=& \\\\mbox{ + the perimeter of the wetted crosssection, a function of reach depth} + \\\\\\\\ d(V) &=& \\\\mbox{ the depth of the reach a function of the + volume} \\\\\\\\ \\\\Delta_z &=& \\\\frac{z_{max} - z_{min}}{l} + \\\\mbox{ Slope of the reach} + +. + +Flow rate [m3/s] + +Parameters: +----------- + +A: The area of the cross section [m2] + +slope: The slope of the reach [m/m] "; + +%feature("docstring") cmf::river::MeanChannel::set_nManning "virtual +void set_nManning(double nManning) "; + +%feature("docstring") cmf::river::MeanChannel::typecode "char +typecode() const "; + +%feature("docstring") cmf::river::MeanChannel::V "virtual double +V(double h) const "; + + +// File: classcmf__core_1_1_mean_channel.xml +%feature("docstring") cmf_core::MeanChannel " + +A combination of two channel geometries. C++ includes: ReachType.h "; + +%feature("docstring") cmf_core::MeanChannel::__init__ "def +__init__(self, args) + +__init__(cmf::river::MeanChannel self, IChannel channel1, IChannel +channel2) -> MeanChannel __init__(cmf::river::MeanChannel self, +MeanChannel meanChannel) -> MeanChannel MeanChannel(const MeanChannel +&meanChannel) "; + +%feature("docstring") cmf_core::MeanChannel::A "def A(self, args, +kwargs) + +A(IVolumeHeightFunction self, double V) -> double virtual double +A(double V) const =0 Returns the area of the surface for a given +volume. "; + +%feature("docstring") cmf_core::MeanChannel::copy "def copy(self, +args, kwargs) + +copy(MeanChannel self) -> MeanChannel MeanChannel* copy() const "; + +%feature("docstring") cmf_core::MeanChannel::get_channel_width "def +get_channel_width(self, args, kwargs) + +get_channel_width(IChannel self, double depth) -> double virtual +double get_channel_width(double depth) const =0 Calculates the flow +width from a given actual depth [m] using the actual IChannel +geometry. "; + +%feature("docstring") cmf_core::MeanChannel::get_depth "def +get_depth(self, args, kwargs) + +get_depth(IChannel self, double area) -> double virtual double +get_depth(double area) const =0 Calculates the actual depth of the +reach using the IChannel geometry. get_depth of the reach [m] +Parameters: ----------- area: Wetted area of a river cross section +[m2], can be obtained by V/l, where V is the stored volume and l is +the reach length "; + +%feature("docstring") cmf_core::MeanChannel::get_flux_crossection "def get_flux_crossection(self, args, kwargs) + +get_flux_crossection(IChannel self, double depth) -> double virtual +double get_flux_crossection(double depth) const =0 Calculates the +wetted area from a given depth using the IChannel geometry. In most +cases use get_flux_crossection=V/l, where V is the stored volume and l +is the reach length Wetted area of a river cross section [m2] +Parameters: ----------- depth: depth of the reach [m] "; + +%feature("docstring") cmf_core::MeanChannel::get_length "def +get_length(self, args, kwargs) + +get_length(IChannel self) -> double virtual double get_length() const +=0 Length of the reach. "; + +%feature("docstring") cmf_core::MeanChannel::get_nManning "def +get_nManning(self, args, kwargs) + +get_nManning(IChannel self) -> double virtual double get_nManning() +const =0 "; + +%feature("docstring") cmf_core::MeanChannel::get_wetted_perimeter "def get_wetted_perimeter(self, args, kwargs) + +get_wetted_perimeter(IChannel self, double depth) -> double virtual +double get_wetted_perimeter(double depth) const =0 Calculates the +wetted perimeter from a given actual depth [m] using the actual +IChannel geometry. "; + +%feature("docstring") cmf_core::MeanChannel::h "def h(self, args, +kwargs) + +h(IVolumeHeightFunction self, double V) -> double virtual double +h(double V) const =0 Returns the depth of a given volume. "; + +%feature("docstring") cmf_core::MeanChannel::q "def q(self, args, +kwargs) + +q(IVolumeHeightFunction self, double h, double slope) -> double +virtual double q(double h, double slope) const "; + +%feature("docstring") cmf_core::MeanChannel::qManning "def +qManning(self, args, kwargs) + +qManning(IChannel self, double A, double slope) -> double virtual +double qManning(double A, double slope) const Calculates the flow +rate from a given water volume in the reach .. math:: q_{Manning}&=& +A R^{\\\\\\\\frac 2 3} \\\\\\\\sqrt{\\\\\\\\frac {\\\\\\\\Delta_z} +n} \\\\\\\\\\\\\\\\ A &=& \\\\\\\\frac V l \\\\\\\\mbox{, +(Crosssectional area of the wetted crossection, Volume per +length)} \\\\\\\\\\\\\\\\ R &=& \\\\\\\\frac A {P(d)} \\\\\\\\\\\\\\\\ +P(d) &=& \\\\\\\\mbox{ the perimeter of the wetted crosssection, a +function of reach depth} \\\\\\\\\\\\\\\\ d(V) &=& \\\\\\\\mbox{ +the depth of the reach a function of the volume} \\\\\\\\\\\\\\\\ +\\\\\\\\Delta_z &=& \\\\\\\\frac{z_{max} - z_{min}}{l} +\\\\\\\\mbox{ Slope of the reach} . Flow rate [m3/s] Parameters: +----------- A: The area of the cross section [m2] slope: The slope +of the reach [m/m] "; + +%feature("docstring") cmf_core::MeanChannel::set_nManning "def +set_nManning(self, args, kwargs) + +set_nManning(IChannel self, double val) virtual void +set_nManning(double val)=0 "; + +%feature("docstring") cmf_core::MeanChannel::typecode "def +typecode(self, args, kwargs) + +typecode(IChannel self) -> char virtual char typecode() const =0 "; + +%feature("docstring") cmf_core::MeanChannel::V "def V(self, args, +kwargs) + +V(IVolumeHeightFunction self, double h) -> double virtual double +V(double h) const =0 "; + + +// File: classcmf_1_1atmosphere_1_1_meteorology.xml +%feature("docstring") cmf::atmosphere::Meteorology " + +An abstract class, for objects generating Weather records at a +specific time. + +C++ includes: meteorology.h "; + +%feature("docstring") cmf::atmosphere::Meteorology::~Meteorology "virtual ~Meteorology() "; + +%feature("docstring") cmf::atmosphere::Meteorology::copy "virtual +Meteorology* copy() const =0 + +Returns a copy of the meteorology object. Pure virtual function, needs +to be implemented. "; + +%feature("docstring") +cmf::atmosphere::Meteorology::get_instrument_height "virtual real +get_instrument_height() const =0 + +Returns the height of the instruments above canopy. "; + +%feature("docstring") cmf::atmosphere::Meteorology::get_weather "virtual cmf::atmosphere::Weather get_weather(cmf::math::Time t) const +=0 + +Returns the Weather at time t. Pure virtual function. Must get +implemented by child functions. "; + + +// File: classcmf__core_1_1_meteorology.xml +%feature("docstring") cmf_core::Meteorology " + +An abstract class, for objects generating Weather records at a +specific time. C++ includes: meteorology.h "; + +%feature("docstring") cmf_core::Meteorology::__init__ "def +__init__(self, args, kwargs) "; + +%feature("docstring") cmf_core::Meteorology::__call__ "def +__call__(self, args, kwargs) + +__call__(Meteorology self, Time t) -> Weather "; + +%feature("docstring") cmf_core::Meteorology::copy "def copy(self, +args, kwargs) + +copy(Meteorology self) -> Meteorology virtual Meteorology* copy() +const =0 Returns a copy of the meteorology object. Pure virtual +function, needs to be implemented. "; + +%feature("docstring") cmf_core::Meteorology::get_instrument_height "def get_instrument_height(self, args, kwargs) + +get_instrument_height(Meteorology self) -> real virtual real +get_instrument_height() const =0 Returns the height of the +instruments above canopy. "; + +%feature("docstring") cmf_core::Meteorology::get_weather "def +get_weather(self, args, kwargs) + +get_weather(Meteorology self, Time t) -> Weather virtual +cmf::atmosphere::Weather get_weather(cmf::math::Time t) const =0 +Returns the Weather at time t. Pure virtual function. Must get +implemented by child functions. "; + + +// File: classcmf_1_1atmosphere_1_1_meteo_station.xml +%feature("docstring") cmf::atmosphere::MeteoStation " + +A meteorological station holding timeseries to create Weather records. + +In order to calculate ETpot with cmf a big amount of meteorological +data is needed, more data than usually available. The MeteoStation +class can estimate missing data from a minimal set. As more data, as +one provides, the better the calculation of ETpot becomes. The minimal +data needed is Tmin and Tmax (daily) and precipitation. To calculate +the global radiation (although measured global radiation could be +inserted), the position of meteorological station in geographic +coordinates has to be set. + +A meteorological station is created by +cmf::atmosphere::MeteoStationList::add_station . Usage from python: + +There are two modes for the meteorology: daily=true and daily=false. +If daily=true, Radiation is given as a daily mean value. If +daily=false, Radiation is given as an hourly mean value, which shows +the dial ETpot variation but results in erronous results if the +timestep is daily. + +C++ includes: meteorology.h "; + +/* Location and behaviour properties */ + +%feature("docstring") cmf::atmosphere::MeteoStation::get_position "cmf::geometry::point get_position() const "; + +/* Data access methods */ + +%feature("docstring") cmf::atmosphere::MeteoStation::get_data "cmf::atmosphere::Weather get_data(cmf::math::Time t, double height) +const + +Returns the current Atmosphere state. Uses default values for missing +timeseries. "; + +%feature("docstring") cmf::atmosphere::MeteoStation::use_for_cell "void use_for_cell(cmf::upslope::Cell &c) + +Connects this meteostation as a meteo data provider with the cell. "; + +%feature("docstring") +cmf::atmosphere::MeteoStation::SetSunshineFraction "void +SetSunshineFraction(cmf::math::timeseries sunshine_duration) + +Calculates a timeseries of the sunshine fraction (to put into +Sunshine) from a timeseries of absolute sunshine duration + +seehttp://www.fao.org/docrep/X0490E/x0490e07.htm#radiation + + +.. math:: + + \\\\phi &=& \\\\frac{(\\\\mbox{geogr. + Latitude})^\\\\circ \\\\pi}{180^\\\\circ} \\\\mbox{ Latitude in }rad + \\\\\\\\ \\\\delta &=& 0.409 \\\\sin\\\\left(\\\\frac{2\\\\pi}{365}DOY + - 1.39\\\\right) \\\\mbox{ Declination, DOY is day of year}\\\\\\\\ + \\\\omega_s &=& \\\\arccos(-\\\\tan\\\\phi\\\\tan\\\\delta) \\\\mbox{ + Sunset angle in }rad \\\\\\\\ N &=& \\\\frac{24}{\\\\pi}\\\\omega_s + \\\\mbox{ potential duration of sunshine in }h \\\\\\\\ \\\\frac n N + &=& n\\\\mbox{ absolute sunshine duration in }h + + "; + +/* Timeseries of meteorological data */ + +%feature("docstring") cmf::atmosphere::MeteoStation::MeteoStation "MeteoStation(const cmf::atmosphere::MeteoStation &other) + +Copy c'tor. "; + + +// File: classcmf__core_1_1_meteo_station.xml +%feature("docstring") cmf_core::MeteoStation " + +A meteorological station holding timeseries to create Weather records. +In order to calculate ETpot with cmf a big amount of meteorological +data is needed, more data than usually available. The MeteoStation +class can estimate missing data from a minimal set. As more data, as +one provides, the better the calculation of ETpot becomes. The minimal +data needed is Tmin and Tmax (daily) and precipitation. To calculate +the global radiation (although measured global radiation could be +inserted), the position of meteorological station in geographic +coordinates has to be set. A meteorological station is created by +cmf::atmosphere::MeteoStationList::add_station . Usage from python: +There are two modes for the meteorology: daily=true and daily=false. +If daily=true, Radiation is given as a daily mean value. If +daily=false, Radiation is given as an hourly mean value, which shows +the dial ETpot variation but results in erronous results if the +timestep is daily. C++ includes: meteorology.h "; + +%feature("docstring") cmf_core::MeteoStation::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::atmosphere::MeteoStation self, MeteoStation other) -> +MeteoStation MeteoStation(const cmf::atmosphere::MeteoStation &other) +Copy c'tor. "; + +%feature("docstring") cmf_core::MeteoStation::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::MeteoStation::get_data "def +get_data(self, args, kwargs) + +get_data(MeteoStation self, Time t, double height) -> Weather +cmf::atmosphere::Weather get_data(cmf::math::Time t, double height) +const Returns the current Atmosphere state. Uses default values for +missing timeseries. "; + +%feature("docstring") cmf_core::MeteoStation::get_position "def +get_position(self, args, kwargs) + +get_position(MeteoStation self) -> point cmf::geometry::point +get_position() const "; + +%feature("docstring") cmf_core::MeteoStation::SetSunshineFraction "def SetSunshineFraction(self, args, kwargs) + +SetSunshineFraction(MeteoStation self, timeseries sunshine_duration) +void SetSunshineFraction(cmf::math::timeseries sunshine_duration) +Calculates a timeseries of the sunshine fraction (to put into +Sunshine) from a timeseries of absolute sunshine duration +seehttp://www.fao.org/docrep/X0490E/x0490e07.htm#radiation .. math:: +\\\\\\\\phi &=& \\\\\\\\frac{(\\\\\\\\mbox{geogr. +Latitude})^\\\\\\\\circ \\\\\\\\pi}{180^\\\\\\\\circ} \\\\\\\\mbox{ +Latitude in }rad \\\\\\\\\\\\\\\\ \\\\\\\\delta &=& 0.409 +\\\\\\\\sin\\\\\\\\left(\\\\\\\\frac{2\\\\\\\\pi}{365}DOY - +1.39\\\\\\\\right) \\\\\\\\mbox{ Declination, DOY is day of +year}\\\\\\\\\\\\\\\\ \\\\\\\\omega_s &=& +\\\\\\\\arccos(-\\\\\\\\tan\\\\\\\\phi\\\\\\\\tan\\\\\\\\delta) +\\\\\\\\mbox{ Sunset angle in }rad \\\\\\\\\\\\\\\\ N &=& +\\\\\\\\frac{24}{\\\\\\\\pi}\\\\\\\\omega_s \\\\\\\\mbox{ +potential duration of sunshine in }h \\\\\\\\\\\\\\\\ \\\\\\\\frac n N +&=& n\\\\\\\\mbox{ absolute sunshine duration in }h "; + +%feature("docstring") cmf_core::MeteoStation::TimeseriesDictionary "def TimeseriesDictionary(self) "; + +%feature("docstring") cmf_core::MeteoStation::use_for_cell "def +use_for_cell(self, args, kwargs) + +use_for_cell(MeteoStation self, Cell c) void +use_for_cell(cmf::upslope::Cell &c) Connects this meteostation as a +meteo data provider with the cell. "; + + +// File: classcmf_1_1atmosphere_1_1_meteo_station_list.xml +%feature("docstring") cmf::atmosphere::MeteoStationList " + +A list of meteorological stations. + +Can find the nearest station for a position and calculate the +temperature lapse + +C++ includes: meteorology.h "; + +%feature("docstring") +cmf::atmosphere::MeteoStationList::MeteoStationList "MeteoStationList() + +Create empty list. "; + +%feature("docstring") +cmf::atmosphere::MeteoStationList::MeteoStationList "MeteoStationList(const MeteoStationList ©) + +Copy c'tor. "; + +%feature("docstring") cmf::atmosphere::MeteoStationList::add_station +"MeteoStation::ptr add_station(std::string name, cmf::geometry::point +position, double latitude=51.0, double longitude=8.0, double tz=1.0, +cmf::math::Time startTime=cmf::math::Time(1, 1, 2001), cmf::math::Time +timestep=cmf::math::day) + +Creates a meteorological station at a certain position and adds it to +the list. + +Parameters: +----------- + +name: Name of the station + +position: The location of the station in map coordinates + +latitude: Latitude of the study area (for solar radiation) + +longitude: Longitude of the study area (for solar time) + +tz: Time zone of the study area (e.g Germany +1,U.S. Pacific time -8 + +startTime: Date of the beginning of the climatic data (may be changed +for each time series later) + +timestep: Frequency of climatic data (may be changed for each time +series later) "; + +%feature("docstring") +cmf::atmosphere::MeteoStationList::calculate_Temp_lapse "double +calculate_Temp_lapse(cmf::math::Time begin, cmf::math::Time step, +cmf::math::Time end) + +Calculates the temperature lapse from all stations in the list and +sets the T_lapse attribute of each station. + +Returns the average lapse over the whole period. "; + +%feature("docstring") +cmf::atmosphere::MeteoStationList::reference_to_nearest "MeteoStationReference reference_to_nearest(const cmf::geometry::point +&position, double z_weight=0) const + +Creates a MeteoStationReference from the nearest station to position +at position. + +The distance is calculated as :math:`d=\\\\sqrt{(x_{s} - x_{l})^2 + (y_{s} - y_{l})^2} + \\\\lambda_z\\\\|z_{s} - z_{l}\\\\|` Where :math:`s` is the +station and :math:`l` is the locatable A Meteorology using the data of the +nearest station to position + +Parameters: +----------- + +position: The position (any locatable, like e.g. Cell possible) to +look for the station. The reference should be owned by the locatable + +z_weight: The weight of the height difference :math:`\\\\lambda_z` "; + +%feature("docstring") +cmf::atmosphere::MeteoStationList::remove_station "ptrdiff_t +remove_station(ptrdiff_t index) + +Removes a station and returns the number of remaining references to +the removed station. If the station is deleted, 0 is returned. "; + +%feature("docstring") cmf::atmosphere::MeteoStationList::size "size_t size() const + +Returns the number of stations. "; + + +// File: classcmf__core_1_1_meteo_station_list.xml +%feature("docstring") cmf_core::MeteoStationList " + +A list of meteorological stations. Can find the nearest station for a +position and calculate the temperature lapse C++ includes: +meteorology.h "; + +%feature("docstring") cmf_core::MeteoStationList::__init__ "def +__init__(self, args) + +__init__(cmf::atmosphere::MeteoStationList self) -> MeteoStationList +__init__(cmf::atmosphere::MeteoStationList self, MeteoStationList +copy) -> MeteoStationList MeteoStationList(const MeteoStationList +©) Copy c'tor. "; + +%feature("docstring") cmf_core::MeteoStationList::__getitem__ "def +__getitem__(self, args) + +__getitem__(MeteoStationList self, ptrdiff_t index) -> +cmf::atmosphere::MeteoStation::ptr __getitem__(MeteoStationList self, +std::string const & Name) -> cmf::atmosphere::MeteoStation::ptr "; + +%feature("docstring") cmf_core::MeteoStationList::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::MeteoStationList::__len__ "def +__len__(self, args, kwargs) + +__len__(MeteoStationList self) -> size_t size_t size() const Returns +the number of stations. "; + +%feature("docstring") cmf_core::MeteoStationList::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::MeteoStationList::add_station "def +add_station(self, args, kwargs) + +add_station(MeteoStationList self, std::string name, point position, +double latitude=51.0, double longitude=8.0, double tz=1.0, Time +startTime, Time timestep) -> cmf::atmosphere::MeteoStation::ptr +MeteoStation::ptr add_station(std::string name, cmf::geometry::point +position, double latitude=51.0, double longitude=8.0, double tz=1.0, +cmf::math::Time startTime=cmf::math::Time(1, 1, 2001), cmf::math::Time +timestep=cmf::math::day) Creates a meteorological station at a +certain position and adds it to the list. Parameters: ----------- +name: Name of the station position: The location of the station in +map coordinates latitude: Latitude of the study area (for solar +radiation) longitude: Longitude of the study area (for solar time) +tz: Time zone of the study area (e.g Germany +1,U.S. Pacific time -8 +startTime: Date of the beginning of the climatic data (may be changed +for each time series later) timestep: Frequency of climatic data +(may be changed for each time series later) "; + +%feature("docstring") +cmf_core::MeteoStationList::calculate_Temp_lapse "def +calculate_Temp_lapse(self, args, kwargs) + +calculate_Temp_lapse(MeteoStationList self, Time begin, Time step, +Time end) -> double double calculate_Temp_lapse(cmf::math::Time +begin, cmf::math::Time step, cmf::math::Time end) Calculates the +temperature lapse from all stations in the list and sets the T_lapse +attribute of each station. Returns the average lapse over the whole +period. "; + +%feature("docstring") +cmf_core::MeteoStationList::reference_to_nearest "def +reference_to_nearest(self, args, kwargs) + +reference_to_nearest(MeteoStationList self, point position, double +z_weight=0) -> MeteoStationReference MeteoStationReference +reference_to_nearest(const cmf::geometry::point &position, double +z_weight=0) const Creates a MeteoStationReference from the nearest +station to position at position. The distance is calculated as +:math:`d=\\\\\\\\sqrt{(x_{s} - x_{l})^2 + (y_{s} - y_{l})^2} + +\\\\\\\\lambda_z\\\\\\\\|z_{s} - z_{l}\\\\\\\\|` Where :math:`s` is +the station and :math:`l` is the locatable A Meteorology using the +data of the nearest station to position Parameters: ----------- +position: The position (any locatable, like e.g. Cell possible) to +look for the station. The reference should be owned by the locatable +z_weight: The weight of the height difference +:math:`\\\\\\\\lambda_z` "; + +%feature("docstring") cmf_core::MeteoStationList::remove_station "def remove_station(self, args, kwargs) + +remove_station(MeteoStationList self, ptrdiff_t index) -> ptrdiff_t +ptrdiff_t remove_station(ptrdiff_t index) Removes a station and +returns the number of remaining references to the removed station. If +the station is deleted, 0 is returned. "; + + +// File: classcmf_1_1atmosphere_1_1_meteo_station_reference.xml +%feature("docstring") cmf::atmosphere::MeteoStationReference " + +A reference to a meteorological station. + +Returns the weather at a given time for its place using +MeteoStation::T_lapse + +C++ includes: meteorology.h "; + +%feature("docstring") +cmf::atmosphere::MeteoStationReference::MeteoStationReference "MeteoStationReference(MeteoStation::ptr station, cmf::geometry::point +location) + +Create a located reference to a meteo station. + +Parameters: +----------- + +station: MeteoStation + +location: Location of the reference "; + +%feature("docstring") +cmf::atmosphere::MeteoStationReference::MeteoStationReference "MeteoStationReference(const MeteoStationReference ©) "; + +%feature("docstring") cmf::atmosphere::MeteoStationReference::copy "MeteoStationReference* copy() const + +Returns a copy of the meteorology object. Pure virtual function, needs +to be implemented. "; + +%feature("docstring") +cmf::atmosphere::MeteoStationReference::get_instrument_height "real +get_instrument_height() const + +Creates a reference for a MeteoStation at a location. "; + +%feature("docstring") +cmf::atmosphere::MeteoStationReference::get_position "cmf::geometry::point get_position() const + +Returns the position of the reference. "; + +%feature("docstring") +cmf::atmosphere::MeteoStationReference::get_station "MeteoStation::ptr get_station() const + +Returns the station referenced. "; + +%feature("docstring") +cmf::atmosphere::MeteoStationReference::get_weather "cmf::atmosphere::Weather get_weather(cmf::math::Time t) const + +Returns the weather at the time t. "; + + +// File: classcmf__core_1_1_meteo_station_reference.xml +%feature("docstring") cmf_core::MeteoStationReference " + +A reference to a meteorological station. Returns the weather at a +given time for its place using MeteoStation::T_lapse C++ includes: +meteorology.h "; + +%feature("docstring") cmf_core::MeteoStationReference::__init__ "def +__init__(self, args) + +__init__(cmf::atmosphere::MeteoStationReference self, +cmf::atmosphere::MeteoStation::ptr station, point location) -> +MeteoStationReference __init__(cmf::atmosphere::MeteoStationReference +self, MeteoStationReference copy) -> MeteoStationReference +MeteoStationReference(const MeteoStationReference ©) "; + +%feature("docstring") cmf_core::MeteoStationReference::__call__ "def +__call__(self, args, kwargs) + +__call__(Meteorology self, Time t) -> Weather "; + +%feature("docstring") cmf_core::MeteoStationReference::copy "def +copy(self, args, kwargs) + +copy(MeteoStationReference self) -> MeteoStationReference +MeteoStationReference* copy() const Returns a copy of the meteorology +object. Pure virtual function, needs to be implemented. "; + +%feature("docstring") +cmf_core::MeteoStationReference::get_instrument_height "def +get_instrument_height(self, args, kwargs) + +get_instrument_height(Meteorology self) -> real virtual real +get_instrument_height() const =0 Returns the height of the +instruments above canopy. "; + +%feature("docstring") cmf_core::MeteoStationReference::get_position "def get_position(self, args, kwargs) + +get_position(MeteoStationReference self) -> point cmf::geometry::point +get_position() const Returns the position of the reference. "; + +%feature("docstring") cmf_core::MeteoStationReference::get_station "def get_station(self, args, kwargs) + +get_station(MeteoStationReference self) -> +cmf::atmosphere::MeteoStation::ptr MeteoStation::ptr get_station() +const Returns the station referenced. "; + +%feature("docstring") cmf_core::MeteoStationReference::get_weather "def get_weather(self, args, kwargs) + +get_weather(Meteorology self, Time t) -> Weather virtual +cmf::atmosphere::Weather get_weather(cmf::math::Time t) const =0 +Returns the Weather at time t. Pure virtual function. Must get +implemented by child functions. "; + + +// File: classcmf__core_1_1_multi_integrator.xml +%feature("docstring") cmf_core::MultiIntegrator " + +The MultiIntegrator is a wrapper for a bunch integrators. The states +of the integrators should not have direct connections over integrator +boundaries. C++ includes: multiintegrator.h "; + +%feature("docstring") cmf_core::MultiIntegrator::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::math::MultiIntegrator self, Integrator +template_integrator, int count) -> MultiIntegrator +MultiIntegrator(const cmf::math::Integrator &template_integrator, int +count) Creates a new MultiIntegrator. Parameters: ----------- +template_integrator: Template for the integrators count: Number of +integrators "; + +%feature("docstring") cmf_core::MultiIntegrator::__call__ "def +__call__(self, t, dt=None, reset=False) + +Advances the integration until `t` A shortcut to .integrate_until +Parameters ---------- t : cmf.Time The time step to advance to. If +t < current time, the solver will advance to self.t + t dt : +cmf.Time, optional The timestep for the integration. If not given +try to integrate in one step reset : bool, optional If True, the +solver will perform a reset before starting Returns ------- cmf.Time +The new time stamp "; + +%feature("docstring") cmf_core::MultiIntegrator::__getitem__ "def +__getitem__(self, args, kwargs) + +__getitem__(Integrator self, long position) -> +cmf::math::StateVariable::ptr "; + +%feature("docstring") cmf_core::MultiIntegrator::__len__ "def +__len__(self, args, kwargs) + +__len__(Integrator self) -> size_t "; + +%feature("docstring") cmf_core::MultiIntegrator::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::MultiIntegrator::add_single_state "def add_single_state(self, args, kwargs) + +add_single_state(Integrator self, cmf::math::StateVariable::ptr state) +virtual void add_single_state(cmf::math::StateVariable::ptr state) +Adds a single state variable to the integrator. "; + +%feature("docstring") cmf_core::MultiIntegrator::add_states "def +add_states(self, args, kwargs) + +add_states(Integrator self, StateVariableOwner stateOwner) virtual +void add_states(cmf::math::StateVariableOwner &stateOwner) Add state +variables from a StateVariableOwner. "; + +%feature("docstring") +cmf_core::MultiIntegrator::add_states_to_integrator "def +add_states_to_integrator(self, args, kwargs) + +add_states_to_integrator(MultiIntegrator self, StateVariableOwner +stateOwner, int integrator_position) void +add_states_to_integrator(cmf::math::StateVariableOwner &stateOwner, +int integrator_position) Add state variables from a +StateVariableOwner. "; + +%feature("docstring") cmf_core::MultiIntegrator::copy "def +copy(self, args, kwargs) + +copy(MultiIntegrator self) -> MultiIntegrator virtual +cmf::math::MultiIntegrator* copy() const Polymorphic copy +constructor. "; + +%feature("docstring") cmf_core::MultiIntegrator::get_dt "def +get_dt(self, args, kwargs) + +get_dt(Integrator self) -> Time cmf::math::Time get_dt() const +Returns the last time step. "; + +%feature("docstring") cmf_core::MultiIntegrator::get_dxdt "def +get_dxdt(self, args, kwargs) + +get_dxdt(Integrator self, Time time) -> cmf::math::num_array +cmf::math::num_array get_dxdt(Time time) const "; + +%feature("docstring") cmf_core::MultiIntegrator::get_state "def +get_state(self, args, kwargs) + +get_state(Integrator self, ptrdiff_t position) -> real real +get_state(ptrdiff_t position) const Returns the statevariable at +position Simplifies the assessment of state variables. "; + +%feature("docstring") cmf_core::MultiIntegrator::get_states "def +get_states(self, args) + +get_states(Integrator self) -> cmf::math::num_array +get_states(Integrator self) -> StateVariableList StateVariableList +get_states() gets the state variables of the integrator "; + +%feature("docstring") cmf_core::MultiIntegrator::get_t "def +get_t(self, args, kwargs) + +get_t(Integrator self) -> Time cmf::math::Time get_t() const Returns +the current model time. "; + +%feature("docstring") cmf_core::MultiIntegrator::integrate "def +integrate(self, args, kwargs) + +integrate(Integrator self, Time t_max, Time dt) -> int virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt)=0 Integrates the +vector of state variables. Parameters: ----------- t_max: To stop +the model (if running in a model framework) at time steps of value +exchange e.g. full hours, the next value exchange time can be given +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; + +%feature("docstring") cmf_core::MultiIntegrator::integrate_until "def integrate_until(self, args, kwargs) + +integrate_until(Integrator self, Time t_max, Time dt, bool +reset=False) void integrate_until(cmf::math::Time t_max, +cmf::math::Time dt=Time(), bool reset=false) Integrates the vector of +state variables until t_max. Parameters: ----------- t_max: Time, +the solver should run to dt: Time step (may be omitted) reset: If +true, solver is reseted before integration starts "; + +%feature("docstring") cmf_core::MultiIntegrator::reset "def +reset(self, args, kwargs) + +reset(Integrator self) virtual void reset() Resets any saved history +(for multistep methods) "; + +%feature("docstring") cmf_core::MultiIntegrator::run "def run(self, +start=None, end=None, step=day *1, max_errors=0, reset=False) + +Returns an iterator over the timesteps start..end **Examples:** >>> +solver=cmf.CVodeIntegrator(...) >>> for t in solver.run(solver.t, +solver.t + cmf.week, cmf.h): >>> print(t, solver[0].state) or with +list comprehension >>> states = [solver[0].state for t in +solver.run(solver.t, solver.t + cmf.week, cmf.h)] Parameters +---------- start : cmf.Time, optional Start time for the solver +iteration end : cmf.Time, optional End time of the iteration step : +cmf.Time, optional Step size for the integration max_errors: int +Number of tolerated errors. If >0, up to these number of runtime +errors will be saved with their time and the integration proceeds +after a reset of the solver. Some systems operate with values close to +their physical limits and inifinite values in the integration can +easily occur. For these kind of systems set max_errors to eg. 10. A +larger number of errors should be eliminated usually. reset: bool If +True, the solver performs a `reset` at every time step Yields ------ +cmf.Time the actual timestep "; + +%feature("docstring") cmf_core::MultiIntegrator::set_state "def +set_state(self, args, kwargs) + +set_state(Integrator self, ptrdiff_t position, real newState) void +set_state(ptrdiff_t position, real newState) Simplifies the +assessment of state variables. "; + +%feature("docstring") cmf_core::MultiIntegrator::set_t "def +set_t(self, args, kwargs) + +set_t(Integrator self, Time val) void set_t(cmf::math::Time val) Sets +the current model time. "; + +%feature("docstring") cmf_core::MultiIntegrator::size "def +size(self, args, kwargs) + +size(Integrator self) -> size_t size_t size() const returns the +number of state variables "; + + +// File: classcmf_1_1math_1_1_multi_integrator.xml +%feature("docstring") cmf::math::MultiIntegrator " + +The MultiIntegrator is a wrapper for a bunch integrators. The states +of the integrators should not have direct connections over integrator +boundaries. + +C++ includes: multiintegrator.h "; + +/* Accuracy parameters */ + +/* model time */ + +%feature("docstring") cmf::math::MultiIntegrator::get_t "cmf::math::Time get_t() const + +Returns the current model time. "; + +%feature("docstring") cmf::math::MultiIntegrator::set_t "void +set_t(cmf::math::Time val) + +Sets the current model time. "; + +%feature("docstring") cmf::math::MultiIntegrator::get_dt "cmf::math::Time get_dt() const + +Returns the last time step. "; + +/* Integrate */ + +%feature("docstring") cmf::math::MultiIntegrator::integrate_until "void integrate_until(cmf::math::Time t_max, cmf::math::Time dt=Time(), +bool reset=false) + +Integrates the vector of state variables until t_max. + +Parameters: +----------- + +t_max: Time, the solver should run to + +dt: Time step (may be omitted) + +reset: If true, solver is reseted before integration starts "; + +%feature("docstring") cmf::math::MultiIntegrator::MultiIntegrator "MultiIntegrator(const cmf::math::Integrator &template_integrator, int +count) + +Creates a new MultiIntegrator. + +Parameters: +----------- + +template_integrator: Template for the integrators + +count: Number of integrators "; + +%feature("docstring") cmf::math::MultiIntegrator::add_single_state "virtual void add_single_state(cmf::math::StateVariable::ptr state) + +Adds a single state variable to the integrator. "; + +%feature("docstring") cmf::math::MultiIntegrator::add_states "void +add_states(cmf::math::StateVariableOwner &stateOwner) + +Only there to override Integrator::AddStatesFromOwner. Throws an +exception. Use add_states_to_integrator instead. "; + +%feature("docstring") +cmf::math::MultiIntegrator::add_states_to_integrator "void +add_states_to_integrator(cmf::math::StateVariableOwner &stateOwner, +int integrator_position) + +Add state variables from a StateVariableOwner. "; + +%feature("docstring") +cmf::math::MultiIntegrator::add_values_to_states "void +add_values_to_states(const num_array &operands) + +Adds the values in operands to the current states. "; + +%feature("docstring") cmf::math::MultiIntegrator::copy "virtual +cmf::math::MultiIntegrator* copy() const + +Polymorphic copy constructor. "; + +%feature("docstring") cmf::math::MultiIntegrator::copy_dxdt "void +copy_dxdt(Time time, num_array &destination, real factor=1) const + +Copies the derivatives at time step \"time\" to a numeric vector using +use_OpenMP. + +Parameters: +----------- + +time: Time at which the derivatives should be calculated + +destination: Vector to be overwritten by the results + +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; + +%feature("docstring") cmf::math::MultiIntegrator::copy_dxdt "void +copy_dxdt(Time time, real *destination, real factor=1) const + +Copies the derivatives at time step \"time\" to an preallocated c +array. + +Parameters: +----------- + +time: Time at which the derivatives should be calculated + +destination: Allocated c array + +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; + +%feature("docstring") cmf::math::MultiIntegrator::copy_states "void +copy_states(num_array &destination) const + +Copies the states to a numeric vector using use_OpenMP. "; + +%feature("docstring") cmf::math::MultiIntegrator::copy_states "void +copy_states(real *destination) const "; + +%feature("docstring") cmf::math::MultiIntegrator::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; + +%feature("docstring") cmf::math::MultiIntegrator::get_state "real +get_state(ptrdiff_t position) const + +Returns the statevariable at position Simplifies the assessment of +state variables. "; + +%feature("docstring") cmf::math::MultiIntegrator::get_states "cmf::math::num_array get_states() const "; + +%feature("docstring") cmf::math::MultiIntegrator::get_states "StateVariableList get_states() + +gets the state variables of the integrator "; + +%feature("docstring") cmf::math::MultiIntegrator::integrate "int +integrate(cmf::math::Time t_max, cmf::math::Time dt) + +Integrates the vector of state variables. + +Parameters: +----------- + +t_max: To stop the model (if running in a model framework) at time +steps of value exchange e.g. full hours, the next value exchange time +can be given + +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; + +%feature("docstring") cmf::math::MultiIntegrator::reset "virtual +void reset() + +Resets the integrator. "; + +%feature("docstring") cmf::math::MultiIntegrator::set_state "void +set_state(ptrdiff_t position, real newState) + +Simplifies the assessment of state variables. "; + +%feature("docstring") cmf::math::MultiIntegrator::set_states "void +set_states(const num_array &newStates) + +Copies the new states to the actual states. "; + +%feature("docstring") cmf::math::MultiIntegrator::set_states "void +set_states(real *newStates) "; + +%feature("docstring") cmf::math::MultiIntegrator::size "size_t +size() const + +returns the number of state variables "; + + +// File: classcmf_1_1maps_1_1_nearest_neighbor_map.xml +%feature("docstring") cmf::maps::NearestNeighborMap " + +A map (spatial distribution of data) returning the nearest neighbor to +the queried position Stores position referenced objects. z_weight is +a weight, how important vertical differences are for neighborhood. 0 +means only horizontal distance and a high value only uses the height +as a distance measure. The distance to be minimized is calculated as: +sqrt((x1-x2)**2+(y1-y2)**2)+abs(z1-z2)*z_weight "; + +%feature("docstring") cmf::maps::NearestNeighborMap::__init__ "def +__init__(self, z_weight=0) "; + +%feature("docstring") cmf::maps::NearestNeighborMap::__call__ "def +__call__(self, x, y, z=0) + +returns the nearest neighbor object to the given position The +distance to be minimized is calculated as: +sqrt((x1-x2)**2+(y1-y2)**2)+abs(z1-z2)*z_weight "; + +%feature("docstring") cmf::maps::NearestNeighborMap::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf::maps::NearestNeighborMap::__nonzero__ "def __nonzero__(self) "; + +%feature("docstring") cmf::maps::NearestNeighborMap::append "def +append(self, position, object) "; + +%feature("docstring") cmf::maps::NearestNeighborMap::remove "def +remove(self, position) "; + +%feature("docstring") cmf::maps::NearestNeighborMap::values "def +values(self) "; + + +// File: classcmf_1_1upslope_1_1neighbor__iterator.xml +%feature("docstring") cmf::upslope::neighbor_iterator " + +A class to iterate through the neighbors of a cell (const). Not needed +from the Python side, use the generator cell.neighbors instead. + +C++ includes: Topology.h "; + +%feature("docstring") +cmf::upslope::neighbor_iterator::neighbor_iterator "neighbor_iterator(cmf::upslope::Topology &topo) "; + +%feature("docstring") +cmf::upslope::neighbor_iterator::neighbor_iterator "neighbor_iterator(cmf::upslope::Cell *cell) "; + +%feature("docstring") cmf::upslope::neighbor_iterator::cell "Cell& +cell() "; + +%feature("docstring") cmf::upslope::neighbor_iterator::flowwidth "double flowwidth() "; + +%feature("docstring") cmf::upslope::neighbor_iterator::next_neighbor +"neighbor_iterator& next_neighbor() + +Points the iterator to the next neighbor. "; + +%feature("docstring") cmf::upslope::neighbor_iterator::valid "bool +valid() const "; + + +// File: classcmf__core_1_1neighbor__iterator.xml +%feature("docstring") cmf_core::neighbor_iterator " + +A class to iterate through the neighbors of a cell (const). Not needed +from the Python side, use the generator cell.neighbors instead. C++ +includes: Topology.h "; + +%feature("docstring") cmf_core::neighbor_iterator::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::neighbor_iterator self, Cell cell) -> +neighbor_iterator neighbor_iterator(cmf::upslope::Cell *cell) "; + +%feature("docstring") cmf_core::neighbor_iterator::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(neighbor_iterator self, neighbor_iterator cmp) -> bool "; + +%feature("docstring") cmf_core::neighbor_iterator::__neq__ "def +__neq__(self, args, kwargs) + +__neq__(neighbor_iterator self, neighbor_iterator cmp) -> bool "; + +%feature("docstring") cmf_core::neighbor_iterator::cell "def +cell(self, args, kwargs) + +cell(neighbor_iterator self) -> Cell Cell& cell() "; + +%feature("docstring") cmf_core::neighbor_iterator::flowwidth "def +flowwidth(self, args, kwargs) + +flowwidth(neighbor_iterator self) -> double double flowwidth() "; + +%feature("docstring") cmf_core::neighbor_iterator::next_neighbor "def next_neighbor(self, args, kwargs) + +next_neighbor(neighbor_iterator self) -> neighbor_iterator +neighbor_iterator& next_neighbor() Points the iterator to the next +neighbor. "; + +%feature("docstring") cmf_core::neighbor_iterator::valid "def +valid(self, args, kwargs) + +valid(neighbor_iterator self) -> bool bool valid() const "; + + +// File: classcmf__core_1_1_neumann_boundary.xml +%feature("docstring") cmf_core::NeumannBoundary " + +A Neumann boundary condition (constant flux boundary condition) The +flux is a timeseries, but can be used as a scalar. To scale the +timeseries to the specific conditions of this boundary condition the +linear_scale flux_scale can be used. C++ includes: +boundary_condition.h "; + +%feature("docstring") cmf_core::NeumannBoundary::__init__ "def +__init__(self, args) + +__init__(cmf::water::NeumannBoundary self, project _project, +timeseries _flux, SoluteTimeseries _concentration, point loc) -> +NeumannBoundary __init__(cmf::water::NeumannBoundary self, project +_project, point loc) -> NeumannBoundary NeumannBoundary(cmf::project +&_project, cmf::geometry::point loc=cmf::geometry::point()) "; + +%feature("docstring") cmf_core::NeumannBoundary::__call__ "def +__call__(self, args, kwargs) + +__call__(NeumannBoundary self, Time t) -> real "; + +%feature("docstring") cmf_core::NeumannBoundary::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_node self, flux_node other) -> bool "; + +%feature("docstring") cmf_core::NeumannBoundary::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::NeumannBoundary::conc "def +conc(self, args, kwargs) + +conc(flux_node self, Time t, solute Solute) -> real virtual real +conc(cmf::math::Time t, const cmf::water::solute &Solute) const +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; + +%feature("docstring") cmf_core::NeumannBoundary::connect_to "def +connect_to(self, args, kwargs) + +connect_to(NeumannBoundary self, cmf::water::flux_node::ptr target) +void connect_to(cmf::water::flux_node::ptr target) "; + +%feature("docstring") cmf_core::NeumannBoundary::connected_nodes "def connected_nodes(self) "; + +%feature("docstring") cmf_core::NeumannBoundary::connection_to "def +connection_to(self, args, kwargs) + +connection_to(flux_node self, flux_node target) -> flux_connection +cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) Returns the connection between this and target. "; + +%feature("docstring") cmf_core::NeumannBoundary::create "def +create(args, kwargs) + +create(cmf::water::flux_node::ptr target) -> +cmf::water::NeumannBoundary::ptr "; + +%feature("docstring") cmf_core::NeumannBoundary::flux3d_to "def +flux3d_to(self, args, kwargs) + +flux3d_to(flux_node self, flux_node target, Time t) -> point +cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; + +%feature("docstring") cmf_core::NeumannBoundary::flux_to "def +flux_to(self, args, kwargs) + +flux_to(flux_node self, flux_node target, Time t) -> real real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; + +%feature("docstring") cmf_core::NeumannBoundary::fluxes "def +fluxes(self, t) "; + +%feature("docstring") cmf_core::NeumannBoundary::get_3d_flux "def +get_3d_flux(self, args, kwargs) + +get_3d_flux(flux_node self, Time t) -> point cmf::geometry::point +get_3d_flux(cmf::math::Time t) Returns the sum of all flux vectors. +"; + +%feature("docstring") cmf_core::NeumannBoundary::get_flux "def +get_flux(self, args, kwargs) + +get_flux(NeumannBoundary self) -> timeseries cmf::math::timeseries +get_flux() The timeseries of the boundary flux. "; + +%feature("docstring") cmf_core::NeumannBoundary::is_empty "def +is_empty(self, args, kwargs) + +is_empty(flux_node self) -> double virtual double is_empty() const +Returns true if the node has no water. "; + +%feature("docstring") cmf_core::NeumannBoundary::is_storage "def +is_storage(self, args, kwargs) + +is_storage(flux_node self) -> bool virtual bool is_storage() const +true, if this is a waterstorage "; + +%feature("docstring") cmf_core::NeumannBoundary::RecalcFluxes "def +RecalcFluxes(self, args, kwargs) + +RecalcFluxes(flux_node self, Time t) -> bool virtual bool +RecalcFluxes(cmf::math::Time t) Pure flux_nodes do not influence +fluxes, therefore no recalculation of fluxes is required by flux_node. +WaterStorage overrides this, since state changes require an update of +the fluxes "; + +%feature("docstring") cmf_core::NeumannBoundary::remove_connection "def remove_connection(self, args, kwargs) + +remove_connection(flux_node self, cmf::water::flux_node::ptr To) -> +bool bool remove_connection(cmf::water::flux_node::ptr To) Remove +the connection. "; + +%feature("docstring") cmf_core::NeumannBoundary::set_flux "def +set_flux(self, args) + +set_flux(NeumannBoundary self, timeseries new_flux) +set_flux(NeumannBoundary self, double new_flux) void set_flux(double +new_flux) Set a constant as the boundary flux. "; + +%feature("docstring") cmf_core::NeumannBoundary::to_string "def +to_string(self, args, kwargs) + +to_string(flux_node self) -> std::string virtual std::string +to_string() const "; + +%feature("docstring") cmf_core::NeumannBoundary::waterbalance "def +waterbalance(self, args, kwargs) + +waterbalance(flux_node self, Time t, flux_connection Without=None) -> +real real waterbalance(cmf::math::Time t, const flux_connection +*Without=0) const Returns the sum of all fluxes (positive and +negative) at time t. Single fluxes can be excluded from the +calculation Parameters: ----------- t: Time of the query Without: +A flux_connection that is excluded from the waterbalance (e.g. to +prevent closed circuits) "; + + +// File: classcmf_1_1water_1_1_neumann_boundary.xml +%feature("docstring") cmf::water::NeumannBoundary " + +A Neumann boundary condition (constant flux boundary condition) + +The flux is a timeseries, but can be used as a scalar. To scale the +timeseries to the specific conditions of this boundary condition the +linear_scale flux_scale can be used. + +C++ includes: boundary_condition.h "; + +%feature("docstring") cmf::water::NeumannBoundary::NeumannBoundary "NeumannBoundary(cmf::project &_project, cmf::math::timeseries _flux, +cmf::water::SoluteTimeseries +_concentration=cmf::water::SoluteTimeseries(), cmf::geometry::point +loc=cmf::geometry::point()) + +Ctor of the Neumann boundary. + +Parameters: +----------- + +_project: The project this boundary condition belongs to + +_flux: The flux timeseries (a scalar is converted to a timeseries +automatically) + +_concentration: The concentration timeseries + +loc: The location of the boundary condition "; + +%feature("docstring") cmf::water::NeumannBoundary::NeumannBoundary "NeumannBoundary(cmf::project &_project, cmf::geometry::point +loc=cmf::geometry::point()) "; + +%feature("docstring") cmf::water::NeumannBoundary::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) const + +Returns the solute concentrations of the flux at a given time. "; + +%feature("docstring") cmf::water::NeumannBoundary::connect_to "void +connect_to(cmf::water::flux_node::ptr target) "; + +%feature("docstring") cmf::water::NeumannBoundary::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) + +Returns the connection between this and target. "; + +%feature("docstring") cmf::water::NeumannBoundary::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; + +%feature("docstring") cmf::water::NeumannBoundary::flux_to "real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) + +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; + +%feature("docstring") cmf::water::NeumannBoundary::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) + +Returns the sum of all flux vectors. "; + +%feature("docstring") cmf::water::NeumannBoundary::get_connections "cmf::water::connection_list get_connections() const "; + +%feature("docstring") cmf::water::NeumannBoundary::get_flux "cmf::math::timeseries get_flux() + +The timeseries of the boundary flux. "; + +%feature("docstring") cmf::water::NeumannBoundary::get_potential "virtual real get_potential() const + +Returns the water potential of the node in m waterhead. + +The base class water storage always returns the height of the location +"; + +%feature("docstring") cmf::water::NeumannBoundary::get_project "cmf::project& get_project() const + +Returns the project, this node is part of. "; + +%feature("docstring") cmf::water::NeumannBoundary::is_empty "double +is_empty() const + +Returns true if the node has no water. "; + +%feature("docstring") cmf::water::NeumannBoundary::is_storage "virtual bool is_storage() const + +true, if this is a waterstorage "; + +%feature("docstring") cmf::water::NeumannBoundary::RecalcFluxes "bool RecalcFluxes(cmf::math::Time t) + +Pure flux_nodes do not influence fluxes, therefore no recalculation of +fluxes is required by flux_node. + +WaterStorage overrides this, since state changes require an update of +the fluxes "; + +%feature("docstring") cmf::water::NeumannBoundary::remove_connection +"bool remove_connection(cmf::water::flux_node::ptr To) + +Remove the connection. "; + +%feature("docstring") cmf::water::NeumannBoundary::set_flux "void +set_flux(cmf::math::timeseries new_flux) + +Set a timeseries as the boundary flux. "; + +%feature("docstring") cmf::water::NeumannBoundary::set_flux "void +set_flux(double new_flux) + +Set a constant as the boundary flux. "; + +%feature("docstring") cmf::water::NeumannBoundary::set_potential "virtual void set_potential(real new_potential) + +Sets the potential of this flux node. "; + +%feature("docstring") cmf::water::NeumannBoundary::to_string "virtual std::string to_string() const "; + +%feature("docstring") cmf::water::NeumannBoundary::waterbalance "real waterbalance(cmf::math::Time t, const flux_connection *Without=0) +const + +Returns the sum of all fluxes (positive and negative) at time t. + +Single fluxes can be excluded from the calculation + +Parameters: +----------- + +t: Time of the query + +Without: A flux_connection that is excluded from the waterbalance +(e.g. to prevent closed circuits) "; + + +// File: classcmf__core_1_1_neumann_boundary__list.xml +%feature("docstring") cmf_core::NeumannBoundary_list " + +Provides fast access to Neumann boundaries for flux update. If many +Neumann boundary conditions are present in a project, a fast data +exchange to update the fluxes might be needed. With this specialized +list a num_array can be passed to the boundary conditions for a fast +flux update If a multiple system layout for the cmf setup is chosen, +we might have a node_list Dirichlet boundary conditions (dbc), a +corresponding NeumannBoundary_list (nbc) of Neumann boundaries and a +node_list containing the storages connected with the +NeumannBoundary_list (storages). The fast data exchange is written in +Python as: C++ includes: collections.h "; + +%feature("docstring") cmf_core::NeumannBoundary_list::__init__ "def +__init__(self, args) + +__init__(cmf::water::NeumannBoundary_list self) -> +NeumannBoundary_list __init__(cmf::water::NeumannBoundary_list self, +node_list copy) -> NeumannBoundary_list +__init__(cmf::water::NeumannBoundary_list self, NeumannBoundary_list +copy) -> NeumannBoundary_list NeumannBoundary_list(const +NeumannBoundary_list ©) "; + +%feature("docstring") cmf_core::NeumannBoundary_list::__getitem__ "def __getitem__(self, index) "; + +%feature("docstring") cmf_core::NeumannBoundary_list::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::NeumannBoundary_list::__len__ "def +__len__(self) "; + +%feature("docstring") cmf_core::NeumannBoundary_list::append "def +append(self, args, kwargs) + +append(NeumannBoundary_list self, cmf::water::NeumannBoundary::ptr +nbc) void append(NeumannBoundary::ptr nbc) Appends a neumann +boundary to this list. "; + +%feature("docstring") cmf_core::NeumannBoundary_list::extend "def +extend(self, sequence) + +Extends the list of Neumann boundaries with the sequence (any iterable +will do) "; + +%feature("docstring") cmf_core::NeumannBoundary_list::get "def +get(self, args, kwargs) + +get(NeumannBoundary_list self, ptrdiff_t index) -> +cmf::water::NeumannBoundary::ptr NeumannBoundary::ptr get(ptrdiff_t +index) const Returns the Neumann boundary condition at position +index. From Python you can use [] "; + +%feature("docstring") cmf_core::NeumannBoundary_list::get_fluxes "def get_fluxes(self, args, kwargs) + +get_fluxes(NeumannBoundary_list self, Time t) -> cmf::math::num_array +cmf::math::num_array get_fluxes(cmf::math::Time t=cmf::math::Time()) +const Returns the fluxes of the items as an array. get_fluxes and +set_fluxes are wrapped with the Python property fluxes "; + +%feature("docstring") +cmf_core::NeumannBoundary_list::global_water_balance "def +global_water_balance(self, args, kwargs) + +global_water_balance(NeumannBoundary_list self, Time t) -> real real +global_water_balance(cmf::math::Time t) const Returns the sum of the +water balances of the nodes .. math:: \\\\\\\\sigma_{global} = +\\\\\\\\sum_{i=0}^N{\\\\\\\\sum_{j=0}^{C_i}{q_{ij}(t)}} . Replaces +slow Python code like: "; + +%feature("docstring") cmf_core::NeumannBoundary_list::size "def +size(self, args, kwargs) + +size(NeumannBoundary_list self) -> size_t size_t size() const returns +the number of stored boundary conditions "; + +%feature("docstring") cmf_core::NeumannBoundary_list::to_node_list "def to_node_list(self, args, kwargs) + +to_node_list(NeumannBoundary_list self) -> node_list +cmf::water::node_list to_node_list() const Creates a node_list from +this NeumannBoundary_list. "; + +%feature("docstring") cmf_core::NeumannBoundary_list::water_balance "def water_balance(self, args, kwargs) + +water_balance(NeumannBoundary_list self, Time t) -> +cmf::math::num_array cmf::math::num_array +water_balance(cmf::math::Time t) const Returns the water balance of +each vector as a vector .. math:: \\\\\\\\sigma_i = +\\\\\\\\sum_{j=0}^{C_i}{q_{ij}(t)} . Replaces slow Python code +like: "; + + +// File: classcmf_1_1water_1_1_neumann_boundary__list.xml +%feature("docstring") cmf::water::NeumannBoundary_list " + +Provides fast access to Neumann boundaries for flux update. + +If many Neumann boundary conditions are present in a project, a fast +data exchange to update the fluxes might be needed. + +With this specialized list a num_array can be passed to the boundary +conditions for a fast flux update If a multiple system layout for the +cmf setup is chosen, we might have a node_list Dirichlet boundary +conditions (dbc), a corresponding NeumannBoundary_list (nbc) of +Neumann boundaries and a node_list containing the storages connected +with the NeumannBoundary_list (storages). The fast data exchange is +written in Python as: + +C++ includes: collections.h "; + +%feature("docstring") +cmf::water::NeumannBoundary_list::NeumannBoundary_list "NeumannBoundary_list() "; + +%feature("docstring") +cmf::water::NeumannBoundary_list::NeumannBoundary_list "NeumannBoundary_list(const cmf::water::node_list ©) "; + +%feature("docstring") +cmf::water::NeumannBoundary_list::NeumannBoundary_list "NeumannBoundary_list(const NeumannBoundary_list ©) "; + +%feature("docstring") cmf::water::NeumannBoundary_list::append "void +append(NeumannBoundary::ptr nbc) + +Appends a neumann boundary to this list. "; + +%feature("docstring") cmf::water::NeumannBoundary_list::get "NeumannBoundary::ptr get(ptrdiff_t index) const + +Returns the Neumann boundary condition at position index. + +From Python you can use [] "; + +%feature("docstring") cmf::water::NeumannBoundary_list::get_fluxes "cmf::math::num_array get_fluxes(cmf::math::Time t=cmf::math::Time()) +const + +Returns the fluxes of the items as an array. + +get_fluxes and set_fluxes are wrapped with the Python property fluxes +"; + +%feature("docstring") +cmf::water::NeumannBoundary_list::global_water_balance "real +global_water_balance(cmf::math::Time t) const + +Returns the sum of the water balances of the nodes + + +.. math:: + + \\\\sigma_{global} = + \\\\sum_{i=0}^N{\\\\sum_{j=0}^{C_i}{q_{ij}(t)}} + +. + +Replaces slow Python code like: "; + +%feature("docstring") cmf::water::NeumannBoundary_list::set_fluxes "void set_fluxes(cmf::math::num_array values) + +Sets the fluxes of the items from an array. + +get_fluxes and set_fluxes are wrapped with the Python property fluxes +"; + +%feature("docstring") cmf::water::NeumannBoundary_list::size "size_t +size() const + +returns the number of stored boundary conditions "; + +%feature("docstring") cmf::water::NeumannBoundary_list::to_node_list +"cmf::water::node_list to_node_list() const + +Creates a node_list from this NeumannBoundary_list. "; + +%feature("docstring") cmf::water::NeumannBoundary_list::water_balance +"cmf::math::num_array water_balance(cmf::math::Time t) const + +Returns the water balance of each vector as a vector + +.. math:: + + \\\\sigma_i + = \\\\sum_{j=0}^{C_i}{q_{ij}(t)} + +. + +Replaces slow Python code like: "; + + +// File: classcmf__core_1_1_neumann_flux.xml +%feature("docstring") cmf_core::NeumannFlux " + +Connection between Neumann-boundary and a flux node. This +flux_connection is created, when connecting a Neumann boundary +condition with a state variable using Neumann::connect_to C++ +includes: boundary_condition.h "; + +%feature("docstring") cmf_core::NeumannFlux::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::water::NeumannFlux self, std::shared_ptr< +cmf::water::NeumannBoundary > left, cmf::water::flux_node::ptr right) +-> NeumannFlux NeumannFlux(std::shared_ptr< NeumannBoundary > left, +cmf::water::flux_node::ptr right) "; + +%feature("docstring") cmf_core::NeumannFlux::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::NeumannFlux::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::NeumannFlux::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::NeumannFlux::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::NeumannFlux::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::NeumannFlux::conc "def conc(self, +args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") cmf_core::NeumannFlux::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::NeumannFlux::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::NeumannFlux::get_tracer_filter "def +get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::NeumannFlux::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::NeumannFlux::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::NeumannFlux::q "def q(self, args, +kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::NeumannFlux::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::NeumannFlux::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::NeumannFlux::set_tracer_filter "def +set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::NeumannFlux::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::NeumannFlux::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf_1_1water_1_1_neumann_flux.xml +%feature("docstring") cmf::water::NeumannFlux " + +Connection between Neumann-boundary and a flux node. + +This flux_connection is created, when connecting a Neumann boundary +condition with a state variable using Neumann::connect_to + +C++ includes: boundary_condition.h "; + +%feature("docstring") cmf::water::NeumannFlux::NeumannFlux "NeumannFlux(std::shared_ptr< NeumannBoundary > left, +cmf::water::flux_node::ptr right) "; + +%feature("docstring") cmf::water::NeumannFlux::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") cmf::water::NeumannFlux::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf::water::NeumannFlux::get_ptr "ptr +get_ptr() const "; + +%feature("docstring") cmf::water::NeumannFlux::get_target "flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") cmf::water::NeumannFlux::get_target "flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") cmf::water::NeumannFlux::get_tracer_filter "real get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") cmf::water::NeumannFlux::get_tracer_filter "real get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") cmf::water::NeumannFlux::kill_me "bool +kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") cmf::water::NeumannFlux::left_node "flux_node::ptr left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") cmf::water::NeumannFlux::q "real q(const +flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") cmf::water::NeumannFlux::refresh "void +refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") cmf::water::NeumannFlux::right_node "flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") cmf::water::NeumannFlux::set_tracer_filter "void set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") cmf::water::NeumannFlux::set_tracer_filter "void set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf::water::NeumannFlux::short_string "virtual +std::string short_string() const "; + +%feature("docstring") cmf::water::NeumannFlux::to_string "virtual +std::string to_string() const "; + + +// File: classcmf_1_1water_1_1node__list.xml +%feature("docstring") cmf::water::node_list " + +A collection of nodes for fast access of the waterbalance. + +In setups with many storages and rather fast computations, the speed +of data access for output generation can take a high portion of the +total run time. To accelerate data access, one can use the node_list +object + +Todo Add a get_volume / set_volume function pair, to complement +get_potential / set_potential + +C++ includes: collections.h "; + +%feature("docstring") cmf::water::node_list::node_list "node_list() + +Creates an empty node_lust. "; + +%feature("docstring") cmf::water::node_list::node_list "node_list(const cmf::water::node_list &forcopy) + +Copy the node_list. "; + +%feature("docstring") cmf::water::node_list::~node_list "virtual +~node_list() "; + +%feature("docstring") cmf::water::node_list::append "void +append(flux_node::ptr node) + +Adds a flux node to the list. "; + +%feature("docstring") cmf::water::node_list::begin "node_vector::iterator begin() "; + +%feature("docstring") cmf::water::node_list::begin "node_vector::const_iterator begin() const "; + +%feature("docstring") cmf::water::node_list::conc "cmf::math::num_array conc(cmf::math::Time t, const cmf::water::solute +&_Solute) const + +Returns an array holding the concentration of all the flux nodes for +the given solute. "; + +%feature("docstring") cmf::water::node_list::end "node_vector::iterator end() "; + +%feature("docstring") cmf::water::node_list::end "node_vector::const_iterator end() const "; + +%feature("docstring") cmf::water::node_list::get "flux_node::ptr +get(ptrdiff_t index) const + +Returns a node in the node_list. "; + +%feature("docstring") cmf::water::node_list::get_fluxes3d "cmf::geometry::point_vector get_fluxes3d(cmf::math::Time t) const + +Returns the current flow vector for each node. "; + +%feature("docstring") cmf::water::node_list::get_fluxes3d_to "cmf::geometry::point_vector get_fluxes3d_to(const +cmf::water::node_list &targets, cmf::math::Time t) const + +Returns the flux vectors to the nodes of a given target node_list. "; + +%feature("docstring") cmf::water::node_list::get_fluxes_to "cmf::math::num_array get_fluxes_to(const cmf::water::node_list +&targets, cmf::math::Time t) const + +A fast method to perform flux queries as a batch. + +The node lists left and right should have the same length. + +The vector containing the flux from left to right at the same position + +Parameters: +----------- + +targets: A node_list containing the source nodes + +t: The time for the fluxes + +Replaces slow Python code like: "; + +%feature("docstring") cmf::water::node_list::get_positions "cmf::geometry::point_vector get_positions() const + +Returns the positions of the nodes. "; + +%feature("docstring") cmf::water::node_list::get_potentials "cmf::math::num_array get_potentials() + +Returns the potential of the nodes. "; + +%feature("docstring") cmf::water::node_list::get_states "cmf::math::StateVariableList get_states() + +Implements StateVariableOwner. "; + +%feature("docstring") cmf::water::node_list::getslice "node_list +getslice(ptrdiff_t begin, ptrdiff_t end, ptrdiff_t step=1) const + +Returns a slice of the node_list. "; + +%feature("docstring") cmf::water::node_list::global_water_balance "real global_water_balance(cmf::math::Time t) const + +Returns the sum of the water balances of the nodes. + + + +.. math:: + + \\\\sigma_{global} = + \\\\sum_{i=0}^N{\\\\sum_{j=0}^{C_i}{q_{ij}(t)}} + +Replaces slow Python code like: "; + +%feature("docstring") cmf::water::node_list::remove "bool +remove(flux_node::ptr node) + +Removes a flux node from the list, returns true if successful. "; + +%feature("docstring") cmf::water::node_list::set_potentials "ptrdiff_t set_potentials(const cmf::math::num_array &potentials) + +Sets the potentials of the node_list. + +If nodes do not have changeable potentials, they are skipped silently +The number of nodes with changed potential "; + +%feature("docstring") cmf::water::node_list::set_solute_source "ptrdiff_t set_solute_source(const cmf::water::solute &_Solute, +cmf::math::num_array source_fluxes) + +Sets the source flux of a solute storage associated with a node (node +has to be a water storage) "; + +%feature("docstring") cmf::water::node_list::size "size_t size() +const + +The number of nodes. "; + +%feature("docstring") cmf::water::node_list::water_balance "cmf::math::num_array water_balance(cmf::math::Time t) const + +Returns the water balance of each vector as a vector. + + + +.. math:: + + \\\\sigma_i = \\\\sum_{j=0}^{C_i}{q_{ij}(t)} + +Replaces slow Python code like: "; + + +// File: classcmf__core_1_1node__list.xml +%feature("docstring") cmf_core::node_list " + +A collection of nodes for fast access of the waterbalance. In setups +with many storages and rather fast computations, the speed of data +access for output generation can take a high portion of the total run +time. To accelerate data access, one can use the node_list object Todo +Add a get_volume / set_volume function pair, to complement +get_potential / set_potential C++ includes: collections.h "; + +%feature("docstring") cmf_core::node_list::__init__ "def +__init__(self, args) + +__init__(cmf::water::node_list self) -> node_list +__init__(cmf::water::node_list self, node_list forcopy) -> node_list +node_list(const cmf::water::node_list &forcopy) Copy the node_list. +"; + +%feature("docstring") cmf_core::node_list::__add__ "def +__add__(self, args, kwargs) + +__add__(node_list self, node_list right) -> node_list "; + +%feature("docstring") cmf_core::node_list::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::node_list::__iadd__ "def +__iadd__(self, args, kwargs) + +__iadd__(node_list self, node_list right) -> node_list "; + +%feature("docstring") cmf_core::node_list::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::node_list::__len__ "def +__len__(self) "; + +%feature("docstring") cmf_core::node_list::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::node_list::append "def append(self, +args, kwargs) + +append(node_list self, cmf::water::flux_node::ptr node) void +append(flux_node::ptr node) Adds a flux node to the list. "; + +%feature("docstring") cmf_core::node_list::conc "def conc(self, +args, kwargs) + +conc(node_list self, Time t, solute _Solute) -> cmf::math::num_array +cmf::math::num_array conc(cmf::math::Time t, const cmf::water::solute +&_Solute) const Returns an array holding the concentration of all the +flux nodes for the given solute. "; + +%feature("docstring") cmf_core::node_list::extend "def extend(self, +sequence) + +Extends the node list with the sequence (any iterable will do) "; + +%feature("docstring") cmf_core::node_list::get_fluxes3d "def +get_fluxes3d(self, args, kwargs) + +get_fluxes3d(node_list self, Time t) -> point_vector +cmf::geometry::point_vector get_fluxes3d(cmf::math::Time t) const +Returns the current flow vector for each node. "; + +%feature("docstring") cmf_core::node_list::get_fluxes3d_to "def +get_fluxes3d_to(self, args, kwargs) + +get_fluxes3d_to(node_list self, node_list targets, Time t) -> +point_vector cmf::geometry::point_vector get_fluxes3d_to(const +cmf::water::node_list &targets, cmf::math::Time t) const Returns the +flux vectors to the nodes of a given target node_list. "; + +%feature("docstring") cmf_core::node_list::get_fluxes_to "def +get_fluxes_to(self, args, kwargs) + +get_fluxes_to(node_list self, node_list targets, Time t) -> +cmf::math::num_array cmf::math::num_array get_fluxes_to(const +cmf::water::node_list &targets, cmf::math::Time t) const A fast +method to perform flux queries as a batch. The node lists left and +right should have the same length. The vector containing the flux +from left to right at the same position Parameters: ----------- +targets: A node_list containing the source nodes t: The time for +the fluxes Replaces slow Python code like: "; + +%feature("docstring") cmf_core::node_list::get_positions "def +get_positions(self, args, kwargs) + +get_positions(node_list self) -> point_vector +cmf::geometry::point_vector get_positions() const Returns the +positions of the nodes. "; + +%feature("docstring") cmf_core::node_list::get_states "def +get_states(self, args, kwargs) + +get_states(StateVariableOwner self) -> StateVariableList virtual +StateVariableList get_states()=0 Add the state variables, owned by an +object derived from StateVariableOwner, to the given vector. "; + +%feature("docstring") cmf_core::node_list::global_water_balance "def +global_water_balance(self, args, kwargs) + +global_water_balance(node_list self, Time t) -> real real +global_water_balance(cmf::math::Time t) const Returns the sum of the +water balances of the nodes. .. math:: \\\\\\\\sigma_{global} += \\\\\\\\sum_{i=0}^N{\\\\\\\\sum_{j=0}^{C_i}{q_{ij}(t)}} Replaces +slow Python code like: "; + +%feature("docstring") cmf_core::node_list::remove "def remove(self, +args, kwargs) + +remove(node_list self, cmf::water::flux_node::ptr node) -> bool bool +remove(flux_node::ptr node) Removes a flux node from the list, +returns true if successful. "; + +%feature("docstring") cmf_core::node_list::set_solute_source "def +set_solute_source(self, args, kwargs) + +set_solute_source(node_list self, solute _Solute, cmf::math::num_array +source_fluxes) -> ptrdiff_t ptrdiff_t set_solute_source(const +cmf::water::solute &_Solute, cmf::math::num_array source_fluxes) Sets +the source flux of a solute storage associated with a node (node has +to be a water storage) "; + +%feature("docstring") cmf_core::node_list::size "def size(self, +args, kwargs) + +size(node_list self) -> size_t size_t size() const The number of +nodes. "; + +%feature("docstring") cmf_core::node_list::water_balance "def +water_balance(self, args, kwargs) + +water_balance(node_list self, Time t) -> cmf::math::num_array +cmf::math::num_array water_balance(cmf::math::Time t) const Returns +the water balance of each vector as a vector. .. math:: +\\\\\\\\sigma_i = \\\\\\\\sum_{j=0}^{C_i}{q_{ij}(t)} Replaces slow +Python code like: "; + + +// File: classcmf_1_1math_1_1root__finding_1_1not__finite__error.xml +%feature("docstring") cmf::math::root_finding::not_finite_error ""; + +%feature("docstring") +cmf::math::root_finding::not_finite_error::not_finite_error "not_finite_error(const std::string &msg) "; + + +// File: classcmf__core_1_1_null_adsorption.xml +%feature("docstring") cmf_core::NullAdsorption " + +A class for tracers without interaction with the storage container. +freesolute returns xt. C++ includes: adsorption.h "; + +%feature("docstring") cmf_core::NullAdsorption::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::water::NullAdsorption self) -> NullAdsorption "; + +%feature("docstring") cmf_core::NullAdsorption::copy "def copy(self, +args, kwargs) + +copy(NullAdsorption self, real m=-1) -> NullAdsorption virtual +NullAdsorption* copy(real m=-1) const returns a copy of the +Adsorption object. If the adsorption is depending on the sorbent +mass, you can give a positive value for the sorbent mass m. If the +value is not given or negative, m is used from the original object. "; + +%feature("docstring") cmf_core::NullAdsorption::freesolute "def +freesolute(self, args, kwargs) + +freesolute(Adsorption self, real xt, real V) -> real virtual real +freesolute(real xt, real V) const =0 Returns the mass of dissolved +tracer as a function of the total tracer mass in the solute storage +and the water volume. Parameters: ----------- xt: :math:`x_t` the +total tracer mass in the storage V: :math:`V m^3` the water volume +in the storage :math:`x_f` the dissolved mass of the tracer "; + +%feature("docstring") cmf_core::NullAdsorption::totalsolute "def +totalsolute(self, args, kwargs) + +totalsolute(Adsorption self, real xf, real V) -> real virtual real +totalsolute(real xf, real V) const =0 Returns the total mass of the +tracer from the dissolved concetration in tracer unit/m3. Parameters: +----------- xf: :math:`x_f` the dissolved tracer mass in the +storage V: :math:`V m^3` the water volume in the storage +:math:`x_t` the total mass of the tracer "; + + +// File: classcmf_1_1water_1_1_null_adsorption.xml +%feature("docstring") cmf::water::NullAdsorption " + +A class for tracers without interaction with the storage container. +freesolute returns xt. + +C++ includes: adsorption.h "; + +%feature("docstring") cmf::water::NullAdsorption::~NullAdsorption "virtual ~NullAdsorption() "; + +%feature("docstring") cmf::water::NullAdsorption::copy "virtual +NullAdsorption* copy(real m=-1) const + +returns a copy of the Adsorption object. + +If the adsorption is depending on the sorbent mass, you can give a +positive value for the sorbent mass m. If the value is not given or +negative, m is used from the original object. "; + +%feature("docstring") cmf::water::NullAdsorption::freesolute "virtual real freesolute(real xt, real V) const + +Returns the mass of dissolved tracer as a function of the total tracer +mass in the solute storage and the water volume. + +Parameters: +----------- + +xt: :math:`x_t` the total tracer mass in the storage + +V: :math:`V m^3` the water volume in the storage + +:math:`x_f` the dissolved mass of the tracer "; + +%feature("docstring") cmf::water::NullAdsorption::totalsolute "virtual real totalsolute(real xf, real V) const + +Returns the total mass of the tracer from the dissolved concetration +in tracer unit/m3. + +Parameters: +----------- + +xf: :math:`x_f` the dissolved tracer mass in the storage + +V: :math:`V m^3` the water volume in the storage + +:math:`x_t` the total mass of the tracer "; + + +// File: classcmf_1_1math_1_1num__array.xml +%feature("docstring") cmf::math::num_array " + +A valarray kind of vector implementation with OpenMP capabilities. + +C++ includes: num_array.h "; + +%feature("docstring") cmf::math::num_array::num_array "num_array() + +constructors "; + +%feature("docstring") cmf::math::num_array::num_array "num_array(const num_array &Vector) "; + +%feature("docstring") cmf::math::num_array::num_array "num_array(const_iterator begin, const_iterator end) "; + +%feature("docstring") cmf::math::num_array::num_array "num_array(ptrdiff_t count, real Value=0.0) "; + +%feature("docstring") cmf::math::num_array::num_array "num_array(size_t count, real Value=0.0) "; + +%feature("docstring") cmf::math::num_array::num_array "num_array(size_t count, real *data) "; + +%feature("docstring") cmf::math::num_array::~num_array "~num_array() + +destructor "; + +%feature("docstring") cmf::math::num_array::apply "num_array +apply(real funct(real)) const "; + +%feature("docstring") cmf::math::num_array::axpy "void axpy(const +real fac, const num_array &other) "; + +%feature("docstring") cmf::math::num_array::begin "iterator begin() +const "; + +%feature("docstring") cmf::math::num_array::dot "real dot(const +num_array &) const "; + +%feature("docstring") cmf::math::num_array::end "iterator end() +const "; + +%feature("docstring") cmf::math::num_array::is_nan "bool is_nan() +const "; + +%feature("docstring") cmf::math::num_array::max "real max() const "; + +%feature("docstring") cmf::math::num_array::mean "real mean() const +"; + +%feature("docstring") cmf::math::num_array::min "real min() const "; + +%feature("docstring") cmf::math::num_array::norm "real norm(int +normtype=0) const "; + +%feature("docstring") cmf::math::num_array::power "num_array +power(const num_array &) const "; + +%feature("docstring") cmf::math::num_array::power "num_array +power(real exponent) const "; + +%feature("docstring") cmf::math::num_array::release "iterator +release() "; + +%feature("docstring") cmf::math::num_array::resize "void +resize(ptrdiff_t count) "; + +%feature("docstring") cmf::math::num_array::scale "void scale(const +real fac) "; + +%feature("docstring") cmf::math::num_array::scale_add "void +scale_add(const real fac, const num_array &other) "; + +%feature("docstring") cmf::math::num_array::set "void set(const +num_array &other) + +Prevents deletion of the stored data. + +Use with care, and only if you know what you are doing. "; + +%feature("docstring") cmf::math::num_array::set "void set(const real +fac, const num_array &other) "; + +%feature("docstring") cmf::math::num_array::size "ptrdiff_t size() +const "; + +%feature("docstring") cmf::math::num_array::sum "real sum() const "; + + +// File: classcmf_1_1river_1_1_open_water_storage.xml +%feature("docstring") cmf::river::OpenWaterStorage " + +An open water body. + +The potential is calculated from the stored water using a water table +function + +C++ includes: OpenWaterStorage.h "; + +/* Overrides of flux_node */ + +%feature("docstring") cmf::river::OpenWaterStorage::RecalcFluxes "virtual bool RecalcFluxes(cmf::math::Time t) + +Pure flux_nodes do not influence fluxes, therefore no recalculation of +fluxes is required by flux_node. + +WaterStorage overrides this, since state changes require an update of +the fluxes "; + +%feature("docstring") cmf::river::OpenWaterStorage::is_empty "virtual double is_empty() const + +Returns true if the node has no water. "; + +%feature("docstring") cmf::river::OpenWaterStorage::to_string "virtual std::string to_string() const "; + +%feature("docstring") +cmf::river::OpenWaterStorage::add_connected_states "virtual void +add_connected_states(cmf::math::StateVariable::list &states) "; + +%feature("docstring") cmf::river::OpenWaterStorage::conc "real +conc(cmf::math::Time t, const cmf::water::solute &solute) const + +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; + +%feature("docstring") cmf::river::OpenWaterStorage::conc "real +conc(const cmf::water::solute &_Solute) const + +Returns the concentration of the given solute. "; + +%feature("docstring") cmf::river::OpenWaterStorage::conc "void +conc(const cmf::water::solute &_Solute, real NewConcetration) + +Sets a new concentration. "; + +%feature("docstring") cmf::river::OpenWaterStorage::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) + +Returns the connection between this and target. "; + +%feature("docstring") cmf::river::OpenWaterStorage::dxdt "virtual +real dxdt(const cmf::math::Time &time) "; + +%feature("docstring") cmf::river::OpenWaterStorage::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; + +%feature("docstring") cmf::river::OpenWaterStorage::flux_to "real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) + +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; + +%feature("docstring") cmf::river::OpenWaterStorage::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) + +Returns the sum of all flux vectors. "; + +%feature("docstring") cmf::river::OpenWaterStorage::get_abs_errtol "real get_abs_errtol(real rel_errtol) const "; + +%feature("docstring") cmf::river::OpenWaterStorage::get_connections "cmf::water::connection_list get_connections() const "; + +%feature("docstring") cmf::river::OpenWaterStorage::get_depth "real +get_depth() const + +Returns the water table depth. "; + +%feature("docstring") +cmf::river::OpenWaterStorage::get_height_function "virtual const +IVolumeHeightFunction& get_height_function() const + +The functional relation between volume, depth and exposed area. "; + +%feature("docstring") cmf::river::OpenWaterStorage::get_potential "virtual real get_potential() const + +Returns the water potential of the node in m waterhead. + +The base class water storage always returns the height of the location +"; + +%feature("docstring") cmf::river::OpenWaterStorage::get_project "cmf::project& get_project() const + +Returns the project, this node is part of. "; + +%feature("docstring") cmf::river::OpenWaterStorage::get_state "real +get_state() const "; + +%feature("docstring") +cmf::river::OpenWaterStorage::get_state_variable_content "char +get_state_variable_content() const + +A character indicating the integrated variable (either 'V' for Volume +or 'h' for head) "; + +%feature("docstring") cmf::river::OpenWaterStorage::get_states "cmf::math::StateVariableList get_states() + +Add the state variables, owned by an object derived from +StateVariableOwner, to the given vector. "; + +%feature("docstring") cmf::river::OpenWaterStorage::get_volume "virtual real get_volume() const + +Returns the volume of water in this storage in m3 "; + +%feature("docstring") cmf::river::OpenWaterStorage::is_connected "virtual bool is_connected(const cmf::math::StateVariable &other) const + +Returns True if this waterstorage is effected by another state. "; + +%feature("docstring") cmf::river::OpenWaterStorage::is_storage "virtual bool is_storage() const + +Returns true, since this is a storage. "; + +%feature("docstring") cmf::river::OpenWaterStorage::remove_connection +"bool remove_connection(cmf::water::flux_node::ptr To) + +Remove the connection. "; + +%feature("docstring") cmf::river::OpenWaterStorage::set_depth "void +set_depth(real new_depth) "; + +%feature("docstring") +cmf::river::OpenWaterStorage::set_height_function "virtual void +set_height_function(const IVolumeHeightFunction &val) "; + +%feature("docstring") cmf::river::OpenWaterStorage::set_potential "virtual void set_potential(real newpotential) + +Sets the potential of this flux node. "; + +%feature("docstring") cmf::river::OpenWaterStorage::set_state "void +set_state(real newState) "; + +%feature("docstring") +cmf::river::OpenWaterStorage::set_state_variable_content "void +set_state_variable_content(char content) + +A character indicating the integrated variable (either 'V' for Volume +or 'h' for head) "; + +%feature("docstring") cmf::river::OpenWaterStorage::set_volume "virtual void set_volume(real newwatercontent) + +Sets the volume of water in this storage in m3 "; + +%feature("docstring") cmf::river::OpenWaterStorage::Solute "SoluteStorage& Solute(const cmf::water::solute _Solute) + +Returns the water quality of the water storage. "; + +%feature("docstring") cmf::river::OpenWaterStorage::Solute "const +SoluteStorage& Solute(const cmf::water::solute _Solute) const "; + +%feature("docstring") cmf::river::OpenWaterStorage::waterbalance "real waterbalance(cmf::math::Time t, const flux_connection *Without=0) +const + +Returns the sum of all fluxes (positive and negative) at time t. + +Single fluxes can be excluded from the calculation + +Parameters: +----------- + +t: Time of the query + +Without: A flux_connection that is excluded from the waterbalance +(e.g. to prevent closed circuits) "; + +%feature("docstring") cmf::river::OpenWaterStorage::wet_area "real +wet_area() const + +Returns the exposed surface area in m2. "; + + +// File: classcmf__core_1_1_open_water_storage.xml +%feature("docstring") cmf_core::OpenWaterStorage " + +An open water body. The potential is calculated from the stored water +using a water table function C++ includes: OpenWaterStorage.h "; + +%feature("docstring") cmf_core::OpenWaterStorage::__init__ "def +__init__(self, args, kwargs) "; + +%feature("docstring") cmf_core::OpenWaterStorage::__call__ "def +__call__(self, args, kwargs) + +__call__(flux_node self, Time t) -> real "; + +%feature("docstring") cmf_core::OpenWaterStorage::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_node self, flux_node other) -> bool "; + +%feature("docstring") cmf_core::OpenWaterStorage::__getitem__ "def +__getitem__(self, args, kwargs) + +__getitem__(WaterStorage self, solute X) -> SoluteStorage "; + +%feature("docstring") cmf_core::OpenWaterStorage::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::OpenWaterStorage::cast "def +cast(args, kwargs) + +cast(cmf::water::flux_node::ptr node) -> +cmf::river::OpenWaterStorage::ptr "; + +%feature("docstring") cmf_core::OpenWaterStorage::conc "def +conc(self, args, kwargs) + +conc(flux_node self, Time t, solute Solute) -> real virtual real +conc(cmf::math::Time t, const cmf::water::solute &Solute) const +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; + +%feature("docstring") cmf_core::OpenWaterStorage::conc "def +conc(self, args) + +conc(WaterStorage self, solute _Solute) -> real conc(WaterStorage +self, Time t, solute _Solute) -> real conc(WaterStorage self, solute +_Solute, real NewConcetration) void conc(const cmf::water::solute +&_Solute, real NewConcetration) Sets a new concentration. "; + +%feature("docstring") cmf_core::OpenWaterStorage::connected_nodes "def connected_nodes(self) "; + +%feature("docstring") cmf_core::OpenWaterStorage::connection_to "def +connection_to(self, args, kwargs) + +connection_to(flux_node self, flux_node target) -> flux_connection +cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) Returns the connection between this and target. "; + +%feature("docstring") cmf_core::OpenWaterStorage::create "def +create(args, kwargs) + +create(project _project, real initial_state=0.0, real scale=1.0) -> +std::shared_ptr< cmf::water::WaterStorage > "; + +%feature("docstring") cmf_core::OpenWaterStorage::create "def +create(args) + +create(project _project, real Area) -> +cmf::river::OpenWaterStorage::ptr create(project _project, +IVolumeHeightFunction base_geo) -> cmf::river::OpenWaterStorage::ptr +"; + +%feature("docstring") cmf_core::OpenWaterStorage::dxdt "def +dxdt(self, args, kwargs) + +dxdt(StateVariable self, Time time) -> real virtual real dxdt(const +cmf::math::Time &time)=0 Returns the derivate of the state variable +at time time. "; + +%feature("docstring") cmf_core::OpenWaterStorage::flux3d_to "def +flux3d_to(self, args, kwargs) + +flux3d_to(flux_node self, flux_node target, Time t) -> point +cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; + +%feature("docstring") cmf_core::OpenWaterStorage::flux_to "def +flux_to(self, args, kwargs) + +flux_to(flux_node self, flux_node target, Time t) -> real real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; + +%feature("docstring") cmf_core::OpenWaterStorage::fluxes "def +fluxes(self, t) "; + +%feature("docstring") cmf_core::OpenWaterStorage::from_node "def +from_node(args, kwargs) + +from_node(cmf::water::flux_node::ptr node) -> std::shared_ptr< +cmf::water::WaterStorage > "; + +%feature("docstring") cmf_core::OpenWaterStorage::get_3d_flux "def +get_3d_flux(self, args, kwargs) + +get_3d_flux(flux_node self, Time t) -> point cmf::geometry::point +get_3d_flux(cmf::math::Time t) Returns the sum of all flux vectors. +"; + +%feature("docstring") cmf_core::OpenWaterStorage::get_abs_errtol "def get_abs_errtol(self, args, kwargs) + +get_abs_errtol(StateVariable self, real rel_errtol) -> real virtual +real get_abs_errtol(real rel_errtol) const "; + +%feature("docstring") cmf_core::OpenWaterStorage::get_height_function +"def get_height_function(self, args, kwargs) + +get_height_function(OpenWaterStorage self) -> IVolumeHeightFunction +virtual const IVolumeHeightFunction& get_height_function() const The +functional relation between volume, depth and exposed area. "; + +%feature("docstring") cmf_core::OpenWaterStorage::get_states "def +get_states(self, args, kwargs) + +get_states(StateVariableOwner self) -> StateVariableList virtual +StateVariableList get_states()=0 Add the state variables, owned by an +object derived from StateVariableOwner, to the given vector. "; + +%feature("docstring") cmf_core::OpenWaterStorage::is_connected "def +is_connected(self, args, kwargs) + +is_connected(StateVariable self, StateVariable other) -> bool virtual +bool is_connected(const cmf::math::StateVariable &other) const "; + +%feature("docstring") cmf_core::OpenWaterStorage::is_empty "def +is_empty(self, args, kwargs) + +is_empty(flux_node self) -> double virtual double is_empty() const +Returns true if the node has no water. "; + +%feature("docstring") cmf_core::OpenWaterStorage::is_storage "def +is_storage(self, args, kwargs) + +is_storage(flux_node self) -> bool virtual bool is_storage() const +true, if this is a waterstorage "; + +%feature("docstring") cmf_core::OpenWaterStorage::RecalcFluxes "def +RecalcFluxes(self, args, kwargs) + +RecalcFluxes(flux_node self, Time t) -> bool virtual bool +RecalcFluxes(cmf::math::Time t) Pure flux_nodes do not influence +fluxes, therefore no recalculation of fluxes is required by flux_node. +WaterStorage overrides this, since state changes require an update of +the fluxes "; + +%feature("docstring") cmf_core::OpenWaterStorage::remove_connection "def remove_connection(self, args, kwargs) + +remove_connection(flux_node self, cmf::water::flux_node::ptr To) -> +bool bool remove_connection(cmf::water::flux_node::ptr To) Remove +the connection. "; + +%feature("docstring") cmf_core::OpenWaterStorage::set_height_function +"def set_height_function(self, args, kwargs) + +set_height_function(OpenWaterStorage self, IVolumeHeightFunction val) +virtual void set_height_function(const IVolumeHeightFunction &val) "; + +%feature("docstring") cmf_core::OpenWaterStorage::Solute "def +Solute(self, args) + +Solute(WaterStorage self, solute _Solute) -> SoluteStorage +Solute(WaterStorage self, solute _Solute) -> SoluteStorage const +SoluteStorage& Solute(const cmf::water::solute _Solute) const "; + +%feature("docstring") cmf_core::OpenWaterStorage::to_string "def +to_string(self, args, kwargs) + +to_string(StateVariable self) -> std::string virtual std::string +to_string() const =0 "; + +%feature("docstring") cmf_core::OpenWaterStorage::to_string "def +to_string(self, args, kwargs) + +to_string(flux_node self) -> std::string virtual std::string +to_string() const "; + +%feature("docstring") cmf_core::OpenWaterStorage::waterbalance "def +waterbalance(self, args, kwargs) + +waterbalance(flux_node self, Time t, flux_connection Without=None) -> +real real waterbalance(cmf::math::Time t, const flux_connection +*Without=0) const Returns the sum of all fluxes (positive and +negative) at time t. Single fluxes can be excluded from the +calculation Parameters: ----------- t: Time of the query Without: +A flux_connection that is excluded from the waterbalance (e.g. to +prevent closed circuits) "; + +%feature("docstring") cmf_core::OpenWaterStorage::wet_area "def +wet_area(self, args, kwargs) + +wet_area(OpenWaterStorage self) -> real real wet_area() const Returns +the exposed surface area in m2. "; + + +// File: classcmf__core_1_1_penman_evaporation.xml +%feature("docstring") cmf_core::PenmanEvaporation " + +Calculates evaporation from an open water body. C++ includes: ET.h "; + +%feature("docstring") cmf_core::PenmanEvaporation::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::ET::PenmanEvaporation self, +cmf::river::OpenWaterStorage::ptr source, cmf::water::flux_node::ptr +Evap_target, Meteorology meteo) -> PenmanEvaporation +PenmanEvaporation(cmf::river::OpenWaterStorage::ptr source, +cmf::water::flux_node::ptr Evap_target, const +cmf::atmosphere::Meteorology &meteo) "; + +%feature("docstring") cmf_core::PenmanEvaporation::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::PenmanEvaporation::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::PenmanEvaporation::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::PenmanEvaporation::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::PenmanEvaporation::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::PenmanEvaporation::conc "def +conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") cmf_core::PenmanEvaporation::exchange_target "def exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::PenmanEvaporation::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::PenmanEvaporation::get_tracer_filter +"def get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::PenmanEvaporation::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::PenmanEvaporation::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::PenmanEvaporation::q "def q(self, +args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::PenmanEvaporation::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::PenmanEvaporation::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::PenmanEvaporation::set_tracer_filter +"def set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::PenmanEvaporation::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::PenmanEvaporation::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf_1_1upslope_1_1_e_t_1_1_penman_evaporation.xml +%feature("docstring") cmf::upslope::ET::PenmanEvaporation " + +Calculates evaporation from an open water body. + +C++ includes: ET.h "; + +%feature("docstring") +cmf::upslope::ET::PenmanEvaporation::PenmanEvaporation "PenmanEvaporation(cmf::river::OpenWaterStorage::ptr source, +cmf::water::flux_node::ptr Evap_target, const +cmf::atmosphere::Meteorology &meteo) "; + +%feature("docstring") cmf::upslope::ET::PenmanEvaporation::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") +cmf::upslope::ET::PenmanEvaporation::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf::upslope::ET::PenmanEvaporation::get_ptr "ptr get_ptr() const "; + +%feature("docstring") cmf::upslope::ET::PenmanEvaporation::get_target +"flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") cmf::upslope::ET::PenmanEvaporation::get_target +"flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") +cmf::upslope::ET::PenmanEvaporation::get_tracer_filter "real +get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::ET::PenmanEvaporation::get_tracer_filter "real +get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") cmf::upslope::ET::PenmanEvaporation::kill_me "bool kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") cmf::upslope::ET::PenmanEvaporation::left_node +"flux_node::ptr left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") cmf::upslope::ET::PenmanEvaporation::q "real +q(const flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") cmf::upslope::ET::PenmanEvaporation::refresh "void refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") cmf::upslope::ET::PenmanEvaporation::right_node +"flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") +cmf::upslope::ET::PenmanEvaporation::set_tracer_filter "void +set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::ET::PenmanEvaporation::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf::upslope::ET::PenmanEvaporation::short_string "virtual +std::string short_string() const "; + +%feature("docstring") cmf::upslope::ET::PenmanEvaporation::to_string +"virtual std::string to_string() const "; + + +// File: classcmf__core_1_1_penman_monteith_e_t.xml +%feature("docstring") cmf_core::PenmanMonteithET " + +Calculates the potential evapotranspiration according to FAO(1998) +Governing equations: .. math:: \\\\\\\\lambda ET &=& +\\\\\\\\frac{\\\\\\\\Delta\\\\\\\\left(R_n - +G\\\\\\\\right)+\\\\\\\\rho_a c_p \\\\\\\\frac{e_s - +e_a}{r_a}}{\\\\\\\\Delta + +\\\\\\\\gamma\\\\\\\\left(1+\\\\\\\\frac{r_s}{r_a}\\\\\\\\right)} +\\\\\\\\mbox{ FAO 1998, Eq. 3} \\\\\\\\\\\\\\\\ +\\\\\\\\mbox{With:} \\\\\\\\\\\\\\\\ \\\\\\\\Delta &=& 4098 +\\\\\\\\frac{0.6108 e^{17.27 T}}{(T+237.3)^2} +\\\\\\\\frac{kPa}{^\\\\\\\\circ C} \\\\\\\\mbox{ (FAO 1998, Eq. +13)} \\\\\\\\\\\\\\\\ T &=& \\\\\\\\mbox{Actual Temperature in } +^\\\\\\\\circ C \\\\\\\\\\\\\\\\ R_n &=& \\\\\\\\mbox{net Radiation +(see Atmosphere) in } \\\\\\\\frac{MJ}{m^2day} \\\\\\\\\\\\\\\\ G &=& +0 \\\\\\\\ \\\\\\\\frac{MJ}{m^2day} \\\\\\\\mbox{ if daily average +(FAO 1998, Eq. 42)} \\\\\\\\\\\\\\\\ && 0.1 R_n \\\\\\\\ +\\\\\\\\mbox{ if day time (FAO 1998, Eq. 45)} \\\\\\\\\\\\\\\\ && +0.5 R_n \\\\\\\\ \\\\\\\\mbox{ if night time (FAO 1998, Eq. 46)} +\\\\\\\\\\\\\\\\ \\\\\\\\gamma &=& \\\\\\\\frac{c_p P}{\\\\\\\\epsilon +\\\\\\\\lambda} \\\\\\\\mbox{ (FAO 1998,Eq. 8): Psychrometric +constant } \\\\\\\\frac{kPa}{^\\\\\\\\circ C} \\\\\\\\\\\\\\\\ c_p +&=& 0.001013 \\\\\\\\frac{MJ}{kg\\\\\\\\ ^\\\\\\\\circ +C}\\\\\\\\mbox{ specific heat at constant pressure } +\\\\\\\\\\\\\\\\ P &=& 101.3 +\\\\\\\\left(\\\\\\\\frac{293-0.0065z}{293}\\\\\\\\right)^{5.26} +\\\\\\\\mbox{ (FAO 1998,Eq. 7)} \\\\\\\\\\\\\\\\ \\\\\\\\epsilon +&=& 0.622 \\\\\\\\frac{mol/g \\\\\\\\mbox{ vapor}}{mol/g +\\\\\\\\mbox{ liquid water}} \\\\\\\\\\\\\\\\ \\\\\\\\lambda &=& 2.45 +\\\\\\\\frac{MJ}{kg} \\\\\\\\mbox{ (FAO 1998,Eq. 8)} \\\\\\\\\\\\\\\\ +R &=& 0.287 \\\\\\\\frac{kJ}{kg\\\\\\\\ k}\\\\\\\\mbox{ Spec. gas +const.} \\\\\\\\\\\\\\\\ \\\\\\\\rho_a &=& +\\\\\\\\frac{P}{1.01(T+273)R} \\\\\\\\mbox{ (FAO 1998,Box. 6)} +\\\\\\\\\\\\\\\\ e_s &=& \\\\\\\\mbox{ Sat. vapor press. } [kPa] +\\\\\\\\\\\\\\\\ e_a &=& \\\\\\\\mbox{ Act. vapor press. } [kPa] +\\\\\\\\\\\\\\\\ r_a &=& +\\\\\\\\frac{\\\\\\\\ln\\\\\\\\left(\\\\\\\\frac{2-d}{z_{om}}\\\\\\\\right)\\\\\\\\ln\\\\\\\\left(\\\\\\\\frac{2-d}{z_{oh}}\\\\\\\\right)}{k^2 +u_2} \\\\\\\\mbox{ (FAO 1998, Eq. 4/Box 4} \\\\\\\\frac s m +\\\\\\\\\\\\\\\\ && d=\\\\\\\\frac 2 3 h,z_{om}=0.123 h,z_{oh}=0.1 +z_{om}, k=0.41 \\\\\\\\\\\\\\\\ h &=& \\\\\\\\mbox{ Vegetation +height in }m \\\\\\\\\\\\\\\\ u_2 &=& \\\\\\\\mbox{ Windspeed in +2m above canopy } \\\\\\\\frac m s \\\\\\\\\\\\\\\\ r_s &=& +\\\\\\\\frac{r_l}{LAI_{Active}} \\\\\\\\mbox{ (FAO 1998, Eq. 5/Box 5)} +\\\\\\\\frac s m \\\\\\\\\\\\\\\\ && r_l=100 \\\\\\\\frac s m, +LAI_{Active}=0.5 LAI C++ includes: ET.h "; + +%feature("docstring") cmf_core::PenmanMonteithET::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::ET::PenmanMonteithET self, +cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr +ET_target) -> PenmanMonteithET +PenmanMonteithET(cmf::upslope::SoilLayer::ptr source, +cmf::water::flux_node::ptr ET_target) "; + +%feature("docstring") cmf_core::PenmanMonteithET::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::PenmanMonteithET::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::PenmanMonteithET::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::PenmanMonteithET::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::PenmanMonteithET::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::PenmanMonteithET::conc "def +conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") cmf_core::PenmanMonteithET::ETpot "def +ETpot(self, args, kwargs) + +ETpot(stressedET self, Time t) -> real virtual real +ETpot(cmf::math::Time t) const "; + +%feature("docstring") cmf_core::PenmanMonteithET::exchange_target "def exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::PenmanMonteithET::get_layer "def +get_layer(self, args, kwargs) + +get_layer(stressedET self) -> cmf::upslope::SoilLayer::ptr +SoilLayer::ptr get_layer() const "; + +%feature("docstring") cmf_core::PenmanMonteithET::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::PenmanMonteithET::get_tracer_filter "def get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::PenmanMonteithET::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::PenmanMonteithET::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::PenmanMonteithET::q "def q(self, +args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::PenmanMonteithET::r_a "def r_a(args, +kwargs) + +r_a(Weather A, real veg_height) -> real "; + +%feature("docstring") cmf_core::PenmanMonteithET::r_s "def r_s(args, +kwargs) + +r_s(Vegetation veg) -> real "; + +%feature("docstring") cmf_core::PenmanMonteithET::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::PenmanMonteithET::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::PenmanMonteithET::set_stressfunction +"def set_stressfunction(self, args, kwargs) + +set_stressfunction(stressedET self, RootUptakeStessFunction +stressfunction) void set_stressfunction(const RootUptakeStessFunction +&stressfunction) Sets the stress function to limit water uptake. "; + +%feature("docstring") cmf_core::PenmanMonteithET::set_tracer_filter "def set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::PenmanMonteithET::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::PenmanMonteithET::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + +%feature("docstring") cmf_core::PenmanMonteithET::use_for_cell "def +use_for_cell(args, kwargs) + +use_for_cell(Cell cell) "; + + +// File: classcmf_1_1upslope_1_1_e_t_1_1_penman_monteith_e_t.xml +%feature("docstring") cmf::upslope::ET::PenmanMonteithET " + +Calculates the potential evapotranspiration according to FAO(1998) + +Governing equations: + +.. math:: + + \\\\lambda ET &=& + \\\\frac{\\\\Delta\\\\left(R_n - G\\\\right)+\\\\rho_a c_p + \\\\frac{e_s - e_a}{r_a}}{\\\\Delta + + \\\\gamma\\\\left(1+\\\\frac{r_s}{r_a}\\\\right)} \\\\mbox{ FAO 1998, + Eq. 3} \\\\\\\\ \\\\mbox{With:} \\\\\\\\ \\\\Delta &=& 4098 + \\\\frac{0.6108 e^{17.27 T}}{(T+237.3)^2} \\\\frac{kPa}{^\\\\circ C} + \\\\mbox{ (FAO 1998, Eq. 13)} \\\\\\\\ T &=& \\\\mbox{Actual + Temperature in } ^\\\\circ C \\\\\\\\ R_n &=& \\\\mbox{net Radiation + (see Atmosphere) in } \\\\frac{MJ}{m^2day} \\\\\\\\ G &=& 0 \\\\ + \\\\frac{MJ}{m^2day} \\\\mbox{ if daily average (FAO 1998, Eq. 42)} + \\\\\\\\ && 0.1 R_n \\\\ \\\\mbox{ if day time (FAO 1998, Eq. 45)} + \\\\\\\\ && 0.5 R_n \\\\ \\\\mbox{ if night time (FAO 1998, Eq. 46)} + \\\\\\\\ \\\\gamma &=& \\\\frac{c_p P}{\\\\epsilon \\\\lambda} + \\\\mbox{ (FAO 1998,Eq. 8): Psychrometric constant } + \\\\frac{kPa}{^\\\\circ C} \\\\\\\\ c_p &=& 0.001013 + \\\\frac{MJ}{kg\\\\ ^\\\\circ C}\\\\mbox{ specific heat at constant + pressure } \\\\\\\\ P &=& 101.3 + \\\\left(\\\\frac{293-0.0065z}{293}\\\\right)^{5.26} \\\\mbox{ (FAO + 1998,Eq. 7)} \\\\\\\\ \\\\epsilon &=& 0.622 \\\\frac{mol/g \\\\mbox{ + vapor}}{mol/g \\\\mbox{ liquid water}} \\\\\\\\ \\\\lambda &=& 2.45 + \\\\frac{MJ}{kg} \\\\mbox{ (FAO 1998,Eq. 8)} \\\\\\\\ R &=& 0.287 + \\\\frac{kJ}{kg\\\\ k}\\\\mbox{ Spec. gas const.} \\\\\\\\ \\\\rho_a + &=& \\\\frac{P}{1.01(T+273)R} \\\\mbox{ (FAO 1998,Box. 6)} \\\\\\\\ + e_s &=& \\\\mbox{ Sat. vapor press. } [kPa] \\\\\\\\ e_a &=& \\\\mbox{ + Act. vapor press. } [kPa] \\\\\\\\ r_a &=& + \\\\frac{\\\\ln\\\\left(\\\\frac{2-d}{z_{om}}\\\\right)\\\\ln\\\\left(\\\\frac{2-d}{z_{oh}}\\\\right)}{k^2 + u_2} \\\\mbox{ (FAO 1998, Eq. 4/Box 4} \\\\frac s m \\\\\\\\ && + d=\\\\frac 2 3 h,z_{om}=0.123 h,z_{oh}=0.1 z_{om}, k=0.41 \\\\\\\\ h + &=& \\\\mbox{ Vegetation height in }m \\\\\\\\ u_2 &=& \\\\mbox{ + Windspeed in 2m above canopy } \\\\frac m s \\\\\\\\ r_s &=& + \\\\frac{r_l}{LAI_{Active}} \\\\mbox{ (FAO 1998, Eq. 5/Box 5)} + \\\\frac s m \\\\\\\\ && r_l=100 \\\\frac s m, LAI_{Active}=0.5 LAI + + + + +C++ includes: ET.h "; + +%feature("docstring") +cmf::upslope::ET::PenmanMonteithET::PenmanMonteithET "PenmanMonteithET(cmf::upslope::SoilLayer::ptr source, +cmf::water::flux_node::ptr ET_target) "; + +%feature("docstring") cmf::upslope::ET::PenmanMonteithET::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") cmf::upslope::ET::PenmanMonteithET::ETpot "virtual real ETpot(cmf::math::Time t) const "; + +%feature("docstring") +cmf::upslope::ET::PenmanMonteithET::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf::upslope::ET::PenmanMonteithET::get_layer "SoilLayer::ptr get_layer() const "; + +%feature("docstring") cmf::upslope::ET::PenmanMonteithET::get_ptr "ptr get_ptr() const "; + +%feature("docstring") cmf::upslope::ET::PenmanMonteithET::get_target +"flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") cmf::upslope::ET::PenmanMonteithET::get_target +"flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") +cmf::upslope::ET::PenmanMonteithET::get_tracer_filter "real +get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::ET::PenmanMonteithET::get_tracer_filter "real +get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") cmf::upslope::ET::PenmanMonteithET::kill_me "bool kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") cmf::upslope::ET::PenmanMonteithET::left_node "flux_node::ptr left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") cmf::upslope::ET::PenmanMonteithET::q "real +q(const flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") cmf::upslope::ET::PenmanMonteithET::refresh "void refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") cmf::upslope::ET::PenmanMonteithET::right_node +"flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") +cmf::upslope::ET::PenmanMonteithET::set_stressfunction "void +set_stressfunction(const RootUptakeStessFunction &stressfunction) + +Sets the stress function to limit water uptake. "; + +%feature("docstring") +cmf::upslope::ET::PenmanMonteithET::set_tracer_filter "void +set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::ET::PenmanMonteithET::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf::upslope::ET::PenmanMonteithET::short_string "virtual std::string +short_string() const "; + +%feature("docstring") cmf::upslope::ET::PenmanMonteithET::to_string "std::string to_string() const "; + + +// File: classcmf_1_1river_1_1_pipe_reach.xml +%feature("docstring") cmf::river::PipeReach " + +Describes the geometry of a closed pipe. + +C++ includes: ReachType.h "; + +%feature("docstring") cmf::river::PipeReach::PipeReach "PipeReach(double l, double diameter) + +Creates a tube IChannel with diameter [m]. "; + +%feature("docstring") cmf::river::PipeReach::PipeReach "PipeReach(const PipeReach ©) "; + +%feature("docstring") cmf::river::PipeReach::~PipeReach "virtual +~PipeReach() "; + +%feature("docstring") cmf::river::PipeReach::A "virtual double +A(double V) const + +Returns the area of the surface for a given volume. "; + +%feature("docstring") cmf::river::PipeReach::copy "PipeReach* copy() +const "; + +%feature("docstring") cmf::river::PipeReach::get_channel_width "virtual double get_channel_width(double depth) const + + + +.. math:: + + w=2\\\\sqrt{\\\\left|r^2-(r-d)^2\\\\right|} + +"; + +%feature("docstring") cmf::river::PipeReach::get_depth "virtual +double get_depth(double area) const + + + +.. math:: + + d=r\\\\left(1-\\\\cos{\\\\frac{A}{r^2}}\\\\right) + +"; + +%feature("docstring") cmf::river::PipeReach::get_flux_crossection "virtual double get_flux_crossection(double depth) const + + + +.. math:: + + A=r^2\\\\arccos{\\\\frac{r-d}{r}{r}} + +"; + +%feature("docstring") cmf::river::PipeReach::get_length "double +get_length() const + +Length of the reach. "; + +%feature("docstring") cmf::river::PipeReach::get_nManning "virtual +double get_nManning() const "; + +%feature("docstring") cmf::river::PipeReach::get_wetted_perimeter "virtual double get_wetted_perimeter(double depth) const + + + +.. math:: + + P=r\\\\arccos{\\\\frac{r-d}{r}} + +"; + +%feature("docstring") cmf::river::PipeReach::h "virtual double +h(double V) const + +Returns the depth of a given volume. "; + +%feature("docstring") cmf::river::PipeReach::q "virtual double +q(double h, double slope) const "; + +%feature("docstring") cmf::river::PipeReach::qManning "virtual +double qManning(double A, double slope) const + +Calculates the flow rate from a given water volume in the reach + + +.. math:: + + q_{Manning}&=& A R^{\\\\frac 2 3} + \\\\sqrt{\\\\frac {\\\\Delta_z} n} \\\\\\\\ A &=& \\\\frac V l + \\\\mbox{, (Crosssectional area of the wetted crossection, Volume per + length)} \\\\\\\\ R &=& \\\\frac A {P(d)} \\\\\\\\ P(d) &=& \\\\mbox{ + the perimeter of the wetted crosssection, a function of reach depth} + \\\\\\\\ d(V) &=& \\\\mbox{ the depth of the reach a function of the + volume} \\\\\\\\ \\\\Delta_z &=& \\\\frac{z_{max} - z_{min}}{l} + \\\\mbox{ Slope of the reach} + +. + +Flow rate [m3/s] + +Parameters: +----------- + +A: The area of the cross section [m2] + +slope: The slope of the reach [m/m] "; + +%feature("docstring") cmf::river::PipeReach::set_nManning "virtual +void set_nManning(double nManning) "; + +%feature("docstring") cmf::river::PipeReach::typecode "char +typecode() const "; + +%feature("docstring") cmf::river::PipeReach::V "virtual double +V(double h) const "; + + +// File: classcmf__core_1_1_pipe_reach.xml +%feature("docstring") cmf_core::PipeReach " + +Describes the geometry of a closed pipe. C++ includes: ReachType.h "; + +%feature("docstring") cmf_core::PipeReach::__init__ "def +__init__(self, args) + +__init__(cmf::river::PipeReach self, double l, double diameter) -> +PipeReach __init__(cmf::river::PipeReach self, PipeReach copy) -> +PipeReach PipeReach(const PipeReach ©) "; + +%feature("docstring") cmf_core::PipeReach::A "def A(self, args, +kwargs) + +A(IVolumeHeightFunction self, double V) -> double virtual double +A(double V) const =0 Returns the area of the surface for a given +volume. "; + +%feature("docstring") cmf_core::PipeReach::copy "def copy(self, +args, kwargs) + +copy(PipeReach self) -> PipeReach PipeReach* copy() const "; + +%feature("docstring") cmf_core::PipeReach::get_channel_width "def +get_channel_width(self, args, kwargs) + +get_channel_width(IChannel self, double depth) -> double virtual +double get_channel_width(double depth) const =0 Calculates the flow +width from a given actual depth [m] using the actual IChannel +geometry. "; + +%feature("docstring") cmf_core::PipeReach::get_depth "def +get_depth(self, args, kwargs) + +get_depth(IChannel self, double area) -> double virtual double +get_depth(double area) const =0 Calculates the actual depth of the +reach using the IChannel geometry. get_depth of the reach [m] +Parameters: ----------- area: Wetted area of a river cross section +[m2], can be obtained by V/l, where V is the stored volume and l is +the reach length "; + +%feature("docstring") cmf_core::PipeReach::get_flux_crossection "def +get_flux_crossection(self, args, kwargs) + +get_flux_crossection(IChannel self, double depth) -> double virtual +double get_flux_crossection(double depth) const =0 Calculates the +wetted area from a given depth using the IChannel geometry. In most +cases use get_flux_crossection=V/l, where V is the stored volume and l +is the reach length Wetted area of a river cross section [m2] +Parameters: ----------- depth: depth of the reach [m] "; + +%feature("docstring") cmf_core::PipeReach::get_length "def +get_length(self, args, kwargs) + +get_length(IChannel self) -> double virtual double get_length() const +=0 Length of the reach. "; + +%feature("docstring") cmf_core::PipeReach::get_nManning "def +get_nManning(self, args, kwargs) + +get_nManning(IChannel self) -> double virtual double get_nManning() +const =0 "; + +%feature("docstring") cmf_core::PipeReach::get_wetted_perimeter "def +get_wetted_perimeter(self, args, kwargs) + +get_wetted_perimeter(IChannel self, double depth) -> double virtual +double get_wetted_perimeter(double depth) const =0 Calculates the +wetted perimeter from a given actual depth [m] using the actual +IChannel geometry. "; + +%feature("docstring") cmf_core::PipeReach::h "def h(self, args, +kwargs) + +h(IVolumeHeightFunction self, double V) -> double virtual double +h(double V) const =0 Returns the depth of a given volume. "; + +%feature("docstring") cmf_core::PipeReach::q "def q(self, args, +kwargs) + +q(IVolumeHeightFunction self, double h, double slope) -> double +virtual double q(double h, double slope) const "; + +%feature("docstring") cmf_core::PipeReach::qManning "def +qManning(self, args, kwargs) + +qManning(IChannel self, double A, double slope) -> double virtual +double qManning(double A, double slope) const Calculates the flow +rate from a given water volume in the reach .. math:: q_{Manning}&=& +A R^{\\\\\\\\frac 2 3} \\\\\\\\sqrt{\\\\\\\\frac {\\\\\\\\Delta_z} +n} \\\\\\\\\\\\\\\\ A &=& \\\\\\\\frac V l \\\\\\\\mbox{, +(Crosssectional area of the wetted crossection, Volume per +length)} \\\\\\\\\\\\\\\\ R &=& \\\\\\\\frac A {P(d)} \\\\\\\\\\\\\\\\ +P(d) &=& \\\\\\\\mbox{ the perimeter of the wetted crosssection, a +function of reach depth} \\\\\\\\\\\\\\\\ d(V) &=& \\\\\\\\mbox{ +the depth of the reach a function of the volume} \\\\\\\\\\\\\\\\ +\\\\\\\\Delta_z &=& \\\\\\\\frac{z_{max} - z_{min}}{l} +\\\\\\\\mbox{ Slope of the reach} . Flow rate [m3/s] Parameters: +----------- A: The area of the cross section [m2] slope: The slope +of the reach [m/m] "; + +%feature("docstring") cmf_core::PipeReach::set_nManning "def +set_nManning(self, args, kwargs) + +set_nManning(IChannel self, double val) virtual void +set_nManning(double val)=0 "; + +%feature("docstring") cmf_core::PipeReach::typecode "def +typecode(self, args, kwargs) + +typecode(IChannel self) -> char virtual char typecode() const =0 "; + +%feature("docstring") cmf_core::PipeReach::V "def V(self, args, +kwargs) + +V(IVolumeHeightFunction self, double h) -> double virtual double +V(double h) const =0 "; + + +// File: classcmf__core_1_1point.xml +%feature("docstring") cmf_core::point " + +2D-Point Class. Used as location property anywhere in the text +Calculation of distances +,-,-=,*= Operators overloaded C++ +includes: geometry.h "; + +%feature("docstring") cmf_core::point::__init__ "def __init__(self, +args) + +__init__(cmf::geometry::point self) -> point +__init__(cmf::geometry::point self, point p) -> point +__init__(cmf::geometry::point self, double x_, double y_, double +z_=0.0) -> point point(double x_, double y_, double z_=0.0) Creates +a point from two doubles. "; + +%feature("docstring") cmf_core::point::__add__ "def __add__(self, +args, kwargs) + +__add__(point self, point p) -> point "; + +%feature("docstring") cmf_core::point::__eq__ "def __eq__(self, +args, kwargs) + +__eq__(point self, point p) -> bool "; + +%feature("docstring") cmf_core::point::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::point::__iadd__ "def __iadd__(self, +args, kwargs) + +__iadd__(point self, point left) -> point "; + +%feature("docstring") cmf_core::point::__imul__ "def __imul__(self, +args) + +__imul__(point self, double left) -> point __imul__(point self, point +left) -> point "; + +%feature("docstring") cmf_core::point::__isub__ "def __isub__(self, +args, kwargs) + +__isub__(point self, point left) -> point "; + +%feature("docstring") cmf_core::point::__iter__ "def __iter__(self) +"; + +%feature("docstring") cmf_core::point::__itruediv__ "def +__itruediv__(self, args) "; + +%feature("docstring") cmf_core::point::__len__ "def __len__(self, +args, kwargs) + +__len__(point self) -> int "; + +%feature("docstring") cmf_core::point::__mul__ "def __mul__(self, +args) + +__mul__(point self, double left) -> point __mul__(point self, point p) +-> point "; + +%feature("docstring") cmf_core::point::__ne__ "def __ne__(self, +args, kwargs) + +__ne__(point self, point p) -> bool "; + +%feature("docstring") cmf_core::point::__rdiv__ "def __rdiv__(self, +args, kwargs) + +__rdiv__(point self, double val) -> point "; + +%feature("docstring") cmf_core::point::__repr__ "def __repr__(self) +"; + +%feature("docstring") cmf_core::point::__rmul__ "def __rmul__(self, +args, kwargs) + +__rmul__(point self, double val) -> point "; + +%feature("docstring") cmf_core::point::__setitem__ "def +__setitem__(self, index, value) "; + +%feature("docstring") cmf_core::point::__sub__ "def __sub__(self, +args, kwargs) + +__sub__(point self, point p) -> point "; + +%feature("docstring") cmf_core::point::__truediv__ "def +__truediv__(self, args) "; + +%feature("docstring") cmf_core::point::angleToXAxis "def +angleToXAxis(self, args, kwargs) + +angleToXAxis(point self, point p) -> double double angleToXAxis(point +p) const Returns the angle between the line +:math:`\\\\\\\\overline{this,p}` to the x-Axis in degrees. "; + +%feature("docstring") cmf_core::point::azimuth "def azimuth(self, +args, kwargs) + +azimuth(point self, point p) -> double double azimuth(point p) const +Returns the azimuth angle of the line :math:`\\\\\\\\overline{this,p}` +to the Azimuth in degrees. "; + +%feature("docstring") cmf_core::point::distance "def distance(args, +kwargs) + +distance(point p1, point p2) -> double "; + +%feature("docstring") cmf_core::point::distance3DTo "def +distance3DTo(self, args, kwargs) + +distance3DTo(point self, point p) -> double double distance3DTo(point +p) const Returns the euclidian distance in space to another point p. +"; + +%feature("docstring") cmf_core::point::distance_max "def +distance_max(self, args, kwargs) + +distance_max(point self, point p) -> double double distance_max(point +p) const Returns the distance by the maximum orthogonal offset. "; + +%feature("docstring") cmf_core::point::distanceTo "def +distanceTo(self, args, kwargs) + +distanceTo(point self, point p) -> double double distanceTo(point p) +const Returns the horizontal euclidian distance to another point p. +:math:`\\\\\\\\sqrt{(this.x-p.x)^2+(this.y-p.y)^2}` "; + +%feature("docstring") cmf_core::point::length "def length(self, +args, kwargs) + +length(point self) -> double double length() const "; + +%feature("docstring") cmf_core::point::sum "def sum(self, args, +kwargs) + +sum(point self) -> double double sum() const Returns x+y+z. "; + +%feature("docstring") cmf_core::point::z_weight_distance "def +z_weight_distance(self, args, kwargs) + +z_weight_distance(point self, point p, double z_weight) -> double +double z_weight_distance(point p, double z_weight) const Returns the +horizontal euclidian distance plus the absolute of the height +difference times a factor. +:math:`\\\\\\\\sqrt{(this.x-p.x)^2+(this.y-p.y)^2}\\\\\\\\ +\\\\\\\\ +w_{z}|this.z-p.z|` "; + + +// File: classcmf_1_1geometry_1_1point.xml +%feature("docstring") cmf::geometry::point " + +2D-Point Class. + +Used as location property anywhere in the text Calculation of +distances + ++,-,-=,*= Operators overloaded + +C++ includes: geometry.h "; + +%feature("docstring") cmf::geometry::point::point "point() + +Empty Constructor. Creates an (0 0) location. "; + +%feature("docstring") cmf::geometry::point::point "point(const point +&p) + +Copy Constructor. "; + +%feature("docstring") cmf::geometry::point::point "point(double x_, +double y_, double z_=0.0) + +Creates a point from two doubles. "; + +%feature("docstring") cmf::geometry::point::angleToXAxis "double +angleToXAxis(point p) const + +Returns the angle between the line :math:`\\\\overline{this,p}` to the +x-Axis in degrees. "; + +%feature("docstring") cmf::geometry::point::azimuth "double +azimuth(point p) const + +Returns the azimuth angle of the line :math:`\\\\overline{this,p}` to the +Azimuth in degrees. "; + +%feature("docstring") cmf::geometry::point::distance3DTo "double +distance3DTo(point p) const + +Returns the euclidian distance in space to another point p. "; + +%feature("docstring") cmf::geometry::point::distance_max "double +distance_max(point p) const + +Returns the distance by the maximum orthogonal offset. "; + +%feature("docstring") cmf::geometry::point::distanceTo "double +distanceTo(point p) const + +Returns the horizontal euclidian distance to another point p. + +:math:`\\\\sqrt{(this.x-p.x)^2+(this.y-p.y)^2}` "; + +%feature("docstring") cmf::geometry::point::length "double length() +const "; + +%feature("docstring") cmf::geometry::point::sum "double sum() const + +Returns x+y+z. "; + +%feature("docstring") cmf::geometry::point::z_weight_distance "double z_weight_distance(point p, double z_weight) const + +Returns the horizontal euclidian distance plus the absolute of the +height difference times a factor. + +:math:`\\\\sqrt{(this.x-p.x)^2+(this.y-p.y)^2}\\\\ +\\\\ w_{z}|this.z-p.z|` +"; + + +// File: classcmf__core_1_1point__vector.xml +%feature("docstring") cmf_core::point_vector " + +Holds three arrays x,y and z for fast access of point coordinates. C++ +includes: geometry.h "; + +%feature("docstring") cmf_core::point_vector::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::geometry::point_vector self, ptrdiff_t size) -> +point_vector point_vector(ptrdiff_t size) Create a point vector of a +specific size. "; + +%feature("docstring") cmf_core::point_vector::get "def get(self, +args, kwargs) + +get(point_vector self, ptrdiff_t index) -> point point get(ptrdiff_t +index) const Return a point at index. "; + +%feature("docstring") cmf_core::point_vector::set "def set(self, +args, kwargs) + +set(point_vector self, ptrdiff_t index, point p) void set(ptrdiff_t +index, cmf::geometry::point p) Change the point at index. "; + +%feature("docstring") cmf_core::point_vector::size "def size(self, +args, kwargs) + +size(point_vector self) -> size_t size_t size() const Return the +number of points in the point_vector. "; + + +// File: classcmf_1_1geometry_1_1point__vector.xml +%feature("docstring") cmf::geometry::point_vector " + +Holds three arrays x,y and z for fast access of point coordinates. + +C++ includes: geometry.h "; + +%feature("docstring") cmf::geometry::point_vector::point_vector "point_vector(ptrdiff_t size) + +Create a point vector of a specific size. "; + +%feature("docstring") cmf::geometry::point_vector::get "point +get(ptrdiff_t index) const + +Return a point at index. "; + +%feature("docstring") cmf::geometry::point_vector::set "void +set(ptrdiff_t index, cmf::geometry::point p) + +Change the point at index. "; + +%feature("docstring") cmf::geometry::point_vector::size "size_t +size() const + +Return the number of points in the point_vector. "; + + +// File: classcmf_1_1maps_1_1_polygon_map.xml +%feature("docstring") cmf::maps::PolygonMap " + +A map of polygons. Each object is referenced with a shapely polygon. +Returns the object of the first polygon, within the query position +lays. "; + +%feature("docstring") cmf::maps::PolygonMap::__init__ "def +__init__(self, quad_tree_raster_size=20) "; + +%feature("docstring") cmf::maps::PolygonMap::__call__ "def +__call__(self, x, y, z=0) "; + +%feature("docstring") cmf::maps::PolygonMap::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf::maps::PolygonMap::__nonzero__ "def +__nonzero__(self) "; + +%feature("docstring") cmf::maps::PolygonMap::append "def +append(self, polygon, object) "; + +%feature("docstring") cmf::maps::PolygonMap::remove "def +remove(self, polygon) "; + +%feature("docstring") cmf::maps::PolygonMap::values "def +values(self) "; + + +// File: classcmf__core_1_1_power_law_connection.xml +%feature("docstring") cmf_core::PowerLawConnection " + +Calculates flux out of a storage as a linear function of its volume to +a power. This connection serves the same purpose as the old +kinematic_wave connection, but the parameters are easier to explain. +.. math:: q = Q_0 {\\\\\\\\left(\\\\\\\\frac{V - +V_{residual}}{V_0} \\\\\\\\right)^\\\\\\\\beta} where: :math:`V` +The actual volume of water stored in source :math:`V_{residual} [m^3]` +The volume of water not flowing out (default = 0) :math:`V_0` A +reference volume to scale the outflux. One can see :math:`V_0` as the +inflection point of the outflow curve :math:`\\\\\\\\beta` A parameter +to shape the response curve. :math:`Q_0` is the outflow from the +source in :math:`\\\\\\\\frac{m^3}{day}`, when :math:`V = V_0`. +WARNING: :math:`\\\\\\\\beta < 0.5` may lead to numerical troubles and +have a dubious hydrological meaning. Please avoid. C++ includes: +simple_connections.h "; + +%feature("docstring") cmf_core::PowerLawConnection::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::water::PowerLawConnection self, +cmf::water::WaterStorage::ptr source, cmf::water::flux_node::ptr +target, real Q0, real V0, real beta=1.0, real residual=0.0) -> +PowerLawConnection PowerLawConnection(WaterStorage::ptr source, +flux_node::ptr target, real Q0, real V0, real beta=1.0, real +residual=0.0) Creates a power law connection. Parameters: +----------- source: Water storage from which the water flows out. +Flux is a function of source.volume target: Target node (boundary +condition or storage). Does not influence the strength of the flow Q0: +Reference flow :math:`Q_0 = q(V_0)` Outflow when the source storage +equals the reference volume V0: Reference volume :math:`V_0` The +reference volume to scale the exponent beta: :math:`\\\\\\\\beta [-]` +An empirical exponent to shape the flux function (default = 1 (linear +function)) residual: :math:`V_{residual} [m^3]` The volume of water +not flowing out (default = 0) "; + +%feature("docstring") cmf_core::PowerLawConnection::__contains__ "def __contains__(self, cmp) "; + +%feature("docstring") cmf_core::PowerLawConnection::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::PowerLawConnection::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::PowerLawConnection::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::PowerLawConnection::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::PowerLawConnection::conc "def +conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") cmf_core::PowerLawConnection::exchange_target "def exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::PowerLawConnection::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::PowerLawConnection::get_tracer_filter +"def get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::PowerLawConnection::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::PowerLawConnection::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::PowerLawConnection::q "def q(self, +args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::PowerLawConnection::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::PowerLawConnection::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::PowerLawConnection::set_tracer_filter +"def set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::PowerLawConnection::short_string "def short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::PowerLawConnection::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf_1_1water_1_1_power_law_connection.xml +%feature("docstring") cmf::water::PowerLawConnection " + +Calculates flux out of a storage as a linear function of its volume to +a power. + +This connection serves the same purpose as the old kinematic_wave +connection, but the parameters are easier to explain. + + + +.. math:: + + q = Q_0 {\\\\left(\\\\frac{V - V_{residual}}{V_0} + \\\\right)^\\\\beta} + +where: :math:`V` The actual volume of water +stored in source + +:math:`V_{residual} [m^3]` The volume of water not flowing out (default = 0) + +:math:`V_0` A reference volume to scale the outflux. One can see :math:`V_0` as +the inflection point of the outflow curve + +:math:`\\\\beta` A parameter to shape the response curve. :math:`Q_0` is the +outflow from the source in :math:`\\\\frac{m^3}{day}`, when :math:`V = V_0`. + +WARNING: :math:`\\\\beta < 0.5` may lead to numerical troubles and have a +dubious hydrological meaning. Please avoid. + +C++ includes: simple_connections.h "; + +%feature("docstring") +cmf::water::PowerLawConnection::PowerLawConnection "PowerLawConnection(WaterStorage::ptr source, flux_node::ptr target, +real Q0, real V0, real beta=1.0, real residual=0.0) + +Creates a power law connection. + +Parameters: +----------- + +source: Water storage from which the water flows out. Flux is a +function of source.volume + +target: Target node (boundary condition or storage). Does not +influence the strength of the flow + +Q0: Reference flow :math:`Q_0 = q(V_0)` Outflow when the source storage +equals the reference volume + +V0: Reference volume :math:`V_0` The reference volume to scale the exponent + +beta: :math:`\\\\beta [-]` An empirical exponent to shape the flux +function (default = 1 (linear function)) + +residual: :math:`V_{residual} [m^3]` The volume of water not flowing out +(default = 0) "; + +%feature("docstring") cmf::water::PowerLawConnection::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") cmf::water::PowerLawConnection::exchange_target +"void exchange_target(flux_node::ptr oldtarget, flux_node::ptr +newTarget) "; + +%feature("docstring") cmf::water::PowerLawConnection::get_ptr "ptr +get_ptr() const "; + +%feature("docstring") cmf::water::PowerLawConnection::get_target "flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") cmf::water::PowerLawConnection::get_target "flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") +cmf::water::PowerLawConnection::get_tracer_filter "real +get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::water::PowerLawConnection::get_tracer_filter "real +get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") cmf::water::PowerLawConnection::kill_me "bool +kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") cmf::water::PowerLawConnection::left_node "flux_node::ptr left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") cmf::water::PowerLawConnection::q "real +q(const flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") cmf::water::PowerLawConnection::refresh "void +refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") cmf::water::PowerLawConnection::right_node "flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") +cmf::water::PowerLawConnection::set_tracer_filter "void +set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::water::PowerLawConnection::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf::water::PowerLawConnection::short_string "virtual std::string short_string() const "; + +%feature("docstring") cmf::water::PowerLawConnection::to_string "virtual std::string to_string() const "; + + +// File: classcmf_1_1math_1_1precalculatable.xml +%feature("docstring") cmf::math::precalculatable ""; + +%feature("docstring") cmf::math::precalculatable::do_action "virtual +void do_action(Time t, bool use_OpenMP=true)=0 "; + + +// File: classcmf__core_1_1_priestley_taylor_e_t.xml +%feature("docstring") cmf_core::PriestleyTaylorET " + +Calculates the Evapotranspiration using Priestley-Taylor equation. .. +math:: lambda ET &=& \\\\\\\\alpha +\\\\\\\\frac{\\\\\\\\Delta}{\\\\\\\\Delta + \\\\\\\\gamma} +\\\\\\\\left(R_n - G\\\\\\\\right) where: :math:`\\\\\\\\Delta = +4098 \\\\\\\\frac{0.6108 e^{17.27 T}}{(T+237.3)^2} +\\\\\\\\frac{kPa}{^\\\\\\\\circ C}`, the slope of the vapor pressure/ +temperature curve :math:`\\\\\\\\gamma = \\\\\\\\frac{c_p +P}{\\\\\\\\epsilon \\\\\\\\lambda} \\\\\\\\frac{kPa}{^\\\\\\\\circ C}` +Psychrometric constant :math:`\\\\\\\\lambda = 2.45 +\\\\\\\\frac{MJ}{kg}` the latent heat of vaporization :math:`R_n +\\\\\\\\frac{MJ}{m^2day}` net Radiation (see Atmosphere) :math:`G` +Ground heat flux :math:`\\\\\\\\alpha` the Priestley-Taylor constant +(default 1.26 for humid climates) C++ includes: ET.h "; + +%feature("docstring") cmf_core::PriestleyTaylorET::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::ET::PriestleyTaylorET self, +cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr +ET_target, real alpha=1.26) -> PriestleyTaylorET +PriestleyTaylorET(cmf::upslope::SoilLayer::ptr source, +cmf::water::flux_node::ptr ET_target, real alpha=1.26) "; + +%feature("docstring") cmf_core::PriestleyTaylorET::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::PriestleyTaylorET::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::PriestleyTaylorET::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::PriestleyTaylorET::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::PriestleyTaylorET::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::PriestleyTaylorET::conc "def +conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") cmf_core::PriestleyTaylorET::ETpot "def +ETpot(self, args, kwargs) + +ETpot(stressedET self, Time t) -> real virtual real +ETpot(cmf::math::Time t) const "; + +%feature("docstring") cmf_core::PriestleyTaylorET::exchange_target "def exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::PriestleyTaylorET::get_layer "def +get_layer(self, args, kwargs) + +get_layer(stressedET self) -> cmf::upslope::SoilLayer::ptr +SoilLayer::ptr get_layer() const "; + +%feature("docstring") cmf_core::PriestleyTaylorET::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::PriestleyTaylorET::get_tracer_filter +"def get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::PriestleyTaylorET::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::PriestleyTaylorET::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::PriestleyTaylorET::q "def q(self, +args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::PriestleyTaylorET::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::PriestleyTaylorET::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::PriestleyTaylorET::set_stressfunction +"def set_stressfunction(self, args, kwargs) + +set_stressfunction(stressedET self, RootUptakeStessFunction +stressfunction) void set_stressfunction(const RootUptakeStessFunction +&stressfunction) Sets the stress function to limit water uptake. "; + +%feature("docstring") cmf_core::PriestleyTaylorET::set_tracer_filter +"def set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::PriestleyTaylorET::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::PriestleyTaylorET::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + +%feature("docstring") cmf_core::PriestleyTaylorET::use_for_cell "def +use_for_cell(args, kwargs) + +use_for_cell(Cell cell) "; + + +// File: classcmf_1_1upslope_1_1_e_t_1_1_priestley_taylor_e_t.xml +%feature("docstring") cmf::upslope::ET::PriestleyTaylorET " + +Calculates the Evapotranspiration using Priestley-Taylor equation. + + + +.. math:: + + lambda ET = \\\\alpha \\\\frac{\\\\Delta}{\\\\Delta + \\\\gamma} + \\\\left(R_n - G\\\\right) + +where: :math:`\\\\Delta = 4098 \\\\frac{0.6108 e^{17.27 T}}{(T+237.3)^2} \\\\frac{kPa}{^\\\\circ C}`, +the slope of the vapor pressure/ temperature curve + +:math:`\\\\gamma = \\\\frac{c_p P}{\\\\epsilon \\\\lambda} \\\\frac{kPa}{^\\\\circ C}` Psychrometric constant + +:math:`\\\\lambda = 2.45 \\\\frac{MJ}{kg}` the latent heat of vaporization + +:math:`R_n \\\\frac{MJ}{m^2day}` net Radiation (see Atmosphere) + +:math:`G` Ground heat flux + +:math:`\\\\alpha` the Priestley-Taylor constant (default 1.26 for humid +climates) + +C++ includes: ET.h "; + +%feature("docstring") +cmf::upslope::ET::PriestleyTaylorET::PriestleyTaylorET "PriestleyTaylorET(cmf::upslope::SoilLayer::ptr source, +cmf::water::flux_node::ptr ET_target, real alpha=1.26) "; + +%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) + +Returns the concentration of the flux. + +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; + +%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::ETpot "real ETpot(cmf::math::Time t) const "; + +%feature("docstring") +cmf::upslope::ET::PriestleyTaylorET::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::get_layer +"SoilLayer::ptr get_layer() const "; + +%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::get_ptr "ptr get_ptr() const "; + +%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::get_target +"flux_node::ptr get_target(const flux_node &inquirer) + +Returns the other end of a connection than the asking end. "; + +%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::get_target +"flux_node::ptr get_target(int index) const + +With index 0, the left node is returned, with index 1 the right node +of the connection. "; + +%feature("docstring") +cmf::upslope::ET::PriestleyTaylorET::get_tracer_filter "real +get_tracer_filter() + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::ET::PriestleyTaylorET::get_tracer_filter "real +get_tracer_filter(solute S) + +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; + +%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::kill_me "bool kill_me() + +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; + +%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::left_node +"flux_node::ptr left_node() const + +Returns the left node of this connection. "; + +%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::q "real +q(const flux_node &inquirer, cmf::math::Time t) + +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::refresh "void refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::right_node +"flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") +cmf::upslope::ET::PriestleyTaylorET::set_stressfunction "void +set_stressfunction(const RootUptakeStessFunction &stressfunction) + +Sets the stress function to limit water uptake. "; + +%feature("docstring") +cmf::upslope::ET::PriestleyTaylorET::set_tracer_filter "void +set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::ET::PriestleyTaylorET::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf::upslope::ET::PriestleyTaylorET::short_string "virtual +std::string short_string() const "; + +%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::to_string +"std::string to_string() const "; + + +// File: classcmf_1_1river_1_1_prism.xml +%feature("docstring") cmf::river::Prism " + +the height of a volume in a Prism with a defined base area + +C++ includes: ReachType.h "; + +%feature("docstring") cmf::river::Prism::Prism "Prism(double +base_area, double thickness_of_rough_ground=0.01) "; + +%feature("docstring") cmf::river::Prism::~Prism "~Prism() "; + +%feature("docstring") cmf::river::Prism::A "double A(double V) const + +:math:`A(V) = A_{base}` "; + +%feature("docstring") cmf::river::Prism::copy "Prism* copy() const +"; + +%feature("docstring") cmf::river::Prism::h "double h(double V) const + +:math:`h(V) = \\\\frac V A_{base}` "; + +%feature("docstring") cmf::river::Prism::q "virtual double q(double +h, double slope) const "; + +%feature("docstring") cmf::river::Prism::V "double V(double h) const +"; + + +// File: classcmf__core_1_1_prism.xml +%feature("docstring") cmf_core::Prism " + +the height of a volume in a Prism with a defined base area C++ +includes: ReachType.h "; + +%feature("docstring") cmf_core::Prism::__init__ "def __init__(self, +args, kwargs) + +__init__(cmf::river::Prism self, double base_area, double +thickness_of_rough_ground=0.01) -> Prism Prism(double base_area, +double thickness_of_rough_ground=0.01) "; + +%feature("docstring") cmf_core::Prism::A "def A(self, args, kwargs) + +A(IVolumeHeightFunction self, double V) -> double virtual double +A(double V) const =0 Returns the area of the surface for a given +volume. "; + +%feature("docstring") cmf_core::Prism::copy "def copy(self, args, +kwargs) + +copy(Prism self) -> Prism Prism* copy() const "; + +%feature("docstring") cmf_core::Prism::h "def h(self, args, kwargs) + +h(IVolumeHeightFunction self, double V) -> double virtual double +h(double V) const =0 Returns the depth of a given volume. "; + +%feature("docstring") cmf_core::Prism::q "def q(self, args, kwargs) + +q(IVolumeHeightFunction self, double h, double slope) -> double +virtual double q(double h, double slope) const "; + +%feature("docstring") cmf_core::Prism::V "def V(self, args, kwargs) + +V(IVolumeHeightFunction self, double h) -> double virtual double +V(double h) const =0 "; + + +// File: classcmf__core_1_1project.xml +%feature("docstring") cmf_core::project " + +The study area, holding all cells, outlets and streams. Todo Describe +tracers C++ includes: project.h "; + +%feature("docstring") cmf_core::project::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::project self, std::string solute_names) -> project +project(std::string solute_names=\"\") Creates a new project. +Parameters: ----------- solute_names: A string representing the +names of the solutes to be used in the project. Sepereate solute names +with space. "; + +%feature("docstring") cmf_core::project::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::project::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::project::__len__ "def __len__(self) +"; + +%feature("docstring") cmf_core::project::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::project::get_cell "def +get_cell(self, args, kwargs) + +get_cell(project self, ptrdiff_t index) -> Cell upslope::Cell& +get_cell(ptrdiff_t index) Returns the reference to the cell at index +in the project. "; + +%feature("docstring") cmf_core::project::get_node "def +get_node(self, args, kwargs) + +get_node(project self, ptrdiff_t index) -> cmf::water::flux_node::ptr +cmf::water::flux_node::ptr get_node(ptrdiff_t index) Returns the node +from the project nodes at index. "; + +%feature("docstring") cmf_core::project::get_reach "def +get_reach(self, args, kwargs) + +get_reach(project self, ptrdiff_t index) -> cmf::river::Reach::ptr +cmf::river::Reach::ptr get_reach(ptrdiff_t index) Returns the reach +at index. "; + +%feature("docstring") cmf_core::project::get_states "def +get_states(self, args, kwargs) + +get_states(StateVariableOwner self) -> StateVariableList virtual +StateVariableList get_states()=0 Add the state variables, owned by an +object derived from StateVariableOwner, to the given vector. "; + +%feature("docstring") cmf_core::project::get_storages "def +get_storages(self, args, kwargs) + +get_storages(project self) -> node_list cmf::water::node_list +get_storages() Returns a list of all storages of this project. "; + +%feature("docstring") cmf_core::project::NewCell "def NewCell(self, +args, kwargs) + +NewCell(project self, double x, double y, double z, double area, bool +with_surfacewater=False) -> Cell cmf::upslope::Cell* NewCell(double +x, double y, double z, double area, bool with_surfacewater=false) +Creates a new cell. A new cell, owned by the project Parameters: +----------- x: y: z: Position of the cell center in project +coordinates (m) area: Area of the cell in m^2 with_surfacewater: If +true, the cell will own a surfacewater storage upon creation "; + +%feature("docstring") cmf_core::project::NewNeumannBoundary "def +NewNeumannBoundary(self, args, kwargs) + +NewNeumannBoundary(project self, std::string name, +cmf::water::WaterStorage::ptr target) -> +cmf::water::NeumannBoundary::ptr cmf::water::NeumannBoundary::ptr +NewNeumannBoundary(std::string name, cmf::water::WaterStorage::ptr +target) Creates a new Neumann boundary for a target water storage. +The boundary is stored with the project A new Neumann boundary +Parameters: ----------- name: The name of the boundary condition +target: The water storage to which the Neumann boundary is bound "; + +%feature("docstring") cmf_core::project::NewOpenStorage "def +NewOpenStorage(self, args, kwargs) + +NewOpenStorage(project self, std::string name, double x, double y, +double z, double area) -> cmf::river::OpenWaterStorage::ptr +cmf::river::OpenWaterStorage::ptr NewOpenStorage(std::string name, +double x, double y, double z, double area) Creates a new open water +storage with a prism geometry. The open water storage is added to the +project nodes A new open water storage, owned by the project +Parameters: ----------- name: Name of the open water storage for +output x: y: z: Position of the open water storage in project +coordinates area: Surface area of the open water storage "; + +%feature("docstring") cmf_core::project::NewOutlet "def +NewOutlet(self, args, kwargs) + +NewOutlet(project self, std::string name, double x=0, double y=0, +double z=0) -> cmf::water::DirichletBoundary::ptr +cmf::water::DirichletBoundary::ptr NewOutlet(std::string name, double +x=0, double y=0, double z=0) Creates a new Dirichlet boundary +condition and adds it to the list of outlets The potential of the +Dirichlet boundary equals z, but can be changed. Parameters: +----------- name: Name of the boundary condition for output x: y: +z: Position of the boundary condition in project coordinates "; + +%feature("docstring") cmf_core::project::NewReach "def +NewReach(self, args, kwargs) + +NewReach(project self, double x, double y, double z, IChannel shape, +bool diffusive=False) -> cmf::river::Reach::ptr cmf::river::Reach::ptr +NewReach(double x, double y, double z, cmf::river::IChannel &shape, +bool diffusive=false) Creates a new reach. A new reach, owned by the +project Parameters: ----------- x: y: z: Position of the reach in +project coordinates shape: Crossectional geometry of the river. Any +class inheriting from cmf::water::IChannel diffusive: If true, this +reach uses by default a diffusive wave connection "; + +%feature("docstring") cmf_core::project::NewStorage "def +NewStorage(self, args, kwargs) + +NewStorage(project self, std::string name, double x=0, double y=0, +double z=0) -> cmf::water::WaterStorage::ptr +cmf::water::WaterStorage::ptr NewStorage(std::string name, double x=0, +double y=0, double z=0) Creates a new generic water storage at +position x,y,z. The storage is added to the project nodes A new water +storage, owned by the project Parameters: ----------- name: Name of +the generic water storage for output x: y: z: Position of the +generic water storage condition in project coordinates "; + +%feature("docstring") cmf_core::project::node_count "def +node_count(self, args, kwargs) + +node_count(project self) -> size_t size_t node_count() const Returns +the number of nodes saved with this project. "; + +%feature("docstring") cmf_core::project::nodes "def nodes(self) "; + +%feature("docstring") cmf_core::project::reach_count "def +reach_count(self, args, kwargs) + +reach_count(project self) -> size_t size_t reach_count() const +Returns the number of reaches in this project. "; + +%feature("docstring") cmf_core::project::reaches "def reaches(self) +"; + +%feature("docstring") cmf_core::project::remove_node "def +remove_node(self, args, kwargs) + +remove_node(project self, cmf::water::flux_node::ptr node) -> size_t +size_t remove_node(cmf::water::flux_node::ptr node) Removes a node +from the repository. Removes a node (boundary condition or water +storage) from the node repository of the project. NOTE: If you have +other references to this node, the node is not deleted. If you are +creating a new solver, the node will not be part of the solver. "; + +%feature("docstring") cmf_core::project::size "def size(self, args, +kwargs) + +size(project self) -> size_t size_t size() const The number of cells +in the project. "; + +%feature("docstring") cmf_core::project::use_IDW_meteo "def +use_IDW_meteo(self, args, kwargs) + +use_IDW_meteo(project self, double z_weight=0, double power=2) void +use_IDW_meteo(double z_weight=0, double power=2) Uses IDW +interpolation to generate meterological data for each cell of project. +Creates a meteo-data source for each cell, using spatial interpolated +data from all meteorological stations of the project using Inverse +Distance Weighted (IDW) interpolation. The meteorolgical value f is +calculated with IDW for position x,y,z and time t as follows: .. +math:: f(x,y,z,t) &=& \\\\\\\\sum^N_{i=1}{f_i(t) w_i(x,y,z)} +\\\\\\\\\\\\\\\\ w_i(x,y,z) &=& +\\\\\\\\frac{d_i(x,y,z)^{-p}}{\\\\\\\\sum^N_{j=0}{d_j(x,y,z)^{-p}}} +\\\\\\\\\\\\\\\\ d_i(x,y,z) &=& w_z +\\\\\\\\left|z-z_i\\\\\\\\right| + +\\\\\\\\sqrt{\\\\\\\\left(x-x_i\\\\\\\\right)^2 + +\\\\\\\\left(y-y_i\\\\\\\\right)^2} :math:`N` is the number of +stations :math:`f_i(t)` the meteorological value at time t, eg. +Temperature, Humidity :math:`w_i` is the weight of station i +:math:`d_i` is the distance from x,y,z to station i :math:`p` the +power of the weighting function, usually 2. :math:`x_i,y_i,z_i` is +the position of station i in space :math:`w_z` is a factor to weight +the vertical distance between stations and the cell. 0 results in a +pure horizontal interpolation (normal IDW). If :math:`w_z=1`, height +difference is as important as horizontal distance, and with +:math:`w_z>1` the height difference is weighted more important than +horizontal distance See: IDW_Meteorology Parameters: ----------- +z_weight: :math:`w_z` the weight of height difference between cell +and station power: the power of the distance weight "; + +%feature("docstring") cmf_core::project::use_IDW_rainfall "def +use_IDW_rainfall(self, args, kwargs) + +use_IDW_rainfall(project self, double z_weight=0, double power=2) void +use_IDW_rainfall(double z_weight=0, double power=2) Uses IDW +interpolation to generate rainfall data for each cell of project. +Creates a rainfall-data source for each cell, using spatial +interpolated data from all meteorological stations of the project +using Inverse Distance Weighted (IDW) interpolation. The rainfall +intensity P is calculated with IDW for position x,y,z and time t as +follows: .. math:: P(x,y,z,t) &=& \\\\\\\\sum^N_{i=1}{P_i(t) +w_i(x,y,z)} \\\\\\\\\\\\\\\\ w_i(x,y,z) &=& +\\\\\\\\frac{d_i(x,y,z)^{-p}}{\\\\\\\\sum^N_{j=0}{d_j(x,y,z)^{-p}}} +\\\\\\\\\\\\\\\\ d_i(x,y,z) &=& w_z +\\\\\\\\left|z-z_i\\\\\\\\right| + +\\\\\\\\sqrt{\\\\\\\\left(x-x_i\\\\\\\\right)^2 + +\\\\\\\\left(y-y_i\\\\\\\\right)^2} :math:`N` is the number of +stations :math:`P_i(t)` the meteorological value at time t, eg. +Temperature, Humidity :math:`w_i` is the weight of station i +:math:`d_i` is the distance from x,y,z to station i :math:`p` the +power of the weighting function, usually 2. :math:`x_i,y_i,z_i` is +the position of station i in space :math:`w_z` is a factor to weight +the vertical distance between stations and the cell. 0 results in a +pure horizontal interpolation (normal IDW). If :math:`w_z=1`, height +difference is as important as horizontal distance, and with +:math:`w_z>1` the height difference is weighted more important than +horizontal distance See: IDW_Meteorology Parameters: ----------- +z_weight: :math:`w_z` the weight of height difference between cell +and station power: the power of the distance weight "; + +%feature("docstring") cmf_core::project::use_nearest_meteo "def +use_nearest_meteo(self, args, kwargs) + +use_nearest_meteo(project self, double z_weight=0) void +use_nearest_meteo(double z_weight=0) Connects all cells of the +project with its nearest meteorological station. Distance is +calculated as follows: .. math:: d_i(x,y,z) = w_z +\\\\\\\\left|z-z_i\\\\\\\\right| + +\\\\\\\\sqrt{\\\\\\\\left(x-x_i\\\\\\\\right)^2 + +\\\\\\\\left(y-y_i\\\\\\\\right)^2} :math:`d_i` is the distance from +x,y,z to station i :math:`p` the power of the weighting function, +usually 2. :math:`x_i,y_i,z_i` is the position of station i in space +:math:`w_z` is a factor to weight the vertical distance between +stations and the cell. 0 results in a pure horizontal interpolation +(normal IDW). If :math:`w_z=1`, height difference is as important as +horizontal distance, and with :math:`w_z>1` the height difference is +weighted more important than horizontal distance Parameters: +----------- z_weight: :math:`w_z` the weight of height difference +between cell and station "; + +%feature("docstring") cmf_core::project::use_nearest_rainfall "def +use_nearest_rainfall(self, args, kwargs) + +use_nearest_rainfall(project self, double z_weight=0) void +use_nearest_rainfall(double z_weight=0) Connects all cells of the +project with its nearest rainfall station. Distance is calculated as +follows: .. math:: d_i(x,y,z) = w_z +\\\\\\\\left|z-z_i\\\\\\\\right| + +\\\\\\\\sqrt{\\\\\\\\left(x-x_i\\\\\\\\right)^2 + +\\\\\\\\left(y-y_i\\\\\\\\right)^2} :math:`d_i` is the distance from +x,y,z to station i :math:`p` the power of the weighting function, +usually 2. :math:`x_i,y_i,z_i` is the position of station i in space +:math:`w_z` is a factor to weight the vertical distance between +stations and the cell. 0 results in a pure horizontal interpolation +(normal IDW). If :math:`w_z=1`, height difference is as important as +horizontal distance, and with :math:`w_z>1` the height difference is +weighted more important than horizontal distance Parameters: +----------- z_weight: :math:`w_z` the weight of height difference +between cell and station "; + + +// File: classcmf_1_1project.xml +%feature("docstring") cmf::project " + +The study area, holding all cells, outlets and streams. + +Todo Describe tracers + +C++ includes: project.h "; + +%feature("docstring") cmf::project::project "project(std::string +solute_names=\"\") + +Creates a new project. + +Parameters: +----------- + +solute_names: A string representing the names of the solutes to be +used in the project. Sepereate solute names with space. "; + +%feature("docstring") cmf::project::~project "~project() "; + +%feature("docstring") cmf::project::get_cell "upslope::Cell& +get_cell(ptrdiff_t index) + +Returns the reference to the cell at index in the project. "; + +%feature("docstring") cmf::project::get_cells "const +upslope::cell_vector& get_cells() const + +Returns the cells in the project. "; + +%feature("docstring") cmf::project::get_node "cmf::water::flux_node::ptr get_node(ptrdiff_t index) + +Returns the node from the project nodes at index. "; + +%feature("docstring") cmf::project::get_reach "cmf::river::Reach::ptr get_reach(ptrdiff_t index) + +Returns the reach at index. "; + +%feature("docstring") cmf::project::get_states "cmf::math::StateVariableList get_states() + +Returns all state variables of the project. Mostly for internal use. +"; + +%feature("docstring") cmf::project::get_storages "cmf::water::node_list get_storages() + +Returns a list of all storages of this project. "; + +%feature("docstring") cmf::project::NewCell "cmf::upslope::Cell* +NewCell(double x, double y, double z, double area, bool +with_surfacewater=false) + +Creates a new cell. + +A new cell, owned by the project + +Parameters: +----------- + +x: y: z: Position of the cell center in project coordinates (m) + +area: Area of the cell in m^2 + +with_surfacewater: If true, the cell will own a surfacewater storage +upon creation "; + +%feature("docstring") cmf::project::NewNeumannBoundary "cmf::water::NeumannBoundary::ptr NewNeumannBoundary(std::string name, +cmf::water::WaterStorage::ptr target) + +Creates a new Neumann boundary for a target water storage. + +The boundary is stored with the project A new Neumann boundary + +Parameters: +----------- + +name: The name of the boundary condition + +target: The water storage to which the Neumann boundary is bound "; + +%feature("docstring") cmf::project::NewOpenStorage "cmf::river::OpenWaterStorage::ptr NewOpenStorage(std::string name, +double x, double y, double z, double area) + +Creates a new open water storage with a prism geometry. + +The open water storage is added to the project nodes A new open water +storage, owned by the project + +Parameters: +----------- + +name: Name of the open water storage for output + +x: y: z: Position of the open water storage in project coordinates + +area: Surface area of the open water storage "; + +%feature("docstring") cmf::project::NewOutlet "cmf::water::DirichletBoundary::ptr NewOutlet(std::string name, double +x=0, double y=0, double z=0) + +Creates a new Dirichlet boundary condition and adds it to the list of +outlets The potential of the Dirichlet boundary equals z, but can be +changed. + +Parameters: +----------- + +name: Name of the boundary condition for output + +x: y: z: Position of the boundary condition in project coordinates +"; + +%feature("docstring") cmf::project::NewReach "cmf::river::Reach::ptr +NewReach(double x, double y, double z, cmf::river::IChannel &shape, +bool diffusive=false) + +Creates a new reach. + +A new reach, owned by the project + +Parameters: +----------- + +x: y: z: Position of the reach in project coordinates + +shape: Crossectional geometry of the river. Any class inheriting from +cmf::water::IChannel + +diffusive: If true, this reach uses by default a diffusive wave +connection "; + +%feature("docstring") cmf::project::NewStorage "cmf::water::WaterStorage::ptr NewStorage(std::string name, double x=0, +double y=0, double z=0) + +Creates a new generic water storage at position x,y,z. + +The storage is added to the project nodes A new water storage, owned +by the project + +Parameters: +----------- + +name: Name of the generic water storage for output -Returns an array containing the wetness in m3 H2O/m3 pore space of all -layers in the list. "; +x: y: z: Position of the generic water storage condition in project +coordinates "; -%feature("docstring") cmf::upslope::layer_list::pop "SoilLayer::ptr -pop() +%feature("docstring") cmf::project::node_count "size_t node_count() +const -Deletes the last layer from the list and returns it. "; +Returns the number of nodes saved with this project. "; -%feature("docstring") cmf::upslope::layer_list::set_ice_fraction "void set_ice_fraction(const cmf::math::num_array &Value, size_t -offset=0) +%feature("docstring") cmf::project::reach_count "size_t +reach_count() const -Sets the fraction of the ice content of the soil water. "; +Returns the number of reaches in this project. "; -%feature("docstring") cmf::upslope::layer_list::set_potential "void -set_potential(const cmf::math::num_array &Value, size_t offset=0) +%feature("docstring") cmf::project::remove_node "size_t +remove_node(cmf::water::flux_node::ptr node) -Sets the potential (head) in m of layers [offset : arraysize]. "; +Removes a node from the repository. -%feature("docstring") cmf::upslope::layer_list::set_rootfraction "void set_rootfraction(const cmf::math::num_array &Value, size_t -offset=0) +Removes a node (boundary condition or water storage) from the node +repository of the project. NOTE: If you have other references to this +node, the node is not deleted. If you are creating a new solver, the +node will not be part of the solver. "; + +%feature("docstring") cmf::project::size "size_t size() const + +The number of cells in the project. "; + +%feature("docstring") cmf::project::use_IDW_meteo "void +use_IDW_meteo(double z_weight=0, double power=2) + +Uses IDW interpolation to generate meterological data for each cell of +project. + +Creates a meteo-data source for each cell, using spatial interpolated +data from all meteorological stations of the project using Inverse +Distance Weighted (IDW) interpolation. The meteorolgical value f is +calculated with IDW for position x,y,z and time t as follows: + + +.. math:: + + f(x,y,z,t) &=& \\\\sum^N_{i=1}{f_i(t) w_i(x,y,z)} + \\\\\\\\ w_i(x,y,z) &=& + \\\\frac{d_i(x,y,z)^{-p}}{\\\\sum^N_{j=0}{d_j(x,y,z)^{-p}}} \\\\\\\\ + d_i(x,y,z) &=& w_z \\\\left|z-z_i\\\\right| + + \\\\sqrt{\\\\left(x-x_i\\\\right)^2 + \\\\left(y-y_i\\\\right)^2} + + + :math:`N` is the number of stations + +:math:`f_i(t)` the meteorological value at time t, eg. Temperature, Humidity + +:math:`w_i` is the weight of station i + +:math:`d_i` is the distance from x,y,z to station i + +:math:`p` the power of the weighting function, usually 2. + +:math:`x_i,y_i,z_i` is the position of station i in space + +:math:`w_z` is a factor to weight the vertical distance between stations and +the cell. 0 results in a pure horizontal interpolation (normal IDW). +If :math:`w_z=1`, height difference is as important as horizontal distance, +and with :math:`w_z>1` the height difference is weighted more important than +horizontal distance See: IDW_Meteorology + +Parameters: +----------- + +z_weight: :math:`w_z` the weight of height difference between cell and +station + +power: the power of the distance weight "; + +%feature("docstring") cmf::project::use_IDW_rainfall "void +use_IDW_rainfall(double z_weight=0, double power=2) + +Uses IDW interpolation to generate rainfall data for each cell of +project. + +Creates a rainfall-data source for each cell, using spatial +interpolated data from all meteorological stations of the project +using Inverse Distance Weighted (IDW) interpolation. The rainfall +intensity P is calculated with IDW for position x,y,z and time t as +follows: + +.. math:: + + P(x,y,z,t) &=& \\\\sum^N_{i=1}{P_i(t) + w_i(x,y,z)} \\\\\\\\ w_i(x,y,z) &=& + \\\\frac{d_i(x,y,z)^{-p}}{\\\\sum^N_{j=0}{d_j(x,y,z)^{-p}}} \\\\\\\\ + d_i(x,y,z) &=& w_z \\\\left|z-z_i\\\\right| + + \\\\sqrt{\\\\left(x-x_i\\\\right)^2 + \\\\left(y-y_i\\\\right)^2} + + + :math:`N` is the number of stations + +:math:`P_i(t)` the meteorological value at time t, eg. Temperature, Humidity + +:math:`w_i` is the weight of station i + +:math:`d_i` is the distance from x,y,z to station i + +:math:`p` the power of the weighting function, usually 2. + +:math:`x_i,y_i,z_i` is the position of station i in space + +:math:`w_z` is a factor to weight the vertical distance between stations and +the cell. 0 results in a pure horizontal interpolation (normal IDW). +If :math:`w_z=1`, height difference is as important as horizontal distance, +and with :math:`w_z>1` the height difference is weighted more important than +horizontal distance See: IDW_Meteorology + +Parameters: +----------- + +z_weight: :math:`w_z` the weight of height difference between cell and +station + +power: the power of the distance weight "; + +%feature("docstring") cmf::project::use_nearest_meteo "void +use_nearest_meteo(double z_weight=0) + +Connects all cells of the project with its nearest meteorological +station. + +Distance is calculated as follows: + +.. math:: + + d_i(x,y,z) = w_z + \\\\left|z-z_i\\\\right| + \\\\sqrt{\\\\left(x-x_i\\\\right)^2 + + \\\\left(y-y_i\\\\right)^2} + +:math:`d_i` is the distance from x,y,z to +station i + +:math:`p` the power of the weighting function, usually 2. + +:math:`x_i,y_i,z_i` is the position of station i in space + +:math:`w_z` is a factor to weight the vertical distance between stations and +the cell. 0 results in a pure horizontal interpolation (normal IDW). +If :math:`w_z=1`, height difference is as important as horizontal distance, +and with :math:`w_z>1` the height difference is weighted more important than +horizontal distance + +Parameters: +----------- + +z_weight: :math:`w_z` the weight of height difference between cell and +station "; + +%feature("docstring") cmf::project::use_nearest_rainfall "void +use_nearest_rainfall(double z_weight=0) + +Connects all cells of the project with its nearest rainfall station. + +Distance is calculated as follows: + +.. math:: + + d_i(x,y,z) = w_z + \\\\left|z-z_i\\\\right| + \\\\sqrt{\\\\left(x-x_i\\\\right)^2 + + \\\\left(y-y_i\\\\right)^2} + +:math:`d_i` is the distance from x,y,z to +station i + +:math:`p` the power of the weighting function, usually 2. + +:math:`x_i,y_i,z_i` is the position of station i in space + +:math:`w_z` is a factor to weight the vertical distance between stations and +the cell. 0 results in a pure horizontal interpolation (normal IDW). +If :math:`w_z=1`, height difference is as important as horizontal distance, +and with :math:`w_z>1` the height difference is weighted more important than +horizontal distance + +Parameters: +----------- + +z_weight: :math:`w_z` the weight of height difference between cell and +station "; + + +// File: classcmf__core_1_1project__list__wrapper.xml +%feature("docstring") cmf_core::project_list_wrapper ""; + +%feature("docstring") cmf_core::project_list_wrapper::__init__ "def +__init__(self, getitem, getlen, name) "; + +%feature("docstring") cmf_core::project_list_wrapper::__getitem__ "def __getitem__(self, index) "; + +%feature("docstring") cmf_core::project_list_wrapper::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::project_list_wrapper::__len__ "def +__len__(self) "; + +%feature("docstring") cmf_core::project_list_wrapper::__repr__ "def +__repr__(self) "; + + +// File: classcmf_1_1geometry_1_1qtree_1_1_quadtree.xml +%feature("docstring") cmf::geometry::qtree::Quadtree " + +A simple quad tree to check if the boundaries of geometries overlap or +not "; + +%feature("docstring") cmf::geometry::qtree::Quadtree::__init__ "def +__init__(self, area, divisions=50) + +:param area: The total area of the study area in m2 :param divisions: +The number of divisions of the area, default is 20 "; + +%feature("docstring") cmf::geometry::qtree::Quadtree::__call__ "def +__call__(self, bounds) + +Get all objects in the given boundaries :param bounds: The boundary +rectangle of the tree. A 4 item sequence (xmin, ymin, xmax, ymax) +:return: "; + +%feature("docstring") cmf::geometry::qtree::Quadtree::append "def +append(self, obj, bounds) + +Appends an object to the qtree using the given bounds. :param obj: An +object to append to the tree, must be hashable :param bounds: The +boundary rectangle of the object. A 4 item sequence (xmin, ymin, xmax, +ymax) "; + +%feature("docstring") cmf::geometry::qtree::Quadtree::extend "def +extend(self, objects_with_boundaries) + +Extends the Quadtree with objects :param objects_with_boundaries: an +iterable of (object, bounds) tuples :return: "; + +%feature("docstring") cmf::geometry::qtree::Quadtree::iterbounds "def iterbounds(self, bounds) + +Iterates through all positions in the boundaries :param bounds: The +boundary rectangle. A 4 item sequence (xmin, ymin, xmax, ymax) +:return: (i,j) position tuple "; + + +// File: classcmf__core_1_1_rainfall.xml +%feature("docstring") cmf_core::Rainfall " + +A connection routing rainfall to surface water and to an eventually +existing canopy storage. C++ includes: AtmosphericFluxes.h "; + +%feature("docstring") cmf_core::Rainfall::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::connections::Rainfall self, +cmf::water::flux_node::ptr target, Cell cell, bool +getthroughfall=True, bool getintercepted=True) -> Rainfall +Rainfall(cmf::water::flux_node::ptr target, cmf::upslope::Cell &cell, +bool getthroughfall=true, bool getintercepted=true) Creates a new +Rainfall connection. "; + +%feature("docstring") cmf_core::Rainfall::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::Rainfall::__eq__ "def __eq__(self, +args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::Rainfall::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::Rainfall::__iter__ "def +__iter__(self) "; -Sets the fraction of roots in each layer. "; +%feature("docstring") cmf_core::Rainfall::__repr__ "def +__repr__(self) "; -%feature("docstring") cmf::upslope::layer_list::set_theta "void -set_theta(const cmf::math::num_array &Value, size_t offset=0) +%feature("docstring") cmf_core::Rainfall::conc "def conc(self, args, +kwargs) -Sets the volumetric water content of the soil. "; +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -%feature("docstring") cmf::upslope::layer_list::set_volume "void -set_volume(const cmf::math::num_array &Value, size_t offset=0) +%feature("docstring") cmf_core::Rainfall::exchange_target "def +exchange_target(self, args, kwargs) -Sets the Volume in m3 of layers [offset : arraysize]. "; +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") cmf::upslope::layer_list::set_wetness "void -set_wetness(const cmf::math::num_array &Value, size_t offset=0) +%feature("docstring") cmf_core::Rainfall::get_target "def +get_target(self, args) -Sets the wetness in m3/m3 of layers [offset : arraysize]. "; +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -%feature("docstring") cmf::upslope::layer_list::size "size_t size() -const +%feature("docstring") cmf_core::Rainfall::get_tracer_filter "def +get_tracer_filter(self, args) -Number of layers in the list. "; +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; +%feature("docstring") cmf_core::Rainfall::kill_me "def kill_me(self, +args, kwargs) -// File: classcmf_1_1upslope_1_1connections_1_1_layer_bypass.xml -%feature("docstring") cmf::upslope::connections::LayerBypass " +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -A simplification of macro pore flux for swelling soils. +%feature("docstring") cmf_core::Rainfall::left_node "def +left_node(self, args, kwargs) -Connects the surfacewater of the cell with deeper layers, assuming the -presence of cracks. At saturation level of the target layer, the -cracks are closed +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -.. math:: +%feature("docstring") cmf_core::Rainfall::q "def q(self, args, +kwargs) - q_{crack} = K_{max,crack} - \\\\left(1-\\\\left(\\\\frac{w-w_0}{1-w_0}\\\\right)^\\\\beta\\\\right) - A +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; -where: :math:`q_{crack}` is the flux from the surface water to the -target layer in m3/day +%feature("docstring") cmf_core::Rainfall::refresh "def refresh(self, +args, kwargs) -:math:`K_{max,crack}` is the maximum conductivity of the cracks in m/day +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; -:math:`w` is the actual wetness of the target layer +%feature("docstring") cmf_core::Rainfall::right_node "def +right_node(self, args, kwargs) -:math:`w_0` is saturation, where the shrinkage of the cracks starts +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; -:math:`\\\\beta` is an empirical shape parameter of the crack size/wetness -relation +%feature("docstring") cmf_core::Rainfall::set_tracer_filter "def +set_tracer_filter(self, args) -:math:`A` is the area of the cell +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; -C++ includes: Percolation.h "; +%feature("docstring") cmf_core::Rainfall::short_string "def +short_string(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::LayerBypass::LayerBypass "LayerBypass(cmf::water::flux_node::ptr left, -cmf::upslope::SoilLayer::ptr right, real Kmax=100., real w0=0.0, real -beta=1.0) +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -Creates a layer bypass connection. +%feature("docstring") cmf_core::Rainfall::to_string "def +to_string(self, args, kwargs) -Parameters: ------------ +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -left: The source of the flux, usually the surfacewater of the cell -right: The target soil layer +// File: classcmf_1_1upslope_1_1connections_1_1_rainfall.xml +%feature("docstring") cmf::upslope::connections::Rainfall " -Kmax: maximum conductivity of the cracks in m/day +A connection routing rainfall to surface water and to an eventually +existing canopy storage. -w0: is the actual wetness of the target layer +C++ includes: AtmosphericFluxes.h "; -beta: is an empirical shape parameter of the crack size/wetness -relation "; +%feature("docstring") cmf::upslope::connections::Rainfall::Rainfall "Rainfall(cmf::water::flux_node::ptr target, cmf::upslope::Cell &cell, +bool getthroughfall=true, bool getintercepted=true) -%feature("docstring") cmf::upslope::connections::LayerBypass::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) +Creates a new Rainfall connection. "; + +%feature("docstring") cmf::upslope::connections::Rainfall::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns the concentration of the flux. @@ -7537,27 +24911,24 @@ If not overridden, it returns the concentration of the source of the flux (direction depending) "; %feature("docstring") -cmf::upslope::connections::LayerBypass::exchange_target "void +cmf::upslope::connections::Rainfall::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") cmf::upslope::connections::LayerBypass::get_ptr -"ptr get_ptr() const "; +%feature("docstring") cmf::upslope::connections::Rainfall::get_ptr "ptr get_ptr() const "; -%feature("docstring") -cmf::upslope::connections::LayerBypass::get_target "flux_node::ptr -get_target(const flux_node &inquirer) +%feature("docstring") cmf::upslope::connections::Rainfall::get_target +"flux_node::ptr get_target(const flux_node &inquirer) Returns the other end of a connection than the asking end. "; -%feature("docstring") -cmf::upslope::connections::LayerBypass::get_target "flux_node::ptr -get_target(int index) const +%feature("docstring") cmf::upslope::connections::Rainfall::get_target +"flux_node::ptr get_target(int index) const With index 0, the left node is returned, with index 1 the right node of the connection. "; %feature("docstring") -cmf::upslope::connections::LayerBypass::get_tracer_filter "real +cmf::upslope::connections::Rainfall::get_tracer_filter "real get_tracer_filter() A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -7566,51 +24937,39 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::connections::LayerBypass::get_tracer_filter "real +cmf::upslope::connections::Rainfall::get_tracer_filter "real get_tracer_filter(solute S) A value ranging from 0 to 1 to filter tracers out of the water flux. "; -%feature("docstring") cmf::upslope::connections::LayerBypass::K "real K(real w) - -the actual crack conductivity - -Parameters: ------------ - -w: the wetness of the target layer "; - -%feature("docstring") cmf::upslope::connections::LayerBypass::kill_me -"bool kill_me() +%feature("docstring") cmf::upslope::connections::Rainfall::kill_me "bool kill_me() Deregisters this connection from its nodes. Returns true if only one reference is left. "; -%feature("docstring") -cmf::upslope::connections::LayerBypass::left_node "flux_node::ptr -left_node() const +%feature("docstring") cmf::upslope::connections::Rainfall::left_node +"flux_node::ptr left_node() const Returns the left node of this connection. "; -%feature("docstring") cmf::upslope::connections::LayerBypass::q "real q(const flux_node &inquirer, cmf::math::Time t) +%feature("docstring") cmf::upslope::connections::Rainfall::q "real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current flux through a connection. Negative signs mean out of the inquirer, positive are inflows to the inquirer. "; -%feature("docstring") cmf::upslope::connections::LayerBypass::refresh -"void refresh(cmf::math::Time t) +%feature("docstring") cmf::upslope::connections::Rainfall::refresh "void refresh(cmf::math::Time t) Performes a new calculation of the flux. "; -%feature("docstring") -cmf::upslope::connections::LayerBypass::right_node "flux_node::ptr -right_node() const +%feature("docstring") cmf::upslope::connections::Rainfall::right_node +"flux_node::ptr right_node() const returns the right node of this connection "; %feature("docstring") -cmf::upslope::connections::LayerBypass::set_tracer_filter "void +cmf::upslope::connections::Rainfall::set_tracer_filter "void set_tracer_filter(real value) A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -7619,557 +24978,635 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::connections::LayerBypass::set_tracer_filter "void +cmf::upslope::connections::Rainfall::set_tracer_filter "void set_tracer_filter(solute S, real value) "; %feature("docstring") -cmf::upslope::connections::LayerBypass::short_string "virtual +cmf::upslope::connections::Rainfall::short_string "virtual std::string short_string() const "; -%feature("docstring") -cmf::upslope::connections::LayerBypass::to_string "virtual -std::string to_string() const "; +%feature("docstring") cmf::upslope::connections::Rainfall::to_string +"virtual std::string to_string() const "; -// File: classcmf_1_1water_1_1linear__scale.xml -%feature("docstring") cmf::water::linear_scale " +// File: classcmf_1_1atmosphere_1_1_rainfall_station.xml +%feature("docstring") cmf::atmosphere::RainfallStation " -A linear scaling functor, with slope and displacement. +RainfallStation describes a rainfall timeseries in mm/day at a certain +place. -C++ includes: boundary_condition.h "; +Use RainfallStationReference or IDWRainfall to distribute the data +into space -%feature("docstring") cmf::water::linear_scale::linear_scale "linear_scale(real _slope=1, real _displacement=0) +C++ includes: precipitation.h "; -Creates a linear scale (by default it is a unity scale, :math:`a=1; b=0`) "; +%feature("docstring") +cmf::atmosphere::RainfallStation::RainfallStation "RainfallStation(const RainfallStation ©) +copy c'tor "; -// File: classcmf_1_1water_1_1_linear_adsorption.xml -%feature("docstring") cmf::water::LinearAdsorption " +%feature("docstring") cmf::atmosphere::RainfallStation::tostring "std::string tostring() const -This class calculates the adsorption equilibrium between sorbat and -sorbent using the linear (Henry) isotherme. +Returns the name and the mean yearly rainfall. "; -Linear (Henry) isotherme: +%feature("docstring") cmf::atmosphere::RainfallStation::use_for_cell +"void use_for_cell(cmf::upslope::Cell &c) +Connects a cell with this rainfall station. "; -.. math:: +// File: classcmf__core_1_1_rainfall_station.xml +%feature("docstring") cmf_core::RainfallStation " - \\\\frac{x_{ad}}{m} = K c +RainfallStation describes a rainfall timeseries in mm/day at a certain +place. Use RainfallStationReference or IDWRainfall to distribute the +data into space C++ includes: precipitation.h "; -where :math:`x_{ad} = x_{tot} - x_{free}` is the adsorbed tracer mass :math:`x_{tot}` is the total tracer -mass +%feature("docstring") cmf_core::RainfallStation::__init__ "def +__init__(self, args, kwargs) -:math:`x_{free}` is the dissolved tracer mass +__init__(cmf::atmosphere::RainfallStation self, RainfallStation copy) +-> RainfallStation RainfallStation(const RainfallStation ©) copy +c'tor "; -:math:`m` is the mass of the sorbent in the same unit as the tracer mass +%feature("docstring") cmf_core::RainfallStation::__call__ "def +__call__(self, args, kwargs) -:math:`K` is the Henry sorption coefficient +__call__(RainfallStation self, Time t) -> double "; -:math:`c = \\\\frac{x_{free}}{V}` is the concentration of the tracer in -tracer mass per m3 +%feature("docstring") cmf_core::RainfallStation::__repr__ "def +__repr__(self, args, kwargs) -CMF stores in a solute storage the total mass of a tracer and needs to -calculate the free tracer mass. Calculating :math:`x_{free}` from :math:`x_{tot}` -gives from the eq. above: +__repr__(RainfallStation self) -> std::string std::string tostring() +const Returns the name and the mean yearly rainfall. "; -.. math:: +%feature("docstring") cmf_core::RainfallStation::create "def +create(args, kwargs) - x_{free} = x_{tot} \\\\frac{V}{K m + - V} +create(size_t Id, std::string Name, timeseries Data, point position) +-> cmf::atmosphere::RainfallStation::ptr "; -C++ includes: adsorption.h "; +%feature("docstring") cmf_core::RainfallStation::use_for_cell "def +use_for_cell(self, args, kwargs) -%feature("docstring") cmf::water::LinearAdsorption::LinearAdsorption -"LinearAdsorption(real K, real m) "; +use_for_cell(RainfallStation self, Cell c) void +use_for_cell(cmf::upslope::Cell &c) Connects a cell with this +rainfall station. "; -%feature("docstring") cmf::water::LinearAdsorption::LinearAdsorption -"LinearAdsorption(const LinearAdsorption &other) "; -%feature("docstring") cmf::water::LinearAdsorption::~LinearAdsorption -"virtual ~LinearAdsorption() "; +// File: classcmf_1_1atmosphere_1_1_rainfall_station_list.xml +%feature("docstring") cmf::atmosphere::RainfallStationList " -%feature("docstring") cmf::water::LinearAdsorption::copy "LinearAdsorption* copy(real m=-1) const +A list of rainfall stations. -returns a copy of the Adsorption object. +C++ includes: precipitation.h "; -If the adsorption is depending on the sorbent mass, you can give a -positive value for the sorbent mass m. If the value is not given or -negative, m is used from the original object. "; +%feature("docstring") cmf::atmosphere::RainfallStationList::add "RainfallStation::ptr add(std::string Name, cmf::math::timeseries Data, +cmf::geometry::point Position) -%feature("docstring") cmf::water::LinearAdsorption::freesolute "real -freesolute(real xt, real V) const +Creates a new RainfallStation and adds it to the list. -Returns the mass of dissolved tracer as a function of the total tracer -mass in the solute storage and the water volume. +Usage: The position of the rainfall station will be used as identifier +A new rainfall station Parameters: ----------- -xt: :math:`x_t` the total tracer mass in the storage +Name: Name of the station -V: :math:`V m^3` the water volume in the storage +Data: Rainfall timeseries -:math:`x_f` the dissolved mass of the tracer "; +Position: Spatial position of the new station "; -%feature("docstring") cmf::water::LinearAdsorption::totalsolute "real totalsolute(real xf, real V) const +%feature("docstring") cmf::atmosphere::RainfallStationList::remove "void remove(ptrdiff_t index) -Returns the total mass of the tracer from the dissolved concetration -in tracer unit/m3. +Removes the station at index from this list. "; -Parameters: ------------ +%feature("docstring") cmf::atmosphere::RainfallStationList::size "size_t size() const -xf: :math:`x_f` the dissolved tracer mass in the storage +Returns the number of rainfall stations. "; -V: :math:`V m^3` the water volume in the storage -:math:`x_t` the total mass of the tracer "; +// File: classcmf__core_1_1_rainfall_station_list.xml +%feature("docstring") cmf_core::RainfallStationList " +A list of rainfall stations. C++ includes: precipitation.h "; -// File: classcmf_1_1upslope_1_1_linear_retention.xml -%feature("docstring") cmf::upslope::LinearRetention " +%feature("docstring") cmf_core::RainfallStationList::__init__ "def +__init__(self, args, kwargs) -The linear retention curve provides a simple linear relationship -between storage and head. +__init__(cmf::atmosphere::RainfallStationList self) -> +RainfallStationList "; -Head function (head in m, calculated from upper side control volume) +%feature("docstring") cmf_core::RainfallStationList::__getitem__ "def __getitem__(self, args) +__getitem__(RainfallStationList self, ptrdiff_t index) -> +cmf::atmosphere::RainfallStation::ptr __getitem__(RainfallStationList +self, ptrdiff_t index) -> cmf::atmosphere::RainfallStation::ptr const +"; -.. math:: +%feature("docstring") cmf_core::RainfallStationList::__iter__ "def +__iter__(self) "; - h(\\\\theta) = -\\\\Delta z \\\\left( 1 - \\\\frac{\\\\theta - - \\\\theta_r}{\\\\theta_s - \\\\theta_r} \\\\right) +%feature("docstring") cmf_core::RainfallStationList::__len__ "def +__len__(self, args, kwargs) -Conductivity -function +__len__(RainfallStationList self) -> size_t size_t size() const +Returns the number of rainfall stations. "; -.. math:: +%feature("docstring") cmf_core::RainfallStationList::__repr__ "def +__repr__(self) "; - K(\\\\theta) = K_{sat} \\\\left(\\\\frac{\\\\theta - - \\\\theta_r}{\\\\theta_s - \\\\theta_r}\\\\right)^\\\\beta +%feature("docstring") cmf_core::RainfallStationList::add "def +add(self, args, kwargs) -C++ includes: RetentionCurve.h "; +add(RainfallStationList self, std::string Name, timeseries Data, point +Position) -> cmf::atmosphere::RainfallStation::ptr +RainfallStation::ptr add(std::string Name, cmf::math::timeseries Data, +cmf::geometry::point Position) Creates a new RainfallStation and adds +it to the list. Usage: The position of the rainfall station will be +used as identifier A new rainfall station Parameters: ----------- +Name: Name of the station Data: Rainfall timeseries Position: +Spatial position of the new station "; -%feature("docstring") cmf::upslope::LinearRetention::LinearRetention -"LinearRetention(real ksat, real phi, real thickness, real -residual_wetness=0.1) "; +%feature("docstring") cmf_core::RainfallStationList::remove "def +remove(self, args, kwargs) -%feature("docstring") cmf::upslope::LinearRetention::~LinearRetention -"virtual ~LinearRetention() "; +remove(RainfallStationList self, ptrdiff_t index) void +remove(ptrdiff_t index) Removes the station at index from this list. +"; -%feature("docstring") cmf::upslope::LinearRetention::copy "LinearRetention* copy() const "; -%feature("docstring") cmf::upslope::LinearRetention::Diffusivity "virtual real Diffusivity(real wetness) const +// File: classcmf_1_1atmosphere_1_1_rainfall_station_reference.xml +%feature("docstring") cmf::atmosphere::RainfallStationReference " -Returns the Diffusivity of the soil. +References a single RainfallStation to provide rainfall intensity +data. -Not implemented for all retention curves. Diffusivity is used by -MACROlikeMacroMicroExchange "; +C++ includes: precipitation.h "; -%feature("docstring") cmf::upslope::LinearRetention::Diffusivity "cmf::math::num_array Diffusivity(cmf::math::num_array &wetness) "; +%feature("docstring") cmf::atmosphere::RainfallStationReference::conc +"real conc(cmf::math::Time t, const cmf::water::solute &Solute) const + +Returns the concentration of a solute in [solute unit]/m3 at time t in +rainfall. "; + +%feature("docstring") +cmf::atmosphere::RainfallStationReference::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) + +Returns the connection between this and target. "; + +%feature("docstring") +cmf::atmosphere::RainfallStationReference::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; + +%feature("docstring") +cmf::atmosphere::RainfallStationReference::flux_to "real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) -%feature("docstring") cmf::upslope::LinearRetention::dPsiM_dW "virtual real dPsiM_dW(real wetness) const "; +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; -%feature("docstring") cmf::upslope::LinearRetention::dPsiM_dW "cmf::math::num_array dPsiM_dW(const cmf::math::num_array &wetness) -const "; +%feature("docstring") +cmf::atmosphere::RainfallStationReference::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) -%feature("docstring") cmf::upslope::LinearRetention::FillHeight "virtual real FillHeight(real lowerDepth, real Area, real Volume) const +Returns the sum of all flux vectors. "; -Returns the thickness of a soil column with a certain pore volume. "; +%feature("docstring") +cmf::atmosphere::RainfallStationReference::get_connections "cmf::water::connection_list get_connections() const "; -%feature("docstring") cmf::upslope::LinearRetention::K "cmf::math::num_array K(const cmf::math::num_array &wetness) const "; +%feature("docstring") +cmf::atmosphere::RainfallStationReference::get_intensity "real +get_intensity(cmf::math::Time t) const -%feature("docstring") cmf::upslope::LinearRetention::K "virtual real -K(real wetness) const +Returns the rainfall intensity in mm/day at time t. "; -Returns the conductivity in m/day at a certain depth and water -content. "; +%feature("docstring") +cmf::atmosphere::RainfallStationReference::get_potential "virtual +real get_potential() const -%feature("docstring") cmf::upslope::LinearRetention::MatricPotential -"cmf::math::num_array MatricPotential(const cmf::math::num_array -&wetness) const "; +Returns the water potential of the node in m waterhead. -%feature("docstring") cmf::upslope::LinearRetention::MatricPotential -"virtual real MatricPotential(real wetness) const +The base class water storage always returns the height of the location +"; -Returns the potential below upper side of the control volume in m. "; +%feature("docstring") +cmf::atmosphere::RainfallStationReference::get_project "cmf::project& +get_project() const -%feature("docstring") cmf::upslope::LinearRetention::Porosity "virtual real Porosity(real depth) const +Returns the project, this node is part of. "; -Returns the porosity at a certain depth. "; +%feature("docstring") +cmf::atmosphere::RainfallStationReference::is_empty "virtual double +is_empty() const -%feature("docstring") cmf::upslope::LinearRetention::theta "virtual -real theta(real wetness) const +Returns false. "; -returns the water content :math:`theta` for a given wetness "; +%feature("docstring") +cmf::atmosphere::RainfallStationReference::is_storage "virtual bool +is_storage() const -%feature("docstring") cmf::upslope::LinearRetention::theta "cmf::math::num_array theta(const cmf::math::num_array &wetness) const -"; +true, if this is a waterstorage "; -%feature("docstring") cmf::upslope::LinearRetention::Transmissivity "virtual real Transmissivity(real upperDepth, real lowerDepth, real -wetness) const "; +%feature("docstring") +cmf::atmosphere::RainfallStationReference::RecalcFluxes "virtual bool +RecalcFluxes(cmf::math::Time t) -%feature("docstring") cmf::upslope::LinearRetention::VoidVolume "virtual real VoidVolume(real upperDepth, real lowerDepth, real Area) -const +Pure flux_nodes do not influence fluxes, therefore no recalculation of +fluxes is required by flux_node. -Returns the void volume of a soil column. "; +WaterStorage overrides this, since state changes require an update of +the fluxes "; -%feature("docstring") cmf::upslope::LinearRetention::Wetness "cmf::math::num_array Wetness(const cmf::math::num_array &suction) -const "; +%feature("docstring") +cmf::atmosphere::RainfallStationReference::remove_connection "bool +remove_connection(cmf::water::flux_node::ptr To) -%feature("docstring") cmf::upslope::LinearRetention::Wetness "virtual real Wetness(real suction) const +Remove the connection. "; -Returns the wetness (water content per pore volume) at a given head. -"; +%feature("docstring") +cmf::atmosphere::RainfallStationReference::set_potential "virtual +void set_potential(real new_potential) -%feature("docstring") cmf::upslope::LinearRetention::Wetness_eff "virtual real Wetness_eff(real wetness, real pF_r=4.2) const +Sets the potential of this flux node. "; -Returns the effective wetness, using a residual pF value +%feature("docstring") +cmf::atmosphere::RainfallStationReference::to_string "virtual +std::string to_string() const "; -.. math:: +%feature("docstring") +cmf::atmosphere::RainfallStationReference::waterbalance "real +waterbalance(cmf::math::Time t, const flux_connection *Without=0) +const - w_{eff} - = - \\\\frac{w_{act}-w\\\\left(pF_r\\\\right)}{1-w\\\\left(pF_r\\\\right)} +Returns the sum of all fluxes (positive and negative) at time t. -. -"; +Single fluxes can be excluded from the calculation -%feature("docstring") cmf::upslope::LinearRetention::Wetness_pF "real Wetness_pF(real pF) const +Parameters: +----------- -returns the volumetric water content at a given pF value "; +t: Time of the query -%feature("docstring") cmf::upslope::LinearRetention::Wetness_pF "cmf::math::num_array Wetness_pF(const cmf::math::num_array &pF) const -"; +Without: A flux_connection that is excluded from the waterbalance +(e.g. to prevent closed circuits) "; -// File: classcmf_1_1water_1_1_linear_storage_connection.xml -%feature("docstring") cmf::water::LinearStorageConnection " +// File: classcmf__core_1_1_rainfall_station_reference.xml +%feature("docstring") cmf_core::RainfallStationReference " -Calculates flux out of a storage as a linear function of its volume. +References a single RainfallStation to provide rainfall intensity +data. C++ includes: precipitation.h "; -This connection serves the same purpose as the old kinematic_wave -connection, but the parameters are easier to explain +%feature("docstring") cmf_core::RainfallStationReference::__init__ "def __init__(self, args, kwargs) "; +%feature("docstring") cmf_core::RainfallStationReference::__call__ "def __call__(self, args, kwargs) +__call__(RainSource self, Time t) -> real "; -.. math:: +%feature("docstring") cmf_core::RainfallStationReference::__eq__ "def __eq__(self, args, kwargs) - q = \\\\frac{V - V_{residual}}{t_r} +__eq__(flux_node self, flux_node other) -> bool "; -where: :math:`V` The actual -volume of water stored in source +%feature("docstring") cmf_core::RainfallStationReference::__repr__ "def __repr__(self) "; -:math:`V_{residual} [m^3]` The volume of water not flowing out (default = 0) -:math:`t_r` is the residence time in the source. +%feature("docstring") cmf_core::RainfallStationReference::conc "def +conc(self, args, kwargs) -C++ includes: simple_connections.h "; +conc(flux_node self, Time t, solute Solute) -> real virtual real +conc(cmf::math::Time t, const cmf::water::solute &Solute) const +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; %feature("docstring") -cmf::water::LinearStorageConnection::LinearStorageConnection "LinearStorageConnection(WaterStorage::ptr source, flux_node::ptr -target, real residencetime, real residual=0.0) +cmf_core::RainfallStationReference::connected_nodes "def +connected_nodes(self) "; -Creates a linear storage connection or Nash-box. +%feature("docstring") +cmf_core::RainfallStationReference::connection_to "def +connection_to(self, args, kwargs) +connection_to(flux_node self, flux_node target) -> flux_connection +cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) Returns the connection between this and target. "; +%feature("docstring") cmf_core::RainfallStationReference::flux3d_to "def flux3d_to(self, args, kwargs) -.. math:: +flux3d_to(flux_node self, flux_node target, Time t) -> point +cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; - q = \\\\frac{V - V_{residual}}{t_r}} +%feature("docstring") cmf_core::RainfallStationReference::flux_to "def flux_to(self, args, kwargs) -Parameters: ------------ +flux_to(flux_node self, flux_node target, Time t) -> real real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; -source: Water storage from which the water flows out. Flux is a -function of source.volume +%feature("docstring") cmf_core::RainfallStationReference::fluxes "def fluxes(self, t) "; -target: Target node (boundary condition or storage). Does not -influence the strength of the flow +%feature("docstring") +cmf_core::RainfallStationReference::from_nearest_station "def +from_nearest_station(args, kwargs) -residencetime: :math:`t_r [days]` The residence time of the water in this -storage +from_nearest_station(project project, point position, double z_weight) +-> cmf::atmosphere::RainfallStationReference::ptr "; -residual: :math:`V_{residual} [m^3]` The volume of water not flowing out -(default = 0) "; +%feature("docstring") +cmf_core::RainfallStationReference::from_station_id "def +from_station_id(args, kwargs) -%feature("docstring") cmf::water::LinearStorageConnection::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) +from_station_id(project project, point position, size_t id) -> +cmf::atmosphere::RainfallStationReference::ptr "; -Returns the concentration of the flux. +%feature("docstring") cmf_core::RainfallStationReference::get_3d_flux +"def get_3d_flux(self, args, kwargs) -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +get_3d_flux(flux_node self, Time t) -> point cmf::geometry::point +get_3d_flux(cmf::math::Time t) Returns the sum of all flux vectors. +"; %feature("docstring") -cmf::water::LinearStorageConnection::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +cmf_core::RainfallStationReference::get_intensity "def +get_intensity(self, args, kwargs) -%feature("docstring") cmf::water::LinearStorageConnection::get_ptr "ptr get_ptr() const "; +get_intensity(RainSource self, Time t) -> real virtual real +get_intensity(cmf::math::Time t) const =0 Returns the actual rainfall +intensity in mm/day. "; -%feature("docstring") cmf::water::LinearStorageConnection::get_target -"flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") cmf_core::RainfallStationReference::is_empty "def is_empty(self, args, kwargs) -Returns the other end of a connection than the asking end. "; +is_empty(flux_node self) -> double virtual double is_empty() const +Returns true if the node has no water. "; -%feature("docstring") cmf::water::LinearStorageConnection::get_target -"flux_node::ptr get_target(int index) const +%feature("docstring") cmf_core::RainfallStationReference::is_storage +"def is_storage(self, args, kwargs) -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +is_storage(flux_node self) -> bool virtual bool is_storage() const +true, if this is a waterstorage "; %feature("docstring") -cmf::water::LinearStorageConnection::get_tracer_filter "real -get_tracer_filter() - -A value ranging from 0 to 1 to filter tracers out of the water flux. +cmf_core::RainfallStationReference::RecalcFluxes "def +RecalcFluxes(self, args, kwargs) -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +RecalcFluxes(flux_node self, Time t) -> bool virtual bool +RecalcFluxes(cmf::math::Time t) Pure flux_nodes do not influence +fluxes, therefore no recalculation of fluxes is required by flux_node. +WaterStorage overrides this, since state changes require an update of +the fluxes "; %feature("docstring") -cmf::water::LinearStorageConnection::get_tracer_filter "real -get_tracer_filter(solute S) +cmf_core::RainfallStationReference::remove_connection "def +remove_connection(self, args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +remove_connection(flux_node self, cmf::water::flux_node::ptr To) -> +bool bool remove_connection(cmf::water::flux_node::ptr To) Remove +the connection. "; -%feature("docstring") cmf::water::LinearStorageConnection::kill_me "bool kill_me() +%feature("docstring") cmf_core::RainfallStationReference::to_string "def to_string(self, args, kwargs) -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +to_string(flux_node self) -> std::string virtual std::string +to_string() const "; -%feature("docstring") cmf::water::LinearStorageConnection::left_node -"flux_node::ptr left_node() const +%feature("docstring") +cmf_core::RainfallStationReference::waterbalance "def +waterbalance(self, args, kwargs) -Returns the left node of this connection. "; +waterbalance(flux_node self, Time t, flux_connection Without=None) -> +real real waterbalance(cmf::math::Time t, const flux_connection +*Without=0) const Returns the sum of all fluxes (positive and +negative) at time t. Single fluxes can be excluded from the +calculation Parameters: ----------- t: Time of the query Without: +A flux_connection that is excluded from the waterbalance (e.g. to +prevent closed circuits) "; -%feature("docstring") cmf::water::LinearStorageConnection::q "real -q(const flux_node &inquirer, cmf::math::Time t) -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +// File: classcmf__core_1_1_rain_source.xml +%feature("docstring") cmf_core::RainSource " -%feature("docstring") cmf::water::LinearStorageConnection::refresh "void refresh(cmf::math::Time t) +An abstract class for different types of rainfall sources. C++ +includes: precipitation.h "; -Performes a new calculation of the flux. "; +%feature("docstring") cmf_core::RainSource::__init__ "def +__init__(self, args, kwargs) "; -%feature("docstring") cmf::water::LinearStorageConnection::right_node -"flux_node::ptr right_node() const +%feature("docstring") cmf_core::RainSource::__call__ "def +__call__(self, args, kwargs) -returns the right node of this connection "; +__call__(RainSource self, Time t) -> real "; -%feature("docstring") -cmf::water::LinearStorageConnection::set_tracer_filter "void -set_tracer_filter(real value) +%feature("docstring") cmf_core::RainSource::__eq__ "def __eq__(self, +args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. +__eq__(flux_node self, flux_node other) -> bool "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::RainSource::__repr__ "def +__repr__(self) "; -%feature("docstring") -cmf::water::LinearStorageConnection::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; +%feature("docstring") cmf_core::RainSource::conc "def conc(self, +args, kwargs) -%feature("docstring") -cmf::water::LinearStorageConnection::short_string "virtual -std::string short_string() const "; +conc(flux_node self, Time t, solute Solute) -> real virtual real +conc(cmf::math::Time t, const cmf::water::solute &Solute) const +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; -%feature("docstring") cmf::water::LinearStorageConnection::to_string -"virtual std::string to_string() const "; +%feature("docstring") cmf_core::RainSource::connected_nodes "def +connected_nodes(self) "; +%feature("docstring") cmf_core::RainSource::connection_to "def +connection_to(self, args, kwargs) -// File: classcmf_1_1atmosphere_1_1log__wind__profile.xml -%feature("docstring") cmf::atmosphere::log_wind_profile " +connection_to(flux_node self, flux_node target) -> flux_connection +cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) Returns the connection between this and target. "; -, A logarithmic wind profile +%feature("docstring") cmf_core::RainSource::flux3d_to "def +flux3d_to(self, args, kwargs) -Todo Cite literature for this windprofile and insert equation +flux3d_to(flux_node self, flux_node target, Time t) -> point +cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; -C++ includes: ET.h "; +%feature("docstring") cmf_core::RainSource::flux_to "def +flux_to(self, args, kwargs) -%feature("docstring") -cmf::atmosphere::log_wind_profile::log_wind_profile "log_wind_profile(cmf::upslope::Cell &_cell) "; +flux_to(flux_node self, flux_node target, Time t) -> real real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; -%feature("docstring") -cmf::atmosphere::log_wind_profile::~log_wind_profile "virtual -~log_wind_profile() "; +%feature("docstring") cmf_core::RainSource::fluxes "def fluxes(self, +t) "; -%feature("docstring") -cmf::atmosphere::log_wind_profile::get_aerodynamic_resistance "virtual void get_aerodynamic_resistance(double &r_ag, double &r_ac, -cmf::math::Time t) const +%feature("docstring") cmf_core::RainSource::get_3d_flux "def +get_3d_flux(self, args, kwargs) -aerodynamic resistance from ground to atmosphere (r_ag) and from -canopy to atmosphere (r_ac) "; +get_3d_flux(flux_node self, Time t) -> point cmf::geometry::point +get_3d_flux(cmf::math::Time t) Returns the sum of all flux vectors. +"; +%feature("docstring") cmf_core::RainSource::get_intensity "def +get_intensity(self, args, kwargs) -// File: classcmf_1_1upslope_1_1connections_1_1_m_a_c_r_olike_macro_micro_exchange.xml -%feature("docstring") -cmf::upslope::connections::MACROlikeMacroMicroExchange " +get_intensity(RainSource self, Time t) -> real virtual real +get_intensity(cmf::math::Time t) const =0 Returns the actual rainfall +intensity in mm/day. "; -This connection models the water exchange between macropores and -micropores as in the MACRO Model (Larsbo & Jarvis, 2003), which -follows Gerke & van Genuchten 1996. +%feature("docstring") cmf_core::RainSource::is_empty "def +is_empty(self, args, kwargs) -WARNING: Deprecated This connection uses the diffusivity of a soil -given by its retention curve. Since no retention curve provides a -valid value for Diffusivity in case of saturation this connection will -blow up the numerical solution for sure. +is_empty(flux_node self) -> double virtual double is_empty() const +Returns true if the node has no water. "; -The exchange between Macropore and matrix is defined as follows: -(MACRO 5 Tech report, Larsbo & Jarvis 2003) +%feature("docstring") cmf_core::RainSource::is_storage "def +is_storage(self, args, kwargs) +is_storage(flux_node self) -> bool virtual bool is_storage() const +true, if this is a waterstorage "; +%feature("docstring") cmf_core::RainSource::RecalcFluxes "def +RecalcFluxes(self, args, kwargs) -.. math:: +RecalcFluxes(flux_node self, Time t) -> bool virtual bool +RecalcFluxes(cmf::math::Time t) Pure flux_nodes do not influence +fluxes, therefore no recalculation of fluxes is required by flux_node. +WaterStorage overrides this, since state changes require an update of +the fluxes "; - q = \\\\frac{G_f D_w \\\\gamma_w}{d^2}(\\\\theta_b - - \\\\theta_{mi}) V_{layer} +%feature("docstring") cmf_core::RainSource::remove_connection "def +remove_connection(self, args, kwargs) -where: :math:`G_f` is the geometry factor. -Use 3 for a rectangular slab geometry +remove_connection(flux_node self, cmf::water::flux_node::ptr To) -> +bool bool remove_connection(cmf::water::flux_node::ptr To) Remove +the connection. "; -:math:`gamma_w` A scaling factor to fit analytical and numerical solution -(0.4) +%feature("docstring") cmf_core::RainSource::to_string "def +to_string(self, args, kwargs) + +to_string(flux_node self) -> std::string virtual std::string +to_string() const "; + +%feature("docstring") cmf_core::RainSource::waterbalance "def +waterbalance(self, args, kwargs) + +waterbalance(flux_node self, Time t, flux_connection Without=None) -> +real real waterbalance(cmf::math::Time t, const flux_connection +*Without=0) const Returns the sum of all fluxes (positive and +negative) at time t. Single fluxes can be excluded from the +calculation Parameters: ----------- t: Time of the query Without: +A flux_connection that is excluded from the waterbalance (e.g. to +prevent closed circuits) "; -:math:`d` is an effective diffusive path length related to aggregate size -and the influence of coatings on the aggregate surfaces in m -:math:`\\\\theta_b` the saturated water content of the matrix +// File: classcmf_1_1atmosphere_1_1_rain_source.xml +%feature("docstring") cmf::atmosphere::RainSource " -:math:`\\\\theta_{mi}` the actual water content of the matrix +An abstract class for different types of rainfall sources. -:math:`D_w = \\\\frac12(D(\\\\theta_b)+D(\\\\theta_{mi})W_{ma})` is the -effective water diffusivity in m2/day, as defined below :math:`W_{ma}` is -the saturation of the macropores +C++ includes: precipitation.h "; -C++ includes: macropore.h "; +%feature("docstring") cmf::atmosphere::RainSource::conc "virtual +real conc(cmf::math::Time t, const cmf::water::solute &Solute) const +=0 -%feature("docstring") -cmf::upslope::connections::MACROlikeMacroMicroExchange::MACROlikeMacroMicroExchange -"MACROlikeMacroMicroExchange(cmf::upslope::SoilLayer::ptr left, -cmf::upslope::MacroPore::ptr right, real _gamma_w=0.4, real _Gf=3) "; +Returns the concentration of a solute in the rainfall at time t. "; -%feature("docstring") -cmf::upslope::connections::MACROlikeMacroMicroExchange::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +%feature("docstring") cmf::atmosphere::RainSource::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) -Returns the concentration of the flux. +Returns the connection between this and target. "; -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +%feature("docstring") cmf::atmosphere::RainSource::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; -%feature("docstring") -cmf::upslope::connections::MACROlikeMacroMicroExchange::exchange_target -"void exchange_target(flux_node::ptr oldtarget, flux_node::ptr -newTarget) "; +%feature("docstring") cmf::atmosphere::RainSource::flux_to "real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) -%feature("docstring") -cmf::upslope::connections::MACROlikeMacroMicroExchange::get_ptr "ptr -get_ptr() const "; +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; -%feature("docstring") -cmf::upslope::connections::MACROlikeMacroMicroExchange::get_target "flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") cmf::atmosphere::RainSource::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) -Returns the other end of a connection than the asking end. "; +Returns the sum of all flux vectors. "; -%feature("docstring") -cmf::upslope::connections::MACROlikeMacroMicroExchange::get_target "flux_node::ptr get_target(int index) const +%feature("docstring") cmf::atmosphere::RainSource::get_connections "cmf::water::connection_list get_connections() const "; -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +%feature("docstring") cmf::atmosphere::RainSource::get_intensity "virtual real get_intensity(cmf::math::Time t) const =0 -%feature("docstring") -cmf::upslope::connections::MACROlikeMacroMicroExchange::get_tracer_filter -"real get_tracer_filter() +Returns the actual rainfall intensity in mm/day. "; -A value ranging from 0 to 1 to filter tracers out of the water flux. +%feature("docstring") cmf::atmosphere::RainSource::get_potential "virtual real get_potential() const -1.0 is no filter and 0.0 means no solute is crossing this connection +Returns the water potential of the node in m waterhead. + +The base class water storage always returns the height of the location "; -%feature("docstring") -cmf::upslope::connections::MACROlikeMacroMicroExchange::get_tracer_filter -"real get_tracer_filter(solute S) +%feature("docstring") cmf::atmosphere::RainSource::get_project "cmf::project& get_project() const -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +Returns the project, this node is part of. "; -%feature("docstring") -cmf::upslope::connections::MACROlikeMacroMicroExchange::kill_me "bool -kill_me() +%feature("docstring") cmf::atmosphere::RainSource::is_empty "virtual +double is_empty() const -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +Returns false. "; -%feature("docstring") -cmf::upslope::connections::MACROlikeMacroMicroExchange::left_node "flux_node::ptr left_node() const +%feature("docstring") cmf::atmosphere::RainSource::is_storage "virtual bool is_storage() const -Returns the left node of this connection. "; +true, if this is a waterstorage "; -%feature("docstring") -cmf::upslope::connections::MACROlikeMacroMicroExchange::q "real -q(const flux_node &inquirer, cmf::math::Time t) +%feature("docstring") cmf::atmosphere::RainSource::RecalcFluxes "virtual bool RecalcFluxes(cmf::math::Time t) -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +Pure flux_nodes do not influence fluxes, therefore no recalculation of +fluxes is required by flux_node. -%feature("docstring") -cmf::upslope::connections::MACROlikeMacroMicroExchange::refresh "void -refresh(cmf::math::Time t) +WaterStorage overrides this, since state changes require an update of +the fluxes "; -Performes a new calculation of the flux. "; +%feature("docstring") cmf::atmosphere::RainSource::remove_connection +"bool remove_connection(cmf::water::flux_node::ptr To) -%feature("docstring") -cmf::upslope::connections::MACROlikeMacroMicroExchange::right_node "flux_node::ptr right_node() const +Remove the connection. "; -returns the right node of this connection "; +%feature("docstring") cmf::atmosphere::RainSource::set_potential "virtual void set_potential(real new_potential) -%feature("docstring") -cmf::upslope::connections::MACROlikeMacroMicroExchange::set_tracer_filter -"void set_tracer_filter(real value) +Sets the potential of this flux node. "; -A value ranging from 0 to 1 to filter tracers out of the water flux. +%feature("docstring") cmf::atmosphere::RainSource::to_string "virtual std::string to_string() const "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf::atmosphere::RainSource::waterbalance "real waterbalance(cmf::math::Time t, const flux_connection *Without=0) +const -%feature("docstring") -cmf::upslope::connections::MACROlikeMacroMicroExchange::set_tracer_filter -"void set_tracer_filter(solute S, real value) "; +Returns the sum of all fluxes (positive and negative) at time t. -%feature("docstring") -cmf::upslope::connections::MACROlikeMacroMicroExchange::short_string "virtual std::string short_string() const "; +Single fluxes can be excluded from the calculation -%feature("docstring") -cmf::upslope::connections::MACROlikeMacroMicroExchange::to_string "virtual std::string to_string() const "; +Parameters: +----------- +t: Time of the query -// File: classcmf_1_1upslope_1_1_macro_pore.xml -%feature("docstring") cmf::upslope::MacroPore " +Without: A flux_connection that is excluded from the waterbalance +(e.g. to prevent closed circuits) "; -An additional water storage for a soil layer to model matrix water and -macro pore water seperately. -Deprecated The MacroPore model is still very experimental and not -stable. Only for tryouts! +// File: classcmf_1_1river_1_1_reach.xml +%feature("docstring") cmf::river::Reach " -If present, the soil layer water storage holds the matrix water and -the MacroPore holds the water in the macro pore. Use -cmf::upslope::Macropore::create to create a macropore storage. +A reach represents the section of a riover and is a specialization of +an open water storage. -Use cmf::upslope::connections::GradientMacroFlow or -cmf::upslope::connections::KinematicMacroFlow to model water flow -between macro pores and a lateral connection ( lateral subsurface -fluxes) like cmf::upslope::connections::Richards_lateral to connect -the macro pore with the matrix. +The OpenWaterStorage attributes and methods are extended by +topological features, for the creation of a network of reaches. -C++ includes: macropore.h "; +C++ includes: Reach.h "; /* Overrides of flux_node */ -%feature("docstring") cmf::upslope::MacroPore::RecalcFluxes "virtual -bool RecalcFluxes(cmf::math::Time t) +%feature("docstring") cmf::river::Reach::RecalcFluxes "virtual bool +RecalcFluxes(cmf::math::Time t) Pure flux_nodes do not influence fluxes, therefore no recalculation of fluxes is required by flux_node. @@ -8177,223 +25614,236 @@ fluxes is required by flux_node. WaterStorage overrides this, since state changes require an update of the fluxes "; -%feature("docstring") cmf::upslope::MacroPore::is_empty "virtual -double is_empty() const +%feature("docstring") cmf::river::Reach::is_empty "virtual double +is_empty() const Returns true if the node has no water. "; -%feature("docstring") cmf::upslope::MacroPore::to_string "virtual +%feature("docstring") cmf::river::Reach::to_string "virtual std::string to_string() const "; -%feature("docstring") cmf::upslope::MacroPore::conc "real conc(const -cmf::water::solute &_Solute) const - -Returns the concentration of the given solute. "; +%feature("docstring") cmf::river::Reach::~Reach "virtual ~Reach() "; -%feature("docstring") cmf::upslope::MacroPore::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) const +%feature("docstring") cmf::river::Reach::add_connected_states "virtual void add_connected_states(cmf::math::StateVariable::list +&states) "; -Returns the current WaterQuality (concentration of all solutes) "; +%feature("docstring") cmf::river::Reach::conc "real +conc(cmf::math::Time t, const cmf::water::solute &solute) const -%feature("docstring") cmf::upslope::MacroPore::conc "void conc(const -cmf::water::solute &_Solute, real NewConcetration) +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; -Sets a new concentration. "; +%feature("docstring") cmf::river::Reach::conc "real conc(const +cmf::water::solute &_Solute) const -%feature("docstring") cmf::upslope::MacroPore::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node -&target) +Returns the concentration of the given solute. "; -Returns the connection between this and target. "; +%feature("docstring") cmf::river::Reach::conc "void conc(const +cmf::water::solute &_Solute, real NewConcetration) -%feature("docstring") cmf::upslope::MacroPore::dxdt "virtual real -dxdt(const cmf::math::Time &time) +Sets a new concentration. "; -Returns the derivate of the state variable at time time. "; +%feature("docstring") cmf::river::Reach::connect_to_surfacewater "void connect_to_surfacewater(cmf::upslope::Cell *cell, real width, +bool diffusive) -%feature("docstring") cmf::upslope::MacroPore::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, -cmf::math::Time t) "; +Connects the surfacewater of a cell with this reach. -%feature("docstring") cmf::upslope::MacroPore::flux_to "real -flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +Parameters: +----------- -Returns the actual flux between this and target (positive sign means -\"from this into target\") "; +cell: The cell with the surface water to be connected with this reach -%feature("docstring") cmf::upslope::MacroPore::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) +width: The flow width from cell to this reach -Returns the sum of all flux vectors. "; +diffusive: If diffusive is false, a ManningKinematic connection is +used, else a ManningDiffusive connection "; -%feature("docstring") cmf::upslope::MacroPore::get_abs_errtol "virtual real get_abs_errtol(real rel_errtol) const "; +%feature("docstring") cmf::river::Reach::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) -%feature("docstring") cmf::upslope::MacroPore::get_capacity "real -get_capacity() const +Returns the connection between this and target. "; -Returns the capacity of the macropores in m3. +%feature("docstring") cmf::river::Reach::distance_to_cell "double +distance_to_cell(cmf::upslope::Cell *cell) const +Returns the distance (d) for connections between this reach and a +cell. +If the effective inner cell distance (defined as :math:`R_{Cell} = 0.5\\\\frac{\\\\sqrt{A}}{\\\\pi}`) is smaller than the distance +between the center points, the cell radius is returned "; -.. math:: +%feature("docstring") cmf::river::Reach::dxdt "virtual real +dxdt(const cmf::math::Time &time) "; - V_{max} = \\\\Phi_{macro} A \\\\Delta z +%feature("docstring") cmf::river::Reach::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; -where: :math:`V_{max}` is -the water capacity of the macropore +%feature("docstring") cmf::river::Reach::flux_to "real flux_to(const +cmf::water::flux_node &target, cmf::math::Time t) -:math:`\\\\Phi_{macro}` is the fraction of macro pores in the soil in :math:`m^3 macro pores/m^3 soil` +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; -:math:`A \\\\Delta z` is the total volume of the soil layer (including all -pores) in :math:`m^3` "; +%feature("docstring") cmf::river::Reach::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) -%feature("docstring") cmf::upslope::MacroPore::get_cell "cmf::upslope::Cell& get_cell() const +Returns the sum of all flux vectors. "; -The cell of this macropore. "; +%feature("docstring") cmf::river::Reach::get_abs_errtol "real +get_abs_errtol(real rel_errtol) const "; -%feature("docstring") cmf::upslope::MacroPore::get_connections "cmf::water::connection_list get_connections() const "; +%feature("docstring") cmf::river::Reach::get_connections "cmf::water::connection_list get_connections() const "; -%feature("docstring") cmf::upslope::MacroPore::get_crackwidth "virtual real get_crackwidth() const +%feature("docstring") cmf::river::Reach::get_depth "real get_depth() +const -Returns the crack width for a prismatic crackstructure. +Returns the water table depth. "; -For a prismatic crack structure, the porefraction in m3/m3 equals the -vertical crack area in m2/m2. The length of equally spaced cracks is -in one direction the inverse of the density and twice the length for -two directions. +%feature("docstring") cmf::river::Reach::get_diffusive "bool +get_diffusive() const -.. math:: +Returns if flow is calculated using a diffusive wave model. "; - l_{crack} [m/m^2]= 2 \\\\frac {1}{d[m]} +%feature("docstring") cmf::river::Reach::get_downstream "cmf::water::flux_node::ptr get_downstream() const -If -we again ignore the fact that the spacing of the cracking crossings is -counted double, the crack width is: +Returns the reach downstream of this (or null if there is no reach +downstream) "; -.. math:: +%feature("docstring") cmf::river::Reach::get_height_function "virtual const IVolumeHeightFunction& get_height_function() const - w_{crack}[m] = - \\\\frac{A_{crack}[m^2/m^2]}{l_{crack}[m/m^2]} +The functional relation between volume, depth and exposed area. "; -Combining both -eq. above: +%feature("docstring") cmf::river::Reach::get_length "real +get_length() const -.. math:: +Returns the length of the reach. "; - w_{crack}[m] = A_{crack}[m^2/m^2]\\\\frac{d[m]}{2} - +%feature("docstring") cmf::river::Reach::get_potential "virtual real +get_potential() const + +Returns the water potential of the node in m waterhead. +The base class water storage always returns the height of the location "; -%feature("docstring") cmf::upslope::MacroPore::get_filled_fraction "real get_filled_fraction() const +%feature("docstring") cmf::river::Reach::get_project "cmf::project& +get_project() const -Get the relative water content in the macro pore :math:`\\\\theta_{macro} = V_{macro}/V_{max}`. "; +Returns the project, this node is part of. "; -%feature("docstring") cmf::upslope::MacroPore::get_flowwidth "real -get_flowwidth() const +%feature("docstring") cmf::river::Reach::get_reachtype "Channel +get_reachtype() const -The approximate length of the aggregate boundaries. +Returns the channel shape. "; +%feature("docstring") cmf::river::Reach::get_root "ptr get_root() +Returns the reach most downstream from this reach. "; -.. math:: +%feature("docstring") cmf::river::Reach::get_state "real get_state() +const "; - l = \\\\frac{2}{d_{macro}} A +%feature("docstring") cmf::river::Reach::get_state_variable_content "char get_state_variable_content() const -where: :math:`l` is the length of -the aggregate boundaries (in m) +A character indicating the integrated variable (either 'V' for Volume +or 'h' for head) "; -:math:`2` is the number of directions +%feature("docstring") cmf::river::Reach::get_states "cmf::math::StateVariableList get_states() -:math:`d_{macro}` is the mean distance between macropores (density) in m +Add the state variables, owned by an object derived from +StateVariableOwner, to the given vector. "; -:math:`A` is the area of the cell "; +%feature("docstring") cmf::river::Reach::get_upstream "ptr +get_upstream(int index) const -%feature("docstring") cmf::upslope::MacroPore::get_K "virtual real -get_K() const +Returns a reach upstream of this. "; -Returns the actual conductivity. "; +%feature("docstring") cmf::river::Reach::get_volume "virtual real +get_volume() const -%feature("docstring") cmf::upslope::MacroPore::get_K "virtual real -get_K(cmf::geometry::point direction) const +Returns the volume of water in this storage in m3 "; -Returns the actual anisotropic conductivity along a direction :math:`K = (k_f \\\\cdot d) K`. "; +%feature("docstring") cmf::river::Reach::get_width "real get_width() +const -%feature("docstring") cmf::upslope::MacroPore::get_layer "SoilLayer::ptr get_layer() const +Returns the average width of the reach. "; -Gets the soil layer (matrix water storage) for this macropore storage. -"; +%feature("docstring") cmf::river::Reach::is_connected "virtual bool +is_connected(const cmf::math::StateVariable &other) const -%feature("docstring") cmf::upslope::MacroPore::get_porefraction "real get_porefraction() const +Returns True if this waterstorage is effected by another state. "; -The fraction of the macro pores in m3/m3. This adds to the porosity of -the layer. "; +%feature("docstring") cmf::river::Reach::is_storage "virtual bool +is_storage() const -%feature("docstring") cmf::upslope::MacroPore::get_potential "real -get_potential() const +Returns true, since this is a storage. "; -Returns the actual water level in the macropore in m above reference. -"; +%feature("docstring") cmf::river::Reach::remove_connection "bool +remove_connection(cmf::water::flux_node::ptr To) -%feature("docstring") cmf::upslope::MacroPore::get_project "cmf::project& get_project() const +Remove the connection. "; -Returns the project, this node is part of. "; +%feature("docstring") cmf::river::Reach::set_dead_end "void +set_dead_end() -%feature("docstring") cmf::upslope::MacroPore::get_state "real -get_state() const "; +Deletes any downstream connection. "; -%feature("docstring") -cmf::upslope::MacroPore::get_state_variable_content "char -get_state_variable_content() const +%feature("docstring") cmf::river::Reach::set_depth "void +set_depth(real new_depth) "; -A character indicating the integrated variable (either 'V' for Volume -or 'h' for head) "; +%feature("docstring") cmf::river::Reach::set_diffusive "void +set_diffusive(bool use_diffusive_wave) -%feature("docstring") cmf::upslope::MacroPore::get_states "cmf::math::StateVariableList get_states() +Sets all Manning kind connections to either diffusive or kinematic. "; -Add the state variables, owned by an object derived from -StateVariableOwner, to the given vector. "; +%feature("docstring") cmf::river::Reach::set_downstream "void +set_downstream(ptr new_downstream, bool use_meanchannel=false) -%feature("docstring") cmf::upslope::MacroPore::get_volume "real -get_volume() const +Connects the reach to another one downstream. "; -Returns the actual stored volume in this macropore in m3. "; +%feature("docstring") cmf::river::Reach::set_height_function "virtual void set_height_function(const IVolumeHeightFunction &val) "; -%feature("docstring") cmf::upslope::MacroPore::is_storage "virtual -bool is_storage() const +%feature("docstring") cmf::river::Reach::set_height_function "void +set_height_function(const IChannel &val) -Returns true, since this is a storage. "; +Sets the channel shape. "; -%feature("docstring") cmf::upslope::MacroPore::remove_connection "bool remove_connection(cmf::water::flux_node::ptr To) +%feature("docstring") cmf::river::Reach::set_outlet "void +set_outlet(cmf::water::flux_node::ptr outlet) -Remove the connection. "; +Connects the reach to an outlet, e.g. a boundary condition. "; -%feature("docstring") cmf::upslope::MacroPore::set_potential "void -set_potential(real waterhead) +%feature("docstring") cmf::river::Reach::set_potential "virtual void +set_potential(real newpotential) -Sets the water level in the macropore. Be aware of not setting it -below the lower boundary. "; +Sets the potential of this flux node. "; -%feature("docstring") cmf::upslope::MacroPore::set_state "void +%feature("docstring") cmf::river::Reach::set_state "void set_state(real newState) "; -%feature("docstring") -cmf::upslope::MacroPore::set_state_variable_content "void -set_state_variable_content(char content) +%feature("docstring") cmf::river::Reach::set_state_variable_content "void set_state_variable_content(char content) A character indicating the integrated variable (either 'V' for Volume or 'h' for head) "; -%feature("docstring") cmf::upslope::MacroPore::set_volume "void -set_volume(real volume) +%feature("docstring") cmf::river::Reach::set_volume "virtual void +set_volume(real newwatercontent) -Sets the volume of stored water in m3. "; +Sets the volume of water in this storage in m3 "; -%feature("docstring") cmf::upslope::MacroPore::Solute "SoluteStorage& Solute(const cmf::water::solute _Solute) +%feature("docstring") cmf::river::Reach::Solute "SoluteStorage& +Solute(const cmf::water::solute _Solute) Returns the water quality of the water storage. "; -%feature("docstring") cmf::upslope::MacroPore::Solute "const +%feature("docstring") cmf::river::Reach::Solute "const SoluteStorage& Solute(const cmf::water::solute _Solute) const "; -%feature("docstring") cmf::upslope::MacroPore::waterbalance "real +%feature("docstring") cmf::river::Reach::upstream_count "int +upstream_count() const + +Returns the number of reaches upstream of this. "; + +%feature("docstring") cmf::river::Reach::waterbalance "real waterbalance(cmf::math::Time t, const flux_connection *Without=0) const @@ -8409,1924 +25859,2313 @@ t: Time of the query Without: A flux_connection that is excluded from the waterbalance (e.g. to prevent closed circuits) "; +%feature("docstring") cmf::river::Reach::wet_area "real wet_area() +const -// File: classcmf_1_1river_1_1_manning.xml -%feature("docstring") cmf::river::Manning " - -Calculates the flux between two open water bodies, using Manning's -equation. - -This is the base class for a kinematic wave approach (topography -driven) and a diffusive wave approach (water table driven). The only -difference between both approaches is the calculation of the flux -driving slope. For the model, one of ManningKinematic or -ManningDiffusive connection is selected - -.. math:: - - v = R^{\\\\frac 2 3} - \\\\frac{\\\\sqrt{\\\\Delta_z}}{n} \\\\\\\\ q = v \\\\cdot A - -Where: :math:`A = \\\\frac V l`: Crosssectional area of the wetted -crossection, Volume per length - -:math:`R = \\\\frac A{P(d)}`: The hydraulic radius - -:math:`P(d)`: the perimeter of the wetted crosssection, a function of reach -depth - -:math:`d(V)`: the depth of the reach, a function of the volume - -:math:`\\\\Delta_z = \\\\frac{|z_1 - z_2|}{l}`: Slope of the reach - -:math:`n`: Manning friction number +Returns the exposed surface area in m2. "; -For the kinematic wave the slope of the river bed is used as slope: +// File: classcmf__core_1_1_reach.xml +%feature("docstring") cmf_core::Reach " -.. math:: +A reach represents the section of a riover and is a specialization of +an open water storage. The OpenWaterStorage attributes and methods +are extended by topological features, for the creation of a network of +reaches. C++ includes: Reach.h "; - \\\\Delta_z = \\\\frac{|z_1 - z_2|}{l} +%feature("docstring") cmf_core::Reach::__init__ "def __init__(self, +args, kwargs) "; -while for the diffusive wave the slope is calculated from the actual -water head: +%feature("docstring") cmf_core::Reach::__call__ "def __call__(self, +args, kwargs) -.. math:: +__call__(flux_node self, Time t) -> real "; - \\\\Delta_z = \\\\frac{|h_1 - h_2|}{l} +%feature("docstring") cmf_core::Reach::__eq__ "def __eq__(self, +args, kwargs) -C++ includes: ManningConnection.h "; +__eq__(flux_node self, flux_node other) -> bool "; -%feature("docstring") cmf::river::Manning::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +%feature("docstring") cmf_core::Reach::__getitem__ "def +__getitem__(self, args, kwargs) -Returns the concentration of the flux. +__getitem__(WaterStorage self, solute X) -> SoluteStorage "; -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +%feature("docstring") cmf_core::Reach::__hash__ "def __hash__(self) +"; -%feature("docstring") cmf::river::Manning::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +%feature("docstring") cmf_core::Reach::__repr__ "def __repr__(self) +"; -%feature("docstring") cmf::river::Manning::get_ptr "ptr get_ptr() -const "; +%feature("docstring") cmf_core::Reach::cast "def cast(args, kwargs) -%feature("docstring") cmf::river::Manning::get_target "flux_node::ptr get_target(const flux_node &inquirer) +cast(cmf::water::flux_node::ptr node) -> +cmf::river::OpenWaterStorage::ptr "; -Returns the other end of a connection than the asking end. "; +%feature("docstring") cmf_core::Reach::conc "def conc(self, args, +kwargs) -%feature("docstring") cmf::river::Manning::get_target "flux_node::ptr get_target(int index) const +conc(flux_node self, Time t, solute Solute) -> real virtual real +conc(cmf::math::Time t, const cmf::water::solute &Solute) const +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +%feature("docstring") cmf_core::Reach::conc "def conc(self, args) + +conc(WaterStorage self, solute _Solute) -> real conc(WaterStorage +self, Time t, solute _Solute) -> real conc(WaterStorage self, solute +_Solute, real NewConcetration) void conc(const cmf::water::solute +&_Solute, real NewConcetration) Sets a new concentration. "; + +%feature("docstring") cmf_core::Reach::connect_to_cell "def +connect_to_cell(self, cell, width, subsurface_connection_type=None, +subsurface_connection_depth=None, diffusive=None) + +Connects a cell with this reach using Manning's equation for surface +runoff and a given connection for subsurface interflow - width : +Boundary width in m - subsurface_connection_type : Any lateral flow +connection type - subsurface_connection_depth : The depth below +ground of the deepest layer to be connected by +subsurface_connection_type, default (None) = +cell.z - reach.position.z - diffusive: Determines if a kinematic or +diffusive wave is to be used for surface runoff "; + +%feature("docstring") cmf_core::Reach::connect_to_surfacewater "def +connect_to_surfacewater(self, args, kwargs) + +connect_to_surfacewater(Reach self, Cell cell, real width, bool +diffusive) void connect_to_surfacewater(cmf::upslope::Cell *cell, +real width, bool diffusive) Connects the surfacewater of a cell with +this reach. Parameters: ----------- cell: The cell with the surface +water to be connected with this reach width: The flow width from +cell to this reach diffusive: If diffusive is false, a +ManningKinematic connection is used, else a ManningDiffusive +connection "; -%feature("docstring") cmf::river::Manning::get_tracer_filter "real -get_tracer_filter() +%feature("docstring") cmf_core::Reach::connected_nodes "def +connected_nodes(self) "; -A value ranging from 0 to 1 to filter tracers out of the water flux. +%feature("docstring") cmf_core::Reach::connection_to "def +connection_to(self, args, kwargs) -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +connection_to(flux_node self, flux_node target) -> flux_connection +cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) Returns the connection between this and target. "; -%feature("docstring") cmf::river::Manning::get_tracer_filter "real -get_tracer_filter(solute S) +%feature("docstring") cmf_core::Reach::create "def create(args) -A value ranging from 0 to 1 to filter tracers out of the water flux. +create(project _project, real Area) -> +cmf::river::OpenWaterStorage::ptr create(project _project, +IVolumeHeightFunction base_geo) -> cmf::river::OpenWaterStorage::ptr "; -%feature("docstring") cmf::river::Manning::kill_me "bool kill_me() - -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +%feature("docstring") cmf_core::Reach::create "def create(args, +kwargs) -%feature("docstring") cmf::river::Manning::left_node "flux_node::ptr -left_node() const - -Returns the left node of this connection. "; +create(project project, IChannel shape, bool diffusive=False) -> +cmf::river::Reach::ptr "; -%feature("docstring") cmf::river::Manning::q "real q(const flux_node -&inquirer, cmf::math::Time t) +%feature("docstring") cmf_core::Reach::distance_to_cell "def +distance_to_cell(self, args, kwargs) -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +distance_to_cell(Reach self, Cell cell) -> double double +distance_to_cell(cmf::upslope::Cell *cell) const Returns the distance +(d) for connections between this reach and a cell. If the effective +inner cell distance (defined as :math:`R_{Cell} = +0.5\\\\\\\\frac{\\\\\\\\sqrt{A}}{\\\\\\\\pi}`) is smaller than the +distance between the center points, the cell radius is returned "; -%feature("docstring") cmf::river::Manning::refresh "void -refresh(cmf::math::Time t) +%feature("docstring") cmf_core::Reach::dxdt "def dxdt(self, args, +kwargs) -Performes a new calculation of the flux. "; +dxdt(StateVariable self, Time time) -> real virtual real dxdt(const +cmf::math::Time &time)=0 Returns the derivate of the state variable +at time time. "; -%feature("docstring") cmf::river::Manning::right_node "flux_node::ptr right_node() const +%feature("docstring") cmf_core::Reach::flux3d_to "def +flux3d_to(self, args, kwargs) -returns the right node of this connection "; +flux3d_to(flux_node self, flux_node target, Time t) -> point +cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; -%feature("docstring") cmf::river::Manning::set_tracer_filter "void -set_tracer_filter(real value) +%feature("docstring") cmf_core::Reach::flux_to "def flux_to(self, +args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. +flux_to(flux_node self, flux_node target, Time t) -> real real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; -1.0 is no filter and 0.0 means no solute is crossing this connection +%feature("docstring") cmf_core::Reach::fluxes "def fluxes(self, t) "; -%feature("docstring") cmf::river::Manning::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; - -%feature("docstring") cmf::river::Manning::short_string "virtual -std::string short_string() const "; - -%feature("docstring") cmf::river::Manning::to_string "virtual -std::string to_string() const "; - - -// File: classcmf_1_1river_1_1_manning___diffusive.xml -%feature("docstring") cmf::river::Manning_Diffusive " +%feature("docstring") cmf_core::Reach::from_node "def +from_node(args, kwargs) -Connecting surface water bodies using a diffusive wave. +from_node(cmf::water::flux_node::ptr node) -> std::shared_ptr< +cmf::water::WaterStorage > "; -This approach might not be numerical stable for deep water with small -gradient cmf for experimental reasons +%feature("docstring") cmf_core::Reach::get_3d_flux "def +get_3d_flux(self, args, kwargs) -.. math:: +get_3d_flux(flux_node self, Time t) -> point cmf::geometry::point +get_3d_flux(cmf::math::Time t) Returns the sum of all flux vectors. +"; - - q_{Manning}&=& A R^{\\\\frac 2 3} \\\\sqrt{\\\\frac {\\\\Delta_z} n} - \\\\\\\\ A &=& \\\\frac V l \\\\mbox{, (Crosssectional area of the - wetted crossection, Volume per length)} \\\\\\\\ R &=& \\\\frac A - {P(d)} \\\\\\\\ P(d) &=& \\\\mbox{ the perimeter of the wetted - crosssection, a function of reach depth} \\\\\\\\ d(V) &=& \\\\mbox{ - the depth of the reach a function of the volume} \\\\\\\\ \\\\Delta_z - = \\\\|\\\\frac{h_1 - h_2}{l} \\\\mbox{ Slope of the reach - waterlevels} \\\\\\\\ n&=&\\\\mbox{Manning friction number} - +%feature("docstring") cmf_core::Reach::get_abs_errtol "def +get_abs_errtol(self, args, kwargs) +get_abs_errtol(StateVariable self, real rel_errtol) -> real virtual +real get_abs_errtol(real rel_errtol) const "; +%feature("docstring") cmf_core::Reach::get_height_function "def +get_height_function(self, args, kwargs) -C++ includes: ManningConnection.h "; +get_height_function(OpenWaterStorage self) -> IVolumeHeightFunction +virtual const IVolumeHeightFunction& get_height_function() const The +functional relation between volume, depth and exposed area. "; -%feature("docstring") -cmf::river::Manning_Diffusive::Manning_Diffusive "Manning_Diffusive(cmf::river::OpenWaterStorage::ptr left, -cmf::water::flux_node::ptr right, const cmf::river::IChannel -&reachtype) +%feature("docstring") cmf_core::Reach::get_reachtype "def +get_reachtype(self, args, kwargs) -Creates a diffusive wave connection between to open water storages. +get_reachtype(Reach self) -> Channel Channel get_reachtype() const +Returns the channel shape. "; -Parameters: ------------ +%feature("docstring") cmf_core::Reach::get_states "def +get_states(self, args, kwargs) -left: right: The nodes to be connected by the diffusive wave. Left -needs to be an open water storage +get_states(StateVariableOwner self) -> StateVariableList virtual +StateVariableList get_states()=0 Add the state variables, owned by an +object derived from StateVariableOwner, to the given vector. "; -reachtype: The channel geometry "; +%feature("docstring") cmf_core::Reach::get_upstream "def +get_upstream(self, args, kwargs) -%feature("docstring") cmf::river::Manning_Diffusive::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +get_upstream(Reach self, int index) -> cmf::river::Reach::ptr ptr +get_upstream(int index) const Returns a reach upstream of this. "; -Returns the concentration of the flux. +%feature("docstring") cmf_core::Reach::is_connected "def +is_connected(self, args, kwargs) -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +is_connected(StateVariable self, StateVariable other) -> bool virtual +bool is_connected(const cmf::math::StateVariable &other) const "; -%feature("docstring") cmf::river::Manning_Diffusive::exchange_target -"void exchange_target(flux_node::ptr oldtarget, flux_node::ptr -newTarget) "; +%feature("docstring") cmf_core::Reach::is_empty "def is_empty(self, +args, kwargs) -%feature("docstring") cmf::river::Manning_Diffusive::get_ptr "ptr -get_ptr() const "; +is_empty(flux_node self) -> double virtual double is_empty() const +Returns true if the node has no water. "; -%feature("docstring") cmf::river::Manning_Diffusive::get_target "flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") cmf_core::Reach::is_storage "def +is_storage(self, args, kwargs) -Returns the other end of a connection than the asking end. "; +is_storage(flux_node self) -> bool virtual bool is_storage() const +true, if this is a waterstorage "; -%feature("docstring") cmf::river::Manning_Diffusive::get_target "flux_node::ptr get_target(int index) const +%feature("docstring") cmf_core::Reach::RecalcFluxes "def +RecalcFluxes(self, args, kwargs) -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +RecalcFluxes(flux_node self, Time t) -> bool virtual bool +RecalcFluxes(cmf::math::Time t) Pure flux_nodes do not influence +fluxes, therefore no recalculation of fluxes is required by flux_node. +WaterStorage overrides this, since state changes require an update of +the fluxes "; -%feature("docstring") -cmf::river::Manning_Diffusive::get_tracer_filter "real -get_tracer_filter() +%feature("docstring") cmf_core::Reach::remove_connection "def +remove_connection(self, args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. +remove_connection(flux_node self, cmf::water::flux_node::ptr To) -> +bool bool remove_connection(cmf::water::flux_node::ptr To) Remove +the connection. "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::Reach::set_dead_end "def +set_dead_end(self, args, kwargs) -%feature("docstring") -cmf::river::Manning_Diffusive::get_tracer_filter "real -get_tracer_filter(solute S) +set_dead_end(Reach self) void set_dead_end() Deletes any downstream +connection. "; -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +%feature("docstring") cmf_core::Reach::set_downstream "def +set_downstream(self, args, kwargs) -%feature("docstring") cmf::river::Manning_Diffusive::kill_me "bool -kill_me() +set_downstream(Reach self, cmf::river::Reach::ptr new_downstream, bool +use_meanchannel=False) void set_downstream(ptr new_downstream, bool +use_meanchannel=false) Connects the reach to another one downstream. +"; -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +%feature("docstring") cmf_core::Reach::set_height_function "def +set_height_function(self, args, kwargs) -%feature("docstring") cmf::river::Manning_Diffusive::left_node "flux_node::ptr left_node() const +set_height_function(Reach self, IChannel val) void +set_height_function(const IChannel &val) Sets the channel shape. "; -Returns the left node of this connection. "; +%feature("docstring") cmf_core::Reach::set_outlet "def +set_outlet(self, args, kwargs) -%feature("docstring") cmf::river::Manning_Diffusive::q "real q(const -flux_node &inquirer, cmf::math::Time t) +set_outlet(Reach self, cmf::water::flux_node::ptr outlet) void +set_outlet(cmf::water::flux_node::ptr outlet) Connects the reach to +an outlet, e.g. a boundary condition. "; -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +%feature("docstring") cmf_core::Reach::Solute "def Solute(self, +args) -%feature("docstring") cmf::river::Manning_Diffusive::refresh "void -refresh(cmf::math::Time t) +Solute(WaterStorage self, solute _Solute) -> SoluteStorage +Solute(WaterStorage self, solute _Solute) -> SoluteStorage const +SoluteStorage& Solute(const cmf::water::solute _Solute) const "; -Performes a new calculation of the flux. "; +%feature("docstring") cmf_core::Reach::to_string "def +to_string(self, args, kwargs) -%feature("docstring") cmf::river::Manning_Diffusive::right_node "flux_node::ptr right_node() const +to_string(StateVariable self) -> std::string virtual std::string +to_string() const =0 "; -returns the right node of this connection "; +%feature("docstring") cmf_core::Reach::to_string "def +to_string(self, args, kwargs) -%feature("docstring") -cmf::river::Manning_Diffusive::set_tracer_filter "void -set_tracer_filter(real value) +to_string(flux_node self) -> std::string virtual std::string +to_string() const "; -A value ranging from 0 to 1 to filter tracers out of the water flux. +%feature("docstring") cmf_core::Reach::upstream "def upstream(self) -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +Returns a list containing all reaches flowing into self "; -%feature("docstring") -cmf::river::Manning_Diffusive::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; +%feature("docstring") cmf_core::Reach::waterbalance "def +waterbalance(self, args, kwargs) -%feature("docstring") cmf::river::Manning_Diffusive::short_string "virtual std::string short_string() const "; +waterbalance(flux_node self, Time t, flux_connection Without=None) -> +real real waterbalance(cmf::math::Time t, const flux_connection +*Without=0) const Returns the sum of all fluxes (positive and +negative) at time t. Single fluxes can be excluded from the +calculation Parameters: ----------- t: Time of the query Without: +A flux_connection that is excluded from the waterbalance (e.g. to +prevent closed circuits) "; -%feature("docstring") cmf::river::Manning_Diffusive::to_string "virtual std::string to_string() const "; +%feature("docstring") cmf_core::Reach::wet_area "def wet_area(self, +args, kwargs) +wet_area(OpenWaterStorage self) -> real real wet_area() const Returns +the exposed surface area in m2. "; -// File: classcmf_1_1river_1_1_manning___kinematic.xml -%feature("docstring") cmf::river::Manning_Kinematic " -Connecting surface water bodies using a kinematic wave. +// File: classcmf_1_1river_1_1_reach_iterator.xml +%feature("docstring") cmf::river::ReachIterator " -Note the fixed gradient :math:`\\\\Delta_z` +An iterator over every upstream reach from a start reach. -.. math:: +Implements both the Python and the C++ iterator interface Usage C++: +Usage Python: - - q_{Manning}&=& A R^{\\\\frac 2 3} \\\\sqrt{\\\\frac {\\\\Delta_z} n} - \\\\\\\\ A &=& \\\\frac V l \\\\mbox{, (Crosssectional area of the - wetted crossection, Volume per length)} \\\\\\\\ R &=& \\\\frac A - {P(d)} \\\\\\\\ P(d) &=& \\\\mbox{ the perimeter of the wetted - crosssection, a function of reach depth} \\\\\\\\ d(V) &=& \\\\mbox{ - the depth of the reach a function of the volume} \\\\\\\\ \\\\Delta_z - &=& \\\\frac{\\\\|z_1 - z_2\\\\|}{l} \\\\mbox{ Slope of the reach} - \\\\\\\\ n&=&\\\\mbox{Manning friction number} +C++ includes: Reach.h "; +%feature("docstring") cmf::river::ReachIterator::ReachIterator "ReachIterator(Reach::ptr first) +Creates a ReachIterator from a first reach. "; -C++ includes: ManningConnection.h "; +%feature("docstring") cmf::river::ReachIterator::next "Reach::ptr +next() -%feature("docstring") -cmf::river::Manning_Kinematic::Manning_Kinematic "Manning_Kinematic(cmf::river::OpenWaterStorage::ptr left, -cmf::water::flux_node::ptr right, const cmf::river::IChannel -&reachtype) +Returns the next reach in the upstream queue. "; -Creates a kinematic wave connection between to open water storages. +%feature("docstring") cmf::river::ReachIterator::position "double +position() const -Parameters: ------------ +Returns the distance to the root reach. "; -left: right: The nodes to be connected by the kinematic wave. Left -needs to be an open water storage +%feature("docstring") cmf::river::ReachIterator::reach "Reach::ptr +reach() const -reachtype: The channel geometry "; +Returns the current reach. "; -%feature("docstring") cmf::river::Manning_Kinematic::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +%feature("docstring") cmf::river::ReachIterator::valid "bool valid() +const -Returns the concentration of the flux. +Returns true, if reaches are left to iterate over. "; -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; -%feature("docstring") cmf::river::Manning_Kinematic::exchange_target -"void exchange_target(flux_node::ptr oldtarget, flux_node::ptr -newTarget) "; +// File: classcmf__core_1_1_reach_iterator.xml +%feature("docstring") cmf_core::ReachIterator " -%feature("docstring") cmf::river::Manning_Kinematic::get_ptr "ptr -get_ptr() const "; +An iterator over every upstream reach from a start reach. Implements +both the Python and the C++ iterator interface Usage C++: Usage +Python: C++ includes: Reach.h "; -%feature("docstring") cmf::river::Manning_Kinematic::get_target "flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") cmf_core::ReachIterator::__init__ "def +__init__(self, args, kwargs) -Returns the other end of a connection than the asking end. "; +__init__(cmf::river::ReachIterator self, cmf::river::Reach::ptr first) +-> ReachIterator ReachIterator(Reach::ptr first) Creates a +ReachIterator from a first reach. "; -%feature("docstring") cmf::river::Manning_Kinematic::get_target "flux_node::ptr get_target(int index) const +%feature("docstring") cmf_core::ReachIterator::__iter__ "def +__iter__(self) "; -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +%feature("docstring") cmf_core::ReachIterator::next "def next(self, +args, kwargs) -%feature("docstring") -cmf::river::Manning_Kinematic::get_tracer_filter "real -get_tracer_filter() +next(ReachIterator self) -> cmf::river::Reach::ptr Reach::ptr next() +Returns the next reach in the upstream queue. "; -A value ranging from 0 to 1 to filter tracers out of the water flux. +%feature("docstring") cmf_core::ReachIterator::valid "def +valid(self, args, kwargs) -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +valid(ReachIterator self) -> bool bool valid() const Returns true, +if reaches are left to iterate over. "; -%feature("docstring") -cmf::river::Manning_Kinematic::get_tracer_filter "real -get_tracer_filter(solute S) -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +// File: classcmf_1_1river_1_1_rectangular_reach.xml +%feature("docstring") cmf::river::RectangularReach " -%feature("docstring") cmf::river::Manning_Kinematic::kill_me "bool -kill_me() +Describes a IChannel with a rectangular crosssection. -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +C++ includes: ReachType.h "; -%feature("docstring") cmf::river::Manning_Kinematic::left_node "flux_node::ptr left_node() const +%feature("docstring") cmf::river::RectangularReach::RectangularReach +"RectangularReach(double l, double width) -Returns the left node of this connection. "; +Creates a new rectangular reach type with width [m]. "; -%feature("docstring") cmf::river::Manning_Kinematic::q "real q(const -flux_node &inquirer, cmf::math::Time t) +%feature("docstring") cmf::river::RectangularReach::RectangularReach +"RectangularReach(const RectangularReach ©) "; -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +%feature("docstring") cmf::river::RectangularReach::~RectangularReach +"virtual ~RectangularReach() "; -%feature("docstring") cmf::river::Manning_Kinematic::refresh "void -refresh(cmf::math::Time t) +%feature("docstring") cmf::river::RectangularReach::A "virtual +double A(double V) const -Performes a new calculation of the flux. "; +Returns the area of the surface for a given volume. "; -%feature("docstring") cmf::river::Manning_Kinematic::right_node "flux_node::ptr right_node() const +%feature("docstring") cmf::river::RectangularReach::copy "RectangularReach* copy() const "; -returns the right node of this connection "; +%feature("docstring") cmf::river::RectangularReach::get_channel_width +"virtual double get_channel_width(double depth) const -%feature("docstring") -cmf::river::Manning_Kinematic::set_tracer_filter "void -set_tracer_filter(real value) +Returns the width of the stream at a given depth -A value ranging from 0 to 1 to filter tracers out of the water flux. +.. math:: -1.0 is no filter and 0.0 means no solute is crossing this connection -"; + + w &=& const -%feature("docstring") -cmf::river::Manning_Kinematic::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; +. "; -%feature("docstring") cmf::river::Manning_Kinematic::short_string "virtual std::string short_string() const "; +%feature("docstring") cmf::river::RectangularReach::get_depth "virtual double get_depth(double area) const -%feature("docstring") cmf::river::Manning_Kinematic::to_string "virtual std::string to_string() const "; +Returns the depth at a given crossection area +.. math:: -// File: classcmf_1_1maps_1_1_map.xml -%feature("docstring") cmf::maps::Map " + d + &=& \\\\frac A w -A Map is the base class for different spatial data distributions. The -base version contains returns always the default value A Map should -implement the following functions: __iter__, returns an iterator over -the items of a map values(), returns an iterator over the different -objects of a map __call__(x,y,z), returns the object belonging to the -position x,y,z "; +. "; -%feature("docstring") cmf::maps::Map::__init__ "def __init__(self, -default=None) "; +%feature("docstring") +cmf::river::RectangularReach::get_flux_crossection "virtual double +get_flux_crossection(double depth) const -%feature("docstring") cmf::maps::Map::__call__ "def __call__(self, -x, y, z=0) +Returns the crossection area at a given depth -returns default, regardless of the position given "; +.. math:: -%feature("docstring") cmf::maps::Map::__iter__ "def __iter__(self) -"; + A + &=& d w -%feature("docstring") cmf::maps::Map::__nonzero__ "def -__nonzero__(self) "; +. "; -%feature("docstring") cmf::maps::Map::values "def values(self) "; +%feature("docstring") cmf::river::RectangularReach::get_length "double get_length() const +Length of the reach. "; -// File: classcmf_1_1upslope_1_1connections_1_1_matrix_infiltration.xml -%feature("docstring") cmf::upslope::connections::MatrixInfiltration " +%feature("docstring") cmf::river::RectangularReach::get_nManning "virtual double get_nManning() const "; -Connects the surfacewater and the most upper layer using a Richards -equation like infiltration model. +%feature("docstring") +cmf::river::RectangularReach::get_wetted_perimeter "virtual double +get_wetted_perimeter(double depth) const -The potential infiltration is calculated according to the Richards -equation. The gradient is from the cell surface to the center of the -first layer and the conductivity is the geometric mean of the wetted -surface ( :math:`K_{sat}`) and the conductivity of the layer center ( -:math:`K(\\\\theta_{layer})` +Returns the wetted perimeter at a given depth .. math:: - q_{max} &=& - \\\\frac{\\\\Psi_{surface} - \\\\Psi_{soil}}{\\\\Delta z} K A_{cell} - \\\\\\\\ K &=& \\\\sqrt{K\\\\left(\\\\theta_{layer}\\\\right)K_{sat}} - \\\\\\\\ \\\\Delta z &=& z_{cell} - z_{layer center} - + P + &=& 2 d + w + +. "; +%feature("docstring") cmf::river::RectangularReach::h "virtual +double h(double V) const +Returns the depth of a given volume. "; -If the surface water is modeled by a distinct water storage, the -actual infiltration is given as the product of the potential -infiltration with the coverage of the surface water -cmf::upslope::Cell::surface_water_coverage +%feature("docstring") cmf::river::RectangularReach::q "virtual +double q(double h, double slope) const "; -.. math:: +%feature("docstring") cmf::river::RectangularReach::qManning "virtual double qManning(double A, double slope) const - q_{act} = q_{max} - \\\\frac{A_{water}}{A_{cell}} +Calculates the flow rate from a given water volume in the reach -If the surface water is no storage on its own, but just a water -distribution node, the actual infiltration is the minimum of the -potential infiltration and the current inflow (rain, snow melt) to the -surface .. math:: - q_{act} = \\\\min\\\\left(q_{max}, - \\\\sum{q_{in,surfacewater}}\\\\right) + q_{Manning}&=& A R^{\\\\frac 2 3} + \\\\sqrt{\\\\frac {\\\\Delta_z} n} \\\\\\\\ A &=& \\\\frac V l + \\\\mbox{, (Crosssectional area of the wetted crossection, Volume per + length)} \\\\\\\\ R &=& \\\\frac A {P(d)} \\\\\\\\ P(d) &=& \\\\mbox{ + the perimeter of the wetted crosssection, a function of reach depth} + \\\\\\\\ d(V) &=& \\\\mbox{ the depth of the reach a function of the + volume} \\\\\\\\ \\\\Delta_z &=& \\\\frac{z_{max} - z_{min}}{l} + \\\\mbox{ Slope of the reach} -C++ includes: infiltration.h "; +. -%feature("docstring") -cmf::upslope::connections::MatrixInfiltration::MatrixInfiltration "MatrixInfiltration(cmf::upslope::SoilLayer::ptr soilwater, -cmf::water::flux_node::ptr surfacewater) "; +Flow rate [m3/s] -%feature("docstring") -cmf::upslope::connections::MatrixInfiltration::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +Parameters: +----------- -Returns the concentration of the flux. +A: The area of the cross section [m2] -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +slope: The slope of the reach [m/m] "; -%feature("docstring") -cmf::upslope::connections::MatrixInfiltration::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +%feature("docstring") cmf::river::RectangularReach::set_nManning "virtual void set_nManning(double nManning) "; -%feature("docstring") -cmf::upslope::connections::MatrixInfiltration::get_ptr "ptr get_ptr() -const "; +%feature("docstring") cmf::river::RectangularReach::typecode "char +typecode() const "; -%feature("docstring") -cmf::upslope::connections::MatrixInfiltration::get_target "flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") cmf::river::RectangularReach::V "virtual +double V(double h) const "; -Returns the other end of a connection than the asking end. "; -%feature("docstring") -cmf::upslope::connections::MatrixInfiltration::get_target "flux_node::ptr get_target(int index) const +// File: classcmf__core_1_1_rectangular_reach.xml +%feature("docstring") cmf_core::RectangularReach " -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +Describes a IChannel with a rectangular crosssection. C++ includes: +ReachType.h "; -%feature("docstring") -cmf::upslope::connections::MatrixInfiltration::get_tracer_filter "real get_tracer_filter() +%feature("docstring") cmf_core::RectangularReach::__init__ "def +__init__(self, args) -A value ranging from 0 to 1 to filter tracers out of the water flux. +__init__(cmf::river::RectangularReach self, double l, double width) -> +RectangularReach __init__(cmf::river::RectangularReach self, +RectangularReach copy) -> RectangularReach RectangularReach(const +RectangularReach ©) "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::RectangularReach::A "def A(self, +args, kwargs) -%feature("docstring") -cmf::upslope::connections::MatrixInfiltration::get_tracer_filter "real get_tracer_filter(solute S) +A(IVolumeHeightFunction self, double V) -> double virtual double +A(double V) const =0 Returns the area of the surface for a given +volume. "; -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +%feature("docstring") cmf_core::RectangularReach::copy "def +copy(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::MatrixInfiltration::kill_me "bool -kill_me() +copy(RectangularReach self) -> RectangularReach RectangularReach* +copy() const "; -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +%feature("docstring") cmf_core::RectangularReach::get_channel_width "def get_channel_width(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::MatrixInfiltration::left_node "flux_node::ptr left_node() const +get_channel_width(IChannel self, double depth) -> double virtual +double get_channel_width(double depth) const =0 Calculates the flow +width from a given actual depth [m] using the actual IChannel +geometry. "; -Returns the left node of this connection. "; +%feature("docstring") cmf_core::RectangularReach::get_depth "def +get_depth(self, args, kwargs) + +get_depth(IChannel self, double area) -> double virtual double +get_depth(double area) const =0 Calculates the actual depth of the +reach using the IChannel geometry. get_depth of the reach [m] +Parameters: ----------- area: Wetted area of a river cross section +[m2], can be obtained by V/l, where V is the stored volume and l is +the reach length "; %feature("docstring") -cmf::upslope::connections::MatrixInfiltration::q "real q(const -flux_node &inquirer, cmf::math::Time t) +cmf_core::RectangularReach::get_flux_crossection "def +get_flux_crossection(self, args, kwargs) -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +get_flux_crossection(IChannel self, double depth) -> double virtual +double get_flux_crossection(double depth) const =0 Calculates the +wetted area from a given depth using the IChannel geometry. In most +cases use get_flux_crossection=V/l, where V is the stored volume and l +is the reach length Wetted area of a river cross section [m2] +Parameters: ----------- depth: depth of the reach [m] "; -%feature("docstring") -cmf::upslope::connections::MatrixInfiltration::refresh "void -refresh(cmf::math::Time t) +%feature("docstring") cmf_core::RectangularReach::get_length "def +get_length(self, args, kwargs) -Performes a new calculation of the flux. "; +get_length(IChannel self) -> double virtual double get_length() const +=0 Length of the reach. "; -%feature("docstring") -cmf::upslope::connections::MatrixInfiltration::right_node "flux_node::ptr right_node() const +%feature("docstring") cmf_core::RectangularReach::get_nManning "def +get_nManning(self, args, kwargs) -returns the right node of this connection "; +get_nManning(IChannel self) -> double virtual double get_nManning() +const =0 "; %feature("docstring") -cmf::upslope::connections::MatrixInfiltration::set_tracer_filter "void set_tracer_filter(real value) +cmf_core::RectangularReach::get_wetted_perimeter "def +get_wetted_perimeter(self, args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. +get_wetted_perimeter(IChannel self, double depth) -> double virtual +double get_wetted_perimeter(double depth) const =0 Calculates the +wetted perimeter from a given actual depth [m] using the actual +IChannel geometry. "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::RectangularReach::h "def h(self, +args, kwargs) -%feature("docstring") -cmf::upslope::connections::MatrixInfiltration::set_tracer_filter "void set_tracer_filter(solute S, real value) "; +h(IVolumeHeightFunction self, double V) -> double virtual double +h(double V) const =0 Returns the depth of a given volume. "; -%feature("docstring") -cmf::upslope::connections::MatrixInfiltration::short_string "virtual -std::string short_string() const "; +%feature("docstring") cmf_core::RectangularReach::q "def q(self, +args, kwargs) -%feature("docstring") -cmf::upslope::connections::MatrixInfiltration::to_string "virtual -std::string to_string() const "; +q(IVolumeHeightFunction self, double h, double slope) -> double +virtual double q(double h, double slope) const "; +%feature("docstring") cmf_core::RectangularReach::qManning "def +qManning(self, args, kwargs) -// File: classcmf_1_1river_1_1_mean_channel.xml -%feature("docstring") cmf::river::MeanChannel " +qManning(IChannel self, double A, double slope) -> double virtual +double qManning(double A, double slope) const Calculates the flow +rate from a given water volume in the reach .. math:: q_{Manning}&=& +A R^{\\\\\\\\frac 2 3} \\\\\\\\sqrt{\\\\\\\\frac {\\\\\\\\Delta_z} +n} \\\\\\\\\\\\\\\\ A &=& \\\\\\\\frac V l \\\\\\\\mbox{, +(Crosssectional area of the wetted crossection, Volume per +length)} \\\\\\\\\\\\\\\\ R &=& \\\\\\\\frac A {P(d)} \\\\\\\\\\\\\\\\ +P(d) &=& \\\\\\\\mbox{ the perimeter of the wetted crosssection, a +function of reach depth} \\\\\\\\\\\\\\\\ d(V) &=& \\\\\\\\mbox{ +the depth of the reach a function of the volume} \\\\\\\\\\\\\\\\ +\\\\\\\\Delta_z &=& \\\\\\\\frac{z_{max} - z_{min}}{l} +\\\\\\\\mbox{ Slope of the reach} . Flow rate [m3/s] Parameters: +----------- A: The area of the cross section [m2] slope: The slope +of the reach [m/m] "; -A combination of two channel geometries. +%feature("docstring") cmf_core::RectangularReach::set_nManning "def +set_nManning(self, args, kwargs) -C++ includes: ReachType.h "; +set_nManning(IChannel self, double val) virtual void +set_nManning(double val)=0 "; -%feature("docstring") cmf::river::MeanChannel::MeanChannel "MeanChannel(const IChannel &channel1, const IChannel &channel2) +%feature("docstring") cmf_core::RectangularReach::typecode "def +typecode(self, args, kwargs) -Creates the mean geometry from the two channel geometries. "; +typecode(IChannel self) -> char virtual char typecode() const =0 "; -%feature("docstring") cmf::river::MeanChannel::MeanChannel "MeanChannel(const MeanChannel &meanChannel) "; +%feature("docstring") cmf_core::RectangularReach::V "def V(self, +args, kwargs) -%feature("docstring") cmf::river::MeanChannel::~MeanChannel "virtual -~MeanChannel() "; +V(IVolumeHeightFunction self, double h) -> double virtual double +V(double h) const =0 "; -%feature("docstring") cmf::river::MeanChannel::A "virtual double -A(double V) const -Returns the area of the surface for a given volume. "; +// File: classcmf_1_1upslope_1_1_retention_curve.xml +%feature("docstring") cmf::upslope::RetentionCurve " -%feature("docstring") cmf::river::MeanChannel::copy "MeanChannel* -copy() const "; +Abstract base class for different types of retention curves. -%feature("docstring") cmf::river::MeanChannel::get_channel_width "double get_channel_width(double depth) const +This class, and its children uses wetness instead of volumetric water +content. The wetness of a soil is defined as water content per void +volume -Calculates the flow width from a given actual depth [m] using the -actual IChannel geometry. "; +C++ includes: RetentionCurve.h "; -%feature("docstring") cmf::river::MeanChannel::get_depth "double -get_depth(double area) const +%feature("docstring") cmf::upslope::RetentionCurve::~RetentionCurve "virtual ~RetentionCurve() "; -Calculates the actual depth of the reach using the IChannel geometry. +%feature("docstring") cmf::upslope::RetentionCurve::copy "virtual +RetentionCurve* copy() const =0 "; -get_depth of the reach [m] +%feature("docstring") cmf::upslope::RetentionCurve::Diffusivity "virtual real Diffusivity(real wetness) const -Parameters: ------------ +Returns the Diffusivity of the soil. -area: Wetted area of a river cross section [m2], can be obtained by -V/l, where V is the stored volume and l is the reach length "; +Not implemented for all retention curves. Diffusivity is used by +MACROlikeMacroMicroExchange "; -%feature("docstring") cmf::river::MeanChannel::get_flux_crossection "double get_flux_crossection(double depth) const +%feature("docstring") cmf::upslope::RetentionCurve::Diffusivity "cmf::math::num_array Diffusivity(cmf::math::num_array &wetness) "; -Calculates the wetted area from a given depth using the IChannel -geometry. +%feature("docstring") cmf::upslope::RetentionCurve::dPsiM_dW "virtual real dPsiM_dW(real wetness) const "; -In most cases use get_flux_crossection=V/l, where V is the stored -volume and l is the reach length Wetted area of a river cross section -[m2] +%feature("docstring") cmf::upslope::RetentionCurve::dPsiM_dW "cmf::math::num_array dPsiM_dW(const cmf::math::num_array &wetness) +const "; -Parameters: ------------ +%feature("docstring") cmf::upslope::RetentionCurve::FillHeight "virtual real FillHeight(real lowerDepth, real Area, real Volume) const -depth: depth of the reach [m] "; +Returns the thickness of a soil column with a certain pore volume. "; -%feature("docstring") cmf::river::MeanChannel::get_length "double -get_length() const +%feature("docstring") cmf::upslope::RetentionCurve::K "virtual real +K(real wetness) const -Length of the reach. "; +Returns the conductivity in m/day at a certain depth and water +content. "; -%feature("docstring") cmf::river::MeanChannel::get_nManning "virtual -double get_nManning() const "; +%feature("docstring") cmf::upslope::RetentionCurve::K "cmf::math::num_array K(const cmf::math::num_array &wetness) const "; -%feature("docstring") cmf::river::MeanChannel::get_wetted_perimeter "double get_wetted_perimeter(double depth) const +%feature("docstring") cmf::upslope::RetentionCurve::MatricPotential "virtual real MatricPotential(real wetness) const -Calculates the wetted perimeter from a given actual depth [m] using -the actual IChannel geometry. "; +returns the wetness of the soil at given water content "; -%feature("docstring") cmf::river::MeanChannel::h "virtual double -h(double V) const +%feature("docstring") cmf::upslope::RetentionCurve::MatricPotential "cmf::math::num_array MatricPotential(const cmf::math::num_array +&wetness) const "; -Returns the depth of a given volume. "; +%feature("docstring") cmf::upslope::RetentionCurve::Porosity "virtual real Porosity(real depth=0.0) const =0 -%feature("docstring") cmf::river::MeanChannel::q "virtual double -q(double h, double slope) const "; +Returns the porosity at a certain depth. "; -%feature("docstring") cmf::river::MeanChannel::qManning "virtual -double qManning(double A, double slope) const +%feature("docstring") cmf::upslope::RetentionCurve::theta "virtual +real theta(real wetness) const -Calculates the flow rate from a given water volume in the reach +returns the water content :math:`theta` for a given wetness "; +%feature("docstring") cmf::upslope::RetentionCurve::theta "cmf::math::num_array theta(const cmf::math::num_array &wetness) const +"; -.. math:: +%feature("docstring") cmf::upslope::RetentionCurve::VoidVolume "virtual real VoidVolume(real upperDepth, real lowerDepth, real Area) +const - q_{Manning}&=& A R^{\\\\frac 2 3} - \\\\sqrt{\\\\frac {\\\\Delta_z} n} \\\\\\\\ A &=& \\\\frac V l - \\\\mbox{, (Crosssectional area of the wetted crossection, Volume per - length)} \\\\\\\\ R &=& \\\\frac A {P(d)} \\\\\\\\ P(d) &=& \\\\mbox{ - the perimeter of the wetted crosssection, a function of reach depth} - \\\\\\\\ d(V) &=& \\\\mbox{ the depth of the reach a function of the - volume} \\\\\\\\ \\\\Delta_z &=& \\\\frac{z_{max} - z_{min}}{l} - \\\\mbox{ Slope of the reach} +Returns the void volume of a soil column. "; -. +%feature("docstring") cmf::upslope::RetentionCurve::Wetness "virtual +real Wetness(real suction) const -Flow rate [m3/s] +returns the wetness (volumetric water content per pore space) at a +given suction pressure "; -Parameters: ------------ +%feature("docstring") cmf::upslope::RetentionCurve::Wetness "cmf::math::num_array Wetness(const cmf::math::num_array &suction) +const "; -A: The area of the cross section [m2] +%feature("docstring") cmf::upslope::RetentionCurve::Wetness_eff "virtual real Wetness_eff(real wetness, real pF_r=4.2) const -slope: The slope of the reach [m/m] "; +Returns the effective wetness, using a residual pF value -%feature("docstring") cmf::river::MeanChannel::set_nManning "virtual -void set_nManning(double nManning) "; +.. math:: -%feature("docstring") cmf::river::MeanChannel::typecode "char -typecode() const "; + w_{eff} + = + \\\\frac{w_{act}-w\\\\left(pF_r\\\\right)}{1-w\\\\left(pF_r\\\\right)} -%feature("docstring") cmf::river::MeanChannel::V "virtual double -V(double h) const "; +. +"; +%feature("docstring") cmf::upslope::RetentionCurve::Wetness_pF "real +Wetness_pF(real pF) const -// File: classcmf_1_1atmosphere_1_1_meteorology.xml -%feature("docstring") cmf::atmosphere::Meteorology " +returns the volumetric water content at a given pF value "; -An abstract class, for objects generating Weather records at a -specific time. +%feature("docstring") cmf::upslope::RetentionCurve::Wetness_pF "cmf::math::num_array Wetness_pF(const cmf::math::num_array &pF) const +"; -C++ includes: meteorology.h "; -%feature("docstring") cmf::atmosphere::Meteorology::~Meteorology "virtual ~Meteorology() "; +// File: classcmf__core_1_1_retention_curve.xml +%feature("docstring") cmf_core::RetentionCurve " -%feature("docstring") cmf::atmosphere::Meteorology::copy "virtual -Meteorology* copy() const =0 +Abstract base class for different types of retention curves. This +class, and its children uses wetness instead of volumetric water +content. The wetness of a soil is defined as water content per void +volume C++ includes: RetentionCurve.h "; -Returns a copy of the meteorology object. Pure virtual function, needs -to be implemented. "; +%feature("docstring") cmf_core::RetentionCurve::__init__ "def +__init__(self, args, kwargs) "; -%feature("docstring") -cmf::atmosphere::Meteorology::get_instrument_height "virtual real -get_instrument_height() const =0 +%feature("docstring") cmf_core::RetentionCurve::copy "def copy(self, +args, kwargs) -Returns the height of the instruments above canopy. "; +copy(RetentionCurve self) -> RetentionCurve virtual RetentionCurve* +copy() const =0 "; + +%feature("docstring") cmf_core::RetentionCurve::Diffusivity "def +Diffusivity(self, args) -%feature("docstring") cmf::atmosphere::Meteorology::get_weather "virtual cmf::atmosphere::Weather get_weather(cmf::math::Time t) const -=0 +Diffusivity(RetentionCurve self, real wetness) -> real +Diffusivity(RetentionCurve self, cmf::math::num_array & wetness) -> +cmf::math::num_array cmf::math::num_array +Diffusivity(cmf::math::num_array &wetness) "; -Returns the Weather at time t. Pure virtual function. Must get -implemented by child functions. "; +%feature("docstring") cmf_core::RetentionCurve::dPsiM_dW "def +dPsiM_dW(self, args) +dPsiM_dW(RetentionCurve self, real wetness) -> real +dPsiM_dW(RetentionCurve self, cmf::math::num_array const & wetness) -> +cmf::math::num_array cmf::math::num_array dPsiM_dW(const +cmf::math::num_array &wetness) const "; -// File: classcmf_1_1atmosphere_1_1_meteo_station.xml -%feature("docstring") cmf::atmosphere::MeteoStation " +%feature("docstring") cmf_core::RetentionCurve::FillHeight "def +FillHeight(self, args, kwargs) -A meteorological station holding timeseries to create Weather records. +FillHeight(RetentionCurve self, real lowerDepth, real Area, real +Volume) -> real virtual real FillHeight(real lowerDepth, real Area, +real Volume) const Returns the thickness of a soil column with a +certain pore volume. "; -In order to calculate ETpot with cmf a big amount of meteorological -data is needed, more data than usually available. The MeteoStation -class can estimate missing data from a minimal set. As more data, as -one provides, the better the calculation of ETpot becomes. The minimal -data needed is Tmin and Tmax (daily) and precipitation. To calculate -the global radiation (although measured global radiation could be -inserted), the position of meteorological station in geographic -coordinates has to be set. +%feature("docstring") cmf_core::RetentionCurve::K "def K(self, args) -A meteorological station is created by -cmf::atmosphere::MeteoStationList::add_station . Usage from python: +K(RetentionCurve self, real wetness) -> real K(RetentionCurve self, +cmf::math::num_array const & wetness) -> cmf::math::num_array +cmf::math::num_array K(const cmf::math::num_array &wetness) const "; -There are two modes for the meteorology: daily=true and daily=false. -If daily=true, Radiation is given as a daily mean value. If -daily=false, Radiation is given as an hourly mean value, which shows -the dial ETpot variation but results in erronous results if the -timestep is daily. +%feature("docstring") cmf_core::RetentionCurve::MatricPotential "def +MatricPotential(self, args) -C++ includes: meteorology.h "; +MatricPotential(RetentionCurve self, real wetness) -> real +MatricPotential(RetentionCurve self, cmf::math::num_array const & +wetness) -> cmf::math::num_array cmf::math::num_array +MatricPotential(const cmf::math::num_array &wetness) const "; -/* Location and behaviour properties */ +%feature("docstring") cmf_core::RetentionCurve::Porosity "def +Porosity(self, args, kwargs) -%feature("docstring") cmf::atmosphere::MeteoStation::get_position "cmf::geometry::point get_position() const "; +Porosity(RetentionCurve self, real depth=0.0) -> real virtual real +Porosity(real depth=0.0) const =0 Returns the porosity at a certain +depth. "; -/* Data access methods */ +%feature("docstring") cmf_core::RetentionCurve::theta "def +theta(self, args) -%feature("docstring") cmf::atmosphere::MeteoStation::get_data "cmf::atmosphere::Weather get_data(cmf::math::Time t, double height) -const +theta(RetentionCurve self, real wetness) -> real theta(RetentionCurve +self, cmf::math::num_array const & wetness) -> cmf::math::num_array +cmf::math::num_array theta(const cmf::math::num_array &wetness) const +"; -Returns the current Atmosphere state. Uses default values for missing -timeseries. "; +%feature("docstring") cmf_core::RetentionCurve::VoidVolume "def +VoidVolume(self, args, kwargs) -%feature("docstring") cmf::atmosphere::MeteoStation::use_for_cell "void use_for_cell(cmf::upslope::Cell &c) +VoidVolume(RetentionCurve self, real upperDepth, real lowerDepth, real +Area) -> real virtual real VoidVolume(real upperDepth, real +lowerDepth, real Area) const Returns the void volume of a soil +column. "; -Connects this meteostation as a meteo data provider with the cell. "; +%feature("docstring") cmf_core::RetentionCurve::Wetness "def +Wetness(self, args) -%feature("docstring") -cmf::atmosphere::MeteoStation::SetSunshineFraction "void -SetSunshineFraction(cmf::math::timeseries sunshine_duration) +Wetness(RetentionCurve self, real suction) -> real +Wetness(RetentionCurve self, cmf::math::num_array const & suction) -> +cmf::math::num_array cmf::math::num_array Wetness(const +cmf::math::num_array &suction) const "; -Calculates a timeseries of the sunshine fraction (to put into -Sunshine) from a timeseries of absolute sunshine duration +%feature("docstring") cmf_core::RetentionCurve::Wetness_eff "def +Wetness_eff(self, args, kwargs) -seehttp://www.fao.org/docrep/X0490E/x0490e07.htm#radiation +Wetness_eff(RetentionCurve self, real wetness, real pF_r=4.2) -> real +virtual real Wetness_eff(real wetness, real pF_r=4.2) const Returns +the effective wetness, using a residual pF value .. math:: w_{eff} += +\\\\\\\\frac{w_{act}-w\\\\\\\\left(pF_r\\\\\\\\right)}{1-w\\\\\\\\left(pF_r\\\\\\\\right)} +. "; +%feature("docstring") cmf_core::RetentionCurve::Wetness_pF "def +Wetness_pF(self, args) -.. math:: +Wetness_pF(RetentionCurve self, real pF) -> real +Wetness_pF(RetentionCurve self, cmf::math::num_array const & pF) -> +cmf::math::num_array cmf::math::num_array Wetness_pF(const +cmf::math::num_array &pF) const "; - \\\\phi &=& \\\\frac{(\\\\mbox{geogr. - Latitude})^\\\\circ \\\\pi}{180^\\\\circ} \\\\mbox{ Latitude in }rad - \\\\\\\\ \\\\delta &=& 0.409 \\\\sin\\\\left(\\\\frac{2\\\\pi}{365}DOY - - 1.39\\\\right) \\\\mbox{ Declination, DOY is day of year}\\\\\\\\ - \\\\omega_s &=& \\\\arccos(-\\\\tan\\\\phi\\\\tan\\\\delta) \\\\mbox{ - Sunset angle in }rad \\\\\\\\ N &=& \\\\frac{24}{\\\\pi}\\\\omega_s - \\\\mbox{ potential duration of sunshine in }h \\\\\\\\ \\\\frac n N - &=& n\\\\mbox{ absolute sunshine duration in }h - "; +// File: classcmf__core_1_1_richards.xml +%feature("docstring") cmf_core::Richards " -/* Timeseries of meteorological data */ +Calculates flow according to the Richards equation. .. math:: +q_{Richards} &=& \\\\\\\\frac{\\\\\\\\Delta\\\\\\\\Psi_{tot}}{d} +K(\\\\\\\\theta) A \\\\\\\\\\\\\\\\ \\\\\\\\Psi_{tot} &= +&\\\\\\\\Psi_{M}(\\\\\\\\theta) + h where +:math:`\\\\\\\\Delta\\\\\\\\Psi_{tot} [m]` is the difference of the +total water potentials of the two soil layers :math:`d [m]` is the +distance between the two soil layers +:math:`K(\\\\\\\\theta)\\\\\\\\left[\\\\\\\\frac m{day}\\\\\\\\right]` +is the geometric mean conductivity (see SoilType::Kunsat) :math:`A +[m^2]` is the crosssectional area of the flux +:math:`\\\\\\\\Psi_M(\\\\\\\\theta) [m]` is the matrix potential (see +SoilType::MatrixPotential) :math:`h [m]` is the height of a soil +layer above sea level C++ includes: Percolation.h "; -%feature("docstring") cmf::atmosphere::MeteoStation::MeteoStation "MeteoStation(const cmf::atmosphere::MeteoStation &other) +%feature("docstring") cmf_core::Richards::__init__ "def +__init__(self, args, kwargs) -Copy c'tor. "; +__init__(cmf::upslope::connections::Richards self, +cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right) +-> Richards Richards(cmf::upslope::SoilLayer::ptr left, +cmf::water::flux_node::ptr right) Creates a Richards equation +connection between two soil layers (left and right, rather top and +bottom) of the same cell. "; +%feature("docstring") cmf_core::Richards::__contains__ "def +__contains__(self, cmp) "; -// File: classcmf_1_1atmosphere_1_1_meteo_station_list.xml -%feature("docstring") cmf::atmosphere::MeteoStationList " +%feature("docstring") cmf_core::Richards::__eq__ "def __eq__(self, +args, kwargs) -A list of meteorological stations. +__eq__(flux_connection self, flux_connection other) -> bool "; -Can find the nearest station for a position and calculate the -temperature lapse +%feature("docstring") cmf_core::Richards::__getitem__ "def +__getitem__(self, index) "; -C++ includes: meteorology.h "; +%feature("docstring") cmf_core::Richards::__iter__ "def +__iter__(self) "; -%feature("docstring") -cmf::atmosphere::MeteoStationList::MeteoStationList "MeteoStationList() +%feature("docstring") cmf_core::Richards::__repr__ "def +__repr__(self) "; -Create empty list. "; +%feature("docstring") cmf_core::Richards::conc "def conc(self, args, +kwargs) -%feature("docstring") -cmf::atmosphere::MeteoStationList::MeteoStationList "MeteoStationList(const MeteoStationList ©) +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -Copy c'tor. "; +%feature("docstring") cmf_core::Richards::exchange_target "def +exchange_target(self, args, kwargs) -%feature("docstring") cmf::atmosphere::MeteoStationList::add_station -"MeteoStation::ptr add_station(std::string name, cmf::geometry::point -position, double latitude=51.0, double longitude=8.0, double tz=1.0, -cmf::math::Time startTime=cmf::math::Time(1, 1, 2001), cmf::math::Time -timestep=cmf::math::day) +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -Creates a meteorological station at a certain position and adds it to -the list. +%feature("docstring") cmf_core::Richards::get_target "def +get_target(self, args) -Parameters: ------------ +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -name: Name of the station +%feature("docstring") cmf_core::Richards::get_tracer_filter "def +get_tracer_filter(self, args) -position: The location of the station in map coordinates +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -latitude: Latitude of the study area (for solar radiation) +%feature("docstring") cmf_core::Richards::kill_me "def kill_me(self, +args, kwargs) -longitude: Longitude of the study area (for solar time) +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -tz: Time zone of the study area (e.g Germany +1,U.S. Pacific time -8 +%feature("docstring") cmf_core::Richards::left_node "def +left_node(self, args, kwargs) -startTime: Date of the beginning of the climatic data (may be changed -for each time series later) +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -timestep: Frequency of climatic data (may be changed for each time -series later) "; +%feature("docstring") cmf_core::Richards::q "def q(self, args, +kwargs) -%feature("docstring") -cmf::atmosphere::MeteoStationList::calculate_Temp_lapse "double -calculate_Temp_lapse(cmf::math::Time begin, cmf::math::Time step, -cmf::math::Time end) +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; -Calculates the temperature lapse from all stations in the list and -sets the T_lapse attribute of each station. +%feature("docstring") cmf_core::Richards::refresh "def refresh(self, +args, kwargs) -Returns the average lapse over the whole period. "; +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; -%feature("docstring") -cmf::atmosphere::MeteoStationList::reference_to_nearest "MeteoStationReference reference_to_nearest(const cmf::geometry::point -&position, double z_weight=0) const +%feature("docstring") cmf_core::Richards::right_node "def +right_node(self, args, kwargs) -Creates a MeteoStationReference from the nearest station to position -at position. +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; -The distance is calculated as :math:`d=\\\\sqrt{(x_{s} - x_{l})^2 + (y_{s} - y_{l})^2} + \\\\lambda_z\\\\|z_{s} - z_{l}\\\\|` Where :math:`s` is the -station and :math:`l` is the locatable A Meteorology using the data of the -nearest station to position +%feature("docstring") cmf_core::Richards::set_tracer_filter "def +set_tracer_filter(self, args) -Parameters: ------------ +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; -position: The position (any locatable, like e.g. Cell possible) to -look for the station. The reference should be owned by the locatable +%feature("docstring") cmf_core::Richards::short_string "def +short_string(self, args, kwargs) -z_weight: The weight of the height difference :math:`\\\\lambda_z` "; +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -%feature("docstring") -cmf::atmosphere::MeteoStationList::remove_station "ptrdiff_t -remove_station(ptrdiff_t index) +%feature("docstring") cmf_core::Richards::to_string "def +to_string(self, args, kwargs) -Removes a station and returns the number of remaining references to -the removed station. If the station is deleted, 0 is returned. "; +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -%feature("docstring") cmf::atmosphere::MeteoStationList::size "size_t size() const +%feature("docstring") cmf_core::Richards::use_for_cell "def +use_for_cell(args, kwargs) -Returns the number of stations. "; +use_for_cell(Cell cell, bool no_override=True) "; -// File: classcmf_1_1atmosphere_1_1_meteo_station_reference.xml -%feature("docstring") cmf::atmosphere::MeteoStationReference " +// File: classcmf_1_1upslope_1_1connections_1_1_richards.xml +%feature("docstring") cmf::upslope::connections::Richards " -A reference to a meteorological station. +Calculates flow according to the Richards equation. -Returns the weather at a given time for its place using -MeteoStation::T_lapse -C++ includes: meteorology.h "; -%feature("docstring") -cmf::atmosphere::MeteoStationReference::MeteoStationReference "MeteoStationReference(MeteoStation::ptr station, cmf::geometry::point -location) +.. math:: -Create a located reference to a meteo station. + q_{Richards} &=& + \\\\frac{\\\\Delta\\\\Psi_{tot}}{d} K(\\\\theta) A \\\\\\\\ + \\\\Psi_{tot} &= &\\\\Psi_{M}(\\\\theta) + h -Parameters: ------------ + where +:math:`\\\\Delta\\\\Psi_{tot} [m]` is the difference of the total water +potentials of the two soil layers -station: MeteoStation +:math:`d [m]` is the distance between the two soil layers -location: Location of the reference "; +:math:`K(\\\\theta)\\\\left[\\\\frac m{day}\\\\right]` is the geometric +mean conductivity (see SoilType::Kunsat) -%feature("docstring") -cmf::atmosphere::MeteoStationReference::MeteoStationReference "MeteoStationReference(const MeteoStationReference ©) "; +:math:`A [m^2]` is the crosssectional area of the flux -%feature("docstring") cmf::atmosphere::MeteoStationReference::copy "MeteoStationReference* copy() const +:math:`\\\\Psi_M(\\\\theta) [m]` is the matrix potential (see +SoilType::MatrixPotential) -Returns a copy of the meteorology object. Pure virtual function, needs -to be implemented. "; +:math:`h [m]` is the height of a soil layer above sea level -%feature("docstring") -cmf::atmosphere::MeteoStationReference::get_instrument_height "real -get_instrument_height() const +C++ includes: Percolation.h "; -Creates a reference for a MeteoStation at a location. "; +%feature("docstring") cmf::upslope::connections::Richards::Richards "Richards(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr +right) -%feature("docstring") -cmf::atmosphere::MeteoStationReference::get_position "cmf::geometry::point get_position() const +Creates a Richards equation connection between two soil layers (left +and right, rather top and bottom) of the same cell. "; -Returns the position of the reference. "; +%feature("docstring") cmf::upslope::connections::Richards::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) -%feature("docstring") -cmf::atmosphere::MeteoStationReference::get_station "MeteoStation::ptr get_station() const +Returns the concentration of the flux. -Returns the station referenced. "; +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; %feature("docstring") -cmf::atmosphere::MeteoStationReference::get_weather "cmf::atmosphere::Weather get_weather(cmf::math::Time t) const +cmf::upslope::connections::Richards::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -Returns the weather at the time t. "; +%feature("docstring") cmf::upslope::connections::Richards::get_ptr "ptr get_ptr() const "; +%feature("docstring") cmf::upslope::connections::Richards::get_target +"flux_node::ptr get_target(const flux_node &inquirer) -// File: classcmf_1_1math_1_1_multi_integrator.xml -%feature("docstring") cmf::math::MultiIntegrator " +Returns the other end of a connection than the asking end. "; -The MultiIntegrator is a wrapper for a bunch integrators. The states -of the integrators should not have direct connections over integrator -boundaries. +%feature("docstring") cmf::upslope::connections::Richards::get_target +"flux_node::ptr get_target(int index) const -C++ includes: multiintegrator.h "; +With index 0, the left node is returned, with index 1 the right node +of the connection. "; -/* Accuracy parameters */ +%feature("docstring") +cmf::upslope::connections::Richards::get_tracer_filter "real +get_tracer_filter() -/* model time */ +A value ranging from 0 to 1 to filter tracers out of the water flux. -%feature("docstring") cmf::math::MultiIntegrator::get_t "cmf::math::Time get_t() const +1.0 is no filter and 0.0 means no solute is crossing this connection +"; -Returns the current model time. "; +%feature("docstring") +cmf::upslope::connections::Richards::get_tracer_filter "real +get_tracer_filter(solute S) -%feature("docstring") cmf::math::MultiIntegrator::set_t "void -set_t(cmf::math::Time val) +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; -Sets the current model time. "; +%feature("docstring") cmf::upslope::connections::Richards::kill_me "bool kill_me() -%feature("docstring") cmf::math::MultiIntegrator::get_dt "cmf::math::Time get_dt() const +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; -Returns the last time step. "; +%feature("docstring") cmf::upslope::connections::Richards::left_node +"flux_node::ptr left_node() const -/* Integrate */ +Returns the left node of this connection. "; -%feature("docstring") cmf::math::MultiIntegrator::integrate_until "void integrate_until(cmf::math::Time t_max, cmf::math::Time dt=Time(), -bool reset=false) +%feature("docstring") cmf::upslope::connections::Richards::q "real +q(const flux_node &inquirer, cmf::math::Time t) -Integrates the vector of state variables until t_max. +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; -Parameters: ------------ +%feature("docstring") cmf::upslope::connections::Richards::refresh "void refresh(cmf::math::Time t) -t_max: Time, the solver should run to +Performes a new calculation of the flux. "; -dt: Time step (may be omitted) +%feature("docstring") cmf::upslope::connections::Richards::right_node +"flux_node::ptr right_node() const -reset: If true, solver is reseted before integration starts "; +returns the right node of this connection "; -%feature("docstring") cmf::math::MultiIntegrator::MultiIntegrator "MultiIntegrator(const cmf::math::Integrator &template_integrator, int -count) +%feature("docstring") +cmf::upslope::connections::Richards::set_tracer_filter "void +set_tracer_filter(real value) -Creates a new MultiIntegrator. +A value ranging from 0 to 1 to filter tracers out of the water flux. -Parameters: ------------ +1.0 is no filter and 0.0 means no solute is crossing this connection +"; -template_integrator: Template for the integrators +%feature("docstring") +cmf::upslope::connections::Richards::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; -count: Number of integrators "; +%feature("docstring") +cmf::upslope::connections::Richards::short_string "virtual +std::string short_string() const "; -%feature("docstring") cmf::math::MultiIntegrator::add_single_state "virtual void add_single_state(cmf::math::StateVariable::ptr state) +%feature("docstring") cmf::upslope::connections::Richards::to_string +"virtual std::string to_string() const "; -Adds a single state variable to the integrator. "; -%feature("docstring") cmf::math::MultiIntegrator::add_states "void -add_states(cmf::math::StateVariableOwner &stateOwner) +// File: classcmf__core_1_1_richards__lateral.xml +%feature("docstring") cmf_core::Richards_lateral " -Only there to override Integrator::AddStatesFromOwner. Throws an -exception. Use add_states_to_integrator instead. "; +Calculates the flux using Richard's equation for adjacent layers .. +math:: q_{lat} = \\\\\\\\frac{\\\\\\\\Psi_1 - +\\\\\\\\Psi_2}{\\\\\\\\|C_1-C_2\\\\\\\\|} K(\\\\\\\\theta) A +where: :math:`q_{lat}` the lateral flow in :math:`m^3/day` +:math:`\\\\\\\\Psi_i` the head of node i +:math:`\\\\\\\\|C_1-C_2\\\\\\\\|` is the distance from Cell 1 to Cell +2 :math:`K(\\\\\\\\theta_{1,2}) = \\\\\\\\sqrt{K(\\\\\\\\theta_1) +K(\\\\\\\\theta_2)}` :math:`A` the crosssectional area of the +interface between storages 1 and 2 C++ includes: subsurfacefluxes.h +"; -%feature("docstring") -cmf::math::MultiIntegrator::add_states_to_integrator "void -add_states_to_integrator(cmf::math::StateVariableOwner &stateOwner, -int integrator_position) +%feature("docstring") cmf_core::Richards_lateral::__init__ "def +__init__(self, args, kwargs) -Add state variables from a StateVariableOwner. "; +__init__(cmf::upslope::connections::Richards_lateral self, +cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right, +real FlowWidth=0, real Distance=0) -> Richards_lateral +Richards_lateral(cmf::upslope::SoilLayer::ptr left, +cmf::water::flux_node::ptr right, real FlowWidth=0, real Distance=0) +Creates the connection. Parameters: ----------- left: Left node of +the connection (needs to be soil water storage) right: Right node of +the connection (can be any node) FlowWidth: the width of the +connection - is multiplied by layer thickness to get the interface +area Distance: the length of the connection. If 0, the distance is +calculated from the position of the nodes "; -%feature("docstring") -cmf::math::MultiIntegrator::add_values_to_states "void -add_values_to_states(const num_array &operands) +%feature("docstring") cmf_core::Richards_lateral::__contains__ "def +__contains__(self, cmp) "; -Adds the values in operands to the current states. "; +%feature("docstring") cmf_core::Richards_lateral::__eq__ "def +__eq__(self, args, kwargs) -%feature("docstring") cmf::math::MultiIntegrator::copy "virtual -cmf::math::MultiIntegrator* copy() const +__eq__(flux_connection self, flux_connection other) -> bool "; -Polymorphic copy constructor. "; +%feature("docstring") cmf_core::Richards_lateral::__getitem__ "def +__getitem__(self, index) "; -%feature("docstring") cmf::math::MultiIntegrator::copy_dxdt "void -copy_dxdt(Time time, num_array &destination, real factor=1) const +%feature("docstring") cmf_core::Richards_lateral::__iter__ "def +__iter__(self) "; -Copies the derivatives at time step \"time\" to a numeric vector using -use_OpenMP. +%feature("docstring") cmf_core::Richards_lateral::__repr__ "def +__repr__(self) "; -Parameters: ------------ +%feature("docstring") cmf_core::Richards_lateral::conc "def +conc(self, args, kwargs) -time: Time at which the derivatives should be calculated +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -destination: Vector to be overwritten by the results +%feature("docstring") cmf_core::Richards_lateral::exchange_target "def exchange_target(self, args, kwargs) -factor: A factor that is multiplied to the derivate (e.g. unit -conversion or integration length) "; +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") cmf::math::MultiIntegrator::copy_dxdt "void -copy_dxdt(Time time, real *destination, real factor=1) const +%feature("docstring") cmf_core::Richards_lateral::get_target "def +get_target(self, args) -Copies the derivatives at time step \"time\" to an preallocated c -array. +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -Parameters: ------------ +%feature("docstring") cmf_core::Richards_lateral::get_tracer_filter "def get_tracer_filter(self, args) -time: Time at which the derivatives should be calculated +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -destination: Allocated c array +%feature("docstring") cmf_core::Richards_lateral::kill_me "def +kill_me(self, args, kwargs) -factor: A factor that is multiplied to the derivate (e.g. unit -conversion or integration length) "; +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -%feature("docstring") cmf::math::MultiIntegrator::copy_states "void -copy_states(num_array &destination) const +%feature("docstring") cmf_core::Richards_lateral::left_node "def +left_node(self, args, kwargs) -Copies the states to a numeric vector using use_OpenMP. "; +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -%feature("docstring") cmf::math::MultiIntegrator::copy_states "void -copy_states(real *destination) const "; +%feature("docstring") cmf_core::Richards_lateral::q "def q(self, +args, kwargs) -%feature("docstring") cmf::math::MultiIntegrator::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; -%feature("docstring") cmf::math::MultiIntegrator::get_state "real -get_state(ptrdiff_t position) const +%feature("docstring") cmf_core::Richards_lateral::refresh "def +refresh(self, args, kwargs) -Returns the statevariable at position Simplifies the assessment of -state variables. "; +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; -%feature("docstring") cmf::math::MultiIntegrator::get_states "cmf::math::num_array get_states() const "; +%feature("docstring") cmf_core::Richards_lateral::right_node "def +right_node(self, args, kwargs) -%feature("docstring") cmf::math::MultiIntegrator::get_states "StateVariableList get_states() +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; -gets the state variables of the integrator "; +%feature("docstring") cmf_core::Richards_lateral::set_tracer_filter "def set_tracer_filter(self, args) -%feature("docstring") cmf::math::MultiIntegrator::integrate "int -integrate(cmf::math::Time t_max, cmf::math::Time dt) +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; -Integrates the vector of state variables. +%feature("docstring") cmf_core::Richards_lateral::short_string "def +short_string(self, args, kwargs) -Parameters: ------------ +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -t_max: To stop the model (if running in a model framework) at time -steps of value exchange e.g. full hours, the next value exchange time -can be given +%feature("docstring") cmf_core::Richards_lateral::to_string "def +to_string(self, args, kwargs) -dt: Takes the proposed time step, and changes it into the effectively -used time step according to the local stiffness of the problem and -MaxTime "; +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -%feature("docstring") cmf::math::MultiIntegrator::reset "virtual -void reset() +%feature("docstring") cmf_core::Richards_lateral::usebaseflow "def +usebaseflow(args, kwargs) -Resets the integrator. "; +usebaseflow(bool use) "; -%feature("docstring") cmf::math::MultiIntegrator::set_state "void -set_state(ptrdiff_t position, real newState) -Simplifies the assessment of state variables. "; +// File: classcmf_1_1upslope_1_1connections_1_1_richards__lateral.xml +%feature("docstring") cmf::upslope::connections::Richards_lateral " -%feature("docstring") cmf::math::MultiIntegrator::set_states "void -set_states(const num_array &newStates) +Calculates the flux using Richard's equation for adjacent layers -Copies the new states to the actual states. "; +.. math:: -%feature("docstring") cmf::math::MultiIntegrator::set_states "void -set_states(real *newStates) "; + + q_{lat} = \\\\frac{\\\\Psi_1 - \\\\Psi_2}{\\\\|C_1-C_2\\\\|} + K(\\\\theta) A -%feature("docstring") cmf::math::MultiIntegrator::size "size_t -size() const +where: -returns the number of state variables "; +:math:`q_{lat}` the lateral flow in :math:`m^3/day` +:math:`\\\\Psi_i` the head of node i -// File: classcmf_1_1maps_1_1_nearest_neighbor_map.xml -%feature("docstring") cmf::maps::NearestNeighborMap " +:math:`\\\\|C_1-C_2\\\\|` is the distance from Cell 1 to Cell 2 -A map (spatial distribution of data) returning the nearest neighbor to -the queried position Stores position referenced objects. z_weight is -a weight, how important vertical differences are for neighborhood. 0 -means only horizontal distance and a high value only uses the height -as a distance measure. The distance to be minimized is calculated as: -sqrt((x1-x2)**2+(y1-y2)**2)+abs(z1-z2)*z_weight "; +:math:`K(\\\\theta_{1,2}) = \\\\sqrt{K(\\\\theta_1) K(\\\\theta_2)}` -%feature("docstring") cmf::maps::NearestNeighborMap::__init__ "def -__init__(self, z_weight=0) "; +:math:`A` the crosssectional area of the interface between storages 1 and 2 -%feature("docstring") cmf::maps::NearestNeighborMap::__call__ "def -__call__(self, x, y, z=0) +C++ includes: subsurfacefluxes.h "; -returns the nearest neighbor object to the given position The -distance to be minimized is calculated as: -sqrt((x1-x2)**2+(y1-y2)**2)+abs(z1-z2)*z_weight "; +%feature("docstring") +cmf::upslope::connections::Richards_lateral::Richards_lateral "Richards_lateral(cmf::upslope::SoilLayer::ptr left, +cmf::water::flux_node::ptr right, real FlowWidth=0, real Distance=0) -%feature("docstring") cmf::maps::NearestNeighborMap::__iter__ "def -__iter__(self) "; +Creates the connection. -%feature("docstring") cmf::maps::NearestNeighborMap::__nonzero__ "def __nonzero__(self) "; +Parameters: +----------- -%feature("docstring") cmf::maps::NearestNeighborMap::append "def -append(self, position, object) "; +left: Left node of the connection (needs to be soil water storage) -%feature("docstring") cmf::maps::NearestNeighborMap::remove "def -remove(self, position) "; +right: Right node of the connection (can be any node) -%feature("docstring") cmf::maps::NearestNeighborMap::values "def -values(self) "; +FlowWidth: the width of the connection - is multiplied by layer +thickness to get the interface area +Distance: the length of the connection. If 0, the distance is +calculated from the position of the nodes "; -// File: classcmf_1_1upslope_1_1neighbor__iterator.xml -%feature("docstring") cmf::upslope::neighbor_iterator " +%feature("docstring") +cmf::upslope::connections::Richards_lateral::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) -A class to iterate through the neighbors of a cell (const). Not needed -from the Python side, use the generator cell.neighbors instead. +Returns the concentration of the flux. -C++ includes: Topology.h "; +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; %feature("docstring") -cmf::upslope::neighbor_iterator::neighbor_iterator "neighbor_iterator(cmf::upslope::Topology &topo) "; +cmf::upslope::connections::Richards_lateral::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; %feature("docstring") -cmf::upslope::neighbor_iterator::neighbor_iterator "neighbor_iterator(cmf::upslope::Cell *cell) "; - -%feature("docstring") cmf::upslope::neighbor_iterator::cell "Cell& -cell() "; - -%feature("docstring") cmf::upslope::neighbor_iterator::flowwidth "double flowwidth() "; +cmf::upslope::connections::Richards_lateral::get_ptr "ptr get_ptr() +const "; -%feature("docstring") cmf::upslope::neighbor_iterator::next_neighbor -"neighbor_iterator& next_neighbor() +%feature("docstring") +cmf::upslope::connections::Richards_lateral::get_target "flux_node::ptr get_target(const flux_node &inquirer) -Points the iterator to the next neighbor. "; +Returns the other end of a connection than the asking end. "; -%feature("docstring") cmf::upslope::neighbor_iterator::valid "bool -valid() const "; +%feature("docstring") +cmf::upslope::connections::Richards_lateral::get_target "flux_node::ptr get_target(int index) const +With index 0, the left node is returned, with index 1 the right node +of the connection. "; -// File: classcmf_1_1water_1_1_neumann_boundary.xml -%feature("docstring") cmf::water::NeumannBoundary " +%feature("docstring") +cmf::upslope::connections::Richards_lateral::get_tracer_filter "real +get_tracer_filter() -A Neumann boundary condition (constant flux boundary condition) +A value ranging from 0 to 1 to filter tracers out of the water flux. -The flux is a timeseries, but can be used as a scalar. To scale the -timeseries to the specific conditions of this boundary condition the -linear_scale flux_scale can be used. +1.0 is no filter and 0.0 means no solute is crossing this connection +"; -C++ includes: boundary_condition.h "; +%feature("docstring") +cmf::upslope::connections::Richards_lateral::get_tracer_filter "real +get_tracer_filter(solute S) -%feature("docstring") cmf::water::NeumannBoundary::NeumannBoundary "NeumannBoundary(cmf::project &_project, cmf::math::timeseries _flux, -cmf::water::SoluteTimeseries -_concentration=cmf::water::SoluteTimeseries(), cmf::geometry::point -loc=cmf::geometry::point()) +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; -Ctor of the Neumann boundary. +%feature("docstring") +cmf::upslope::connections::Richards_lateral::kill_me "bool kill_me() -Parameters: ------------ +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; -_project: The project this boundary condition belongs to +%feature("docstring") +cmf::upslope::connections::Richards_lateral::left_node "flux_node::ptr left_node() const -_flux: The flux timeseries (a scalar is converted to a timeseries -automatically) +Returns the left node of this connection. "; -_concentration: The concentration timeseries +%feature("docstring") cmf::upslope::connections::Richards_lateral::q +"real q(const flux_node &inquirer, cmf::math::Time t) -loc: The location of the boundary condition "; +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; -%feature("docstring") cmf::water::NeumannBoundary::NeumannBoundary "NeumannBoundary(cmf::project &_project, cmf::geometry::point -loc=cmf::geometry::point()) "; +%feature("docstring") +cmf::upslope::connections::Richards_lateral::refresh "void +refresh(cmf::math::Time t) -%feature("docstring") cmf::water::NeumannBoundary::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) const +Performes a new calculation of the flux. "; -Returns the solute concentrations of the flux at a given time. "; +%feature("docstring") +cmf::upslope::connections::Richards_lateral::right_node "flux_node::ptr right_node() const -%feature("docstring") cmf::water::NeumannBoundary::connect_to "void -connect_to(cmf::water::flux_node::ptr target) "; +returns the right node of this connection "; -%feature("docstring") cmf::water::NeumannBoundary::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node -&target) +%feature("docstring") +cmf::upslope::connections::Richards_lateral::set_tracer_filter "void +set_tracer_filter(real value) -Returns the connection between this and target. "; +A value ranging from 0 to 1 to filter tracers out of the water flux. -%feature("docstring") cmf::water::NeumannBoundary::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, -cmf::math::Time t) "; +1.0 is no filter and 0.0 means no solute is crossing this connection +"; -%feature("docstring") cmf::water::NeumannBoundary::flux_to "real -flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +%feature("docstring") +cmf::upslope::connections::Richards_lateral::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; -Returns the actual flux between this and target (positive sign means -\"from this into target\") "; +%feature("docstring") +cmf::upslope::connections::Richards_lateral::short_string "virtual +std::string short_string() const "; -%feature("docstring") cmf::water::NeumannBoundary::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) +%feature("docstring") +cmf::upslope::connections::Richards_lateral::to_string "virtual +std::string to_string() const "; -Returns the sum of all flux vectors. "; -%feature("docstring") cmf::water::NeumannBoundary::get_connections "cmf::water::connection_list get_connections() const "; +// File: classcmf__core_1_1_r_k_f_integrator.xml +%feature("docstring") cmf_core::RKFIntegrator " -%feature("docstring") cmf::water::NeumannBoundary::get_flux "cmf::math::timeseries get_flux() +Integrates a vector of cmf::math::StateVariable with the Runge-Kutta- +Fehlberg (RKF54) method. C++ includes: RKFintegrator.h "; -The timeseries of the boundary flux. "; +%feature("docstring") cmf_core::RKFIntegrator::__init__ "def +__init__(self, args) -%feature("docstring") cmf::water::NeumannBoundary::get_potential "virtual real get_potential() const +__init__(cmf::math::RKFIntegrator self, StateVariableOwner states, +real epsilon=1e-9, Time dt_min) -> RKFIntegrator +__init__(cmf::math::RKFIntegrator self, real epsilon=1e-9, Time +dt_min) -> RKFIntegrator RKFIntegrator(real epsilon=1e-9, +cmf::math::Time dt_min=cmf::math::timespan(1000)) Constructs a new +RKFIntegrator. Parameters: ----------- epsilon: relative error +tolerance per time step (default=1e-9) dt_min: minimum time step +(default=1s) "; -Returns the water potential of the node in m waterhead. +%feature("docstring") cmf_core::RKFIntegrator::__call__ "def +__call__(self, t, dt=None, reset=False) -The base class water storage always returns the height of the location -"; +Advances the integration until `t` A shortcut to .integrate_until +Parameters ---------- t : cmf.Time The time step to advance to. If +t < current time, the solver will advance to self.t + t dt : +cmf.Time, optional The timestep for the integration. If not given +try to integrate in one step reset : bool, optional If True, the +solver will perform a reset before starting Returns ------- cmf.Time +The new time stamp "; -%feature("docstring") cmf::water::NeumannBoundary::get_project "cmf::project& get_project() const +%feature("docstring") cmf_core::RKFIntegrator::__getitem__ "def +__getitem__(self, args, kwargs) -Returns the project, this node is part of. "; +__getitem__(Integrator self, long position) -> +cmf::math::StateVariable::ptr "; -%feature("docstring") cmf::water::NeumannBoundary::is_empty "double -is_empty() const +%feature("docstring") cmf_core::RKFIntegrator::__len__ "def +__len__(self, args, kwargs) -Returns true if the node has no water. "; +__len__(Integrator self) -> size_t "; -%feature("docstring") cmf::water::NeumannBoundary::is_storage "virtual bool is_storage() const +%feature("docstring") cmf_core::RKFIntegrator::__repr__ "def +__repr__(self) "; -true, if this is a waterstorage "; +%feature("docstring") cmf_core::RKFIntegrator::add_single_state "def +add_single_state(self, args, kwargs) -%feature("docstring") cmf::water::NeumannBoundary::RecalcFluxes "bool RecalcFluxes(cmf::math::Time t) +add_single_state(Integrator self, cmf::math::StateVariable::ptr state) +virtual void add_single_state(cmf::math::StateVariable::ptr state) +Adds a single state variable to the integrator. "; -Pure flux_nodes do not influence fluxes, therefore no recalculation of -fluxes is required by flux_node. +%feature("docstring") cmf_core::RKFIntegrator::add_states "def +add_states(self, args, kwargs) -WaterStorage overrides this, since state changes require an update of -the fluxes "; +add_states(Integrator self, StateVariableOwner stateOwner) virtual +void add_states(cmf::math::StateVariableOwner &stateOwner) Add state +variables from a StateVariableOwner. "; -%feature("docstring") cmf::water::NeumannBoundary::remove_connection -"bool remove_connection(cmf::water::flux_node::ptr To) +%feature("docstring") cmf_core::RKFIntegrator::copy "def copy(self, +args, kwargs) -Remove the connection. "; +copy(Integrator self) -> Integrator virtual Integrator* copy() const +=0 Polymorphic copy constructor. "; -%feature("docstring") cmf::water::NeumannBoundary::set_flux "void -set_flux(cmf::math::timeseries new_flux) +%feature("docstring") cmf_core::RKFIntegrator::get_dt "def +get_dt(self, args, kwargs) -Set a timeseries as the boundary flux. "; +get_dt(Integrator self) -> Time cmf::math::Time get_dt() const +Returns the last time step. "; -%feature("docstring") cmf::water::NeumannBoundary::set_flux "void -set_flux(double new_flux) +%feature("docstring") cmf_core::RKFIntegrator::get_dxdt "def +get_dxdt(self, args, kwargs) -Set a constant as the boundary flux. "; +get_dxdt(Integrator self, Time time) -> cmf::math::num_array +cmf::math::num_array get_dxdt(Time time) const "; -%feature("docstring") cmf::water::NeumannBoundary::set_potential "virtual void set_potential(real new_potential) +%feature("docstring") cmf_core::RKFIntegrator::get_state "def +get_state(self, args, kwargs) -Sets the potential of this flux node. "; +get_state(Integrator self, ptrdiff_t position) -> real real +get_state(ptrdiff_t position) const Returns the statevariable at +position Simplifies the assessment of state variables. "; -%feature("docstring") cmf::water::NeumannBoundary::to_string "virtual std::string to_string() const "; +%feature("docstring") cmf_core::RKFIntegrator::get_states "def +get_states(self, args) -%feature("docstring") cmf::water::NeumannBoundary::waterbalance "real waterbalance(cmf::math::Time t, const flux_connection *Without=0) -const +get_states(Integrator self) -> cmf::math::num_array +get_states(Integrator self) -> StateVariableList StateVariableList +get_states() gets the state variables of the integrator "; -Returns the sum of all fluxes (positive and negative) at time t. +%feature("docstring") cmf_core::RKFIntegrator::get_t "def +get_t(self, args, kwargs) -Single fluxes can be excluded from the calculation +get_t(Integrator self) -> Time cmf::math::Time get_t() const Returns +the current model time. "; -Parameters: ------------ +%feature("docstring") cmf_core::RKFIntegrator::integrate "def +integrate(self, args, kwargs) -t: Time of the query +integrate(Integrator self, Time t_max, Time dt) -> int virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt)=0 Integrates the +vector of state variables. Parameters: ----------- t_max: To stop +the model (if running in a model framework) at time steps of value +exchange e.g. full hours, the next value exchange time can be given +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; -Without: A flux_connection that is excluded from the waterbalance -(e.g. to prevent closed circuits) "; +%feature("docstring") cmf_core::RKFIntegrator::integrate_until "def +integrate_until(self, args, kwargs) +integrate_until(Integrator self, Time t_max, Time dt, bool +reset=False) void integrate_until(cmf::math::Time t_max, +cmf::math::Time dt=Time(), bool reset=false) Integrates the vector of +state variables until t_max. Parameters: ----------- t_max: Time, +the solver should run to dt: Time step (may be omitted) reset: If +true, solver is reseted before integration starts "; -// File: classcmf_1_1water_1_1_neumann_boundary__list.xml -%feature("docstring") cmf::water::NeumannBoundary_list " +%feature("docstring") cmf_core::RKFIntegrator::reset "def +reset(self, args, kwargs) -Provides fast access to Neumann boundaries for flux update. +reset(Integrator self) virtual void reset() Resets any saved history +(for multistep methods) "; -If many Neumann boundary conditions are present in a project, a fast -data exchange to update the fluxes might be needed. +%feature("docstring") cmf_core::RKFIntegrator::run "def run(self, +start=None, end=None, step=day *1, max_errors=0, reset=False) -With this specialized list a num_array can be passed to the boundary -conditions for a fast flux update If a multiple system layout for the -cmf setup is chosen, we might have a node_list Dirichlet boundary -conditions (dbc), a corresponding NeumannBoundary_list (nbc) of -Neumann boundaries and a node_list containing the storages connected -with the NeumannBoundary_list (storages). The fast data exchange is -written in Python as: +Returns an iterator over the timesteps start..end **Examples:** >>> +solver=cmf.CVodeIntegrator(...) >>> for t in solver.run(solver.t, +solver.t + cmf.week, cmf.h): >>> print(t, solver[0].state) or with +list comprehension >>> states = [solver[0].state for t in +solver.run(solver.t, solver.t + cmf.week, cmf.h)] Parameters +---------- start : cmf.Time, optional Start time for the solver +iteration end : cmf.Time, optional End time of the iteration step : +cmf.Time, optional Step size for the integration max_errors: int +Number of tolerated errors. If >0, up to these number of runtime +errors will be saved with their time and the integration proceeds +after a reset of the solver. Some systems operate with values close to +their physical limits and inifinite values in the integration can +easily occur. For these kind of systems set max_errors to eg. 10. A +larger number of errors should be eliminated usually. reset: bool If +True, the solver performs a `reset` at every time step Yields ------ +cmf.Time the actual timestep "; -C++ includes: collections.h "; +%feature("docstring") cmf_core::RKFIntegrator::set_state "def +set_state(self, args, kwargs) -%feature("docstring") -cmf::water::NeumannBoundary_list::NeumannBoundary_list "NeumannBoundary_list() "; +set_state(Integrator self, ptrdiff_t position, real newState) void +set_state(ptrdiff_t position, real newState) Simplifies the +assessment of state variables. "; -%feature("docstring") -cmf::water::NeumannBoundary_list::NeumannBoundary_list "NeumannBoundary_list(const cmf::water::node_list ©) "; +%feature("docstring") cmf_core::RKFIntegrator::set_t "def +set_t(self, args, kwargs) -%feature("docstring") -cmf::water::NeumannBoundary_list::NeumannBoundary_list "NeumannBoundary_list(const NeumannBoundary_list ©) "; +set_t(Integrator self, Time val) void set_t(cmf::math::Time val) Sets +the current model time. "; -%feature("docstring") cmf::water::NeumannBoundary_list::append "void -append(NeumannBoundary::ptr nbc) +%feature("docstring") cmf_core::RKFIntegrator::size "def size(self, +args, kwargs) -Appends a neumann boundary to this list. "; +size(Integrator self) -> size_t size_t size() const returns the +number of state variables "; -%feature("docstring") cmf::water::NeumannBoundary_list::get "NeumannBoundary::ptr get(ptrdiff_t index) const -Returns the Neumann boundary condition at position index. +// File: classcmf_1_1math_1_1_r_k_f_integrator.xml +%feature("docstring") cmf::math::RKFIntegrator " -From Python you can use [] "; +Integrates a vector of cmf::math::StateVariable with the Runge-Kutta- +Fehlberg (RKF54) method. -%feature("docstring") cmf::water::NeumannBoundary_list::get_fluxes "cmf::math::num_array get_fluxes(cmf::math::Time t=cmf::math::Time()) -const +C++ includes: RKFintegrator.h "; -Returns the fluxes of the items as an array. +/* Accuracy parameters */ -get_fluxes and set_fluxes are wrapped with the Python property fluxes -"; +/* model time */ -%feature("docstring") -cmf::water::NeumannBoundary_list::global_water_balance "real -global_water_balance(cmf::math::Time t) const +%feature("docstring") cmf::math::RKFIntegrator::get_t "cmf::math::Time get_t() const -Returns the sum of the water balances of the nodes +Returns the current model time. "; +%feature("docstring") cmf::math::RKFIntegrator::set_t "void +set_t(cmf::math::Time val) -.. math:: +Sets the current model time. "; - \\\\sigma_{global} = - \\\\sum_{i=0}^N{\\\\sum_{j=0}^{C_i}{q_{ij}(t)}} +%feature("docstring") cmf::math::RKFIntegrator::get_dt "cmf::math::Time get_dt() const -. +Returns the last time step. "; -Replaces slow Python code like: "; +%feature("docstring") cmf::math::RKFIntegrator::reset "virtual void +reset() -%feature("docstring") cmf::water::NeumannBoundary_list::set_fluxes "void set_fluxes(cmf::math::num_array values) +Resets any saved history (for multistep methods) "; -Sets the fluxes of the items from an array. +/* Integrate */ -get_fluxes and set_fluxes are wrapped with the Python property fluxes -"; +%feature("docstring") cmf::math::RKFIntegrator::integrate_until "void integrate_until(cmf::math::Time t_max, cmf::math::Time dt=Time(), +bool reset=false) -%feature("docstring") cmf::water::NeumannBoundary_list::size "size_t -size() const +Integrates the vector of state variables until t_max. -returns the number of stored boundary conditions "; +Parameters: +----------- -%feature("docstring") cmf::water::NeumannBoundary_list::to_node_list -"cmf::water::node_list to_node_list() const +t_max: Time, the solver should run to -Creates a node_list from this NeumannBoundary_list. "; +dt: Time step (may be omitted) -%feature("docstring") cmf::water::NeumannBoundary_list::water_balance -"cmf::math::num_array water_balance(cmf::math::Time t) const +reset: If true, solver is reseted before integration starts "; -Returns the water balance of each vector as a vector +%feature("docstring") cmf::math::RKFIntegrator::RKFIntegrator "RKFIntegrator(StateVariableOwner &states, real epsilon=1e-9, +cmf::math::Time dt_min=cmf::math::timespan(1000)) -.. math:: +Constructs a new RKFIntegrator from a pointer to a vector of state +variables. - \\\\sigma_i - = \\\\sum_{j=0}^{C_i}{q_{ij}(t)} +The RKF Integrator becomes the owner of states -. +Parameters: +----------- -Replaces slow Python code like: "; +states: Statevariables of the system +epsilon: relative error tolerance per time step (default=1e-9) -// File: classcmf_1_1water_1_1_neumann_flux.xml -%feature("docstring") cmf::water::NeumannFlux " +dt_min: minimum time step (default=1s) "; -Connection between Neumann-boundary and a flux node. +%feature("docstring") cmf::math::RKFIntegrator::RKFIntegrator "RKFIntegrator(real epsilon=1e-9, cmf::math::Time +dt_min=cmf::math::timespan(1000)) -This flux_connection is created, when connecting a Neumann boundary -condition with a state variable using Neumann::connect_to +Constructs a new RKFIntegrator. -C++ includes: boundary_condition.h "; +Parameters: +----------- -%feature("docstring") cmf::water::NeumannFlux::NeumannFlux "NeumannFlux(std::shared_ptr< NeumannBoundary > left, -cmf::water::flux_node::ptr right) "; +epsilon: relative error tolerance per time step (default=1e-9) -%feature("docstring") cmf::water::NeumannFlux::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +dt_min: minimum time step (default=1s) "; -Returns the concentration of the flux. +%feature("docstring") cmf::math::RKFIntegrator::add_single_state "virtual void add_single_state(cmf::math::StateVariable::ptr state) -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +Adds a single state variable to the integrator. "; -%feature("docstring") cmf::water::NeumannFlux::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +%feature("docstring") cmf::math::RKFIntegrator::add_states "void +add_states(cmf::math::StateVariableOwner &stateOwner) -%feature("docstring") cmf::water::NeumannFlux::get_ptr "ptr -get_ptr() const "; +Adds states from an StateVariableOwner. "; -%feature("docstring") cmf::water::NeumannFlux::get_target "flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") cmf::math::RKFIntegrator::add_values_to_states +"void add_values_to_states(const num_array &operands) -Returns the other end of a connection than the asking end. "; +Adds the values in operands to the current states. "; -%feature("docstring") cmf::water::NeumannFlux::get_target "flux_node::ptr get_target(int index) const +%feature("docstring") cmf::math::RKFIntegrator::copy "virtual +Integrator* copy() const -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +Polymorphic copy constructor. "; -%feature("docstring") cmf::water::NeumannFlux::get_tracer_filter "real get_tracer_filter() +%feature("docstring") cmf::math::RKFIntegrator::copy_dxdt "void +copy_dxdt(Time time, num_array &destination, real factor=1) const -A value ranging from 0 to 1 to filter tracers out of the water flux. +Copies the derivatives at time step \"time\" to a numeric vector using +use_OpenMP. -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +Parameters: +----------- -%feature("docstring") cmf::water::NeumannFlux::get_tracer_filter "real get_tracer_filter(solute S) +time: Time at which the derivatives should be calculated -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +destination: Vector to be overwritten by the results -%feature("docstring") cmf::water::NeumannFlux::kill_me "bool -kill_me() +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +%feature("docstring") cmf::math::RKFIntegrator::copy_dxdt "void +copy_dxdt(Time time, real *destination, real factor=1) const -%feature("docstring") cmf::water::NeumannFlux::left_node "flux_node::ptr left_node() const +Copies the derivatives at time step \"time\" to an preallocated c +array. -Returns the left node of this connection. "; +Parameters: +----------- -%feature("docstring") cmf::water::NeumannFlux::q "real q(const -flux_node &inquirer, cmf::math::Time t) +time: Time at which the derivatives should be calculated -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +destination: Allocated c array -%feature("docstring") cmf::water::NeumannFlux::refresh "void -refresh(cmf::math::Time t) +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; -Performes a new calculation of the flux. "; +%feature("docstring") cmf::math::RKFIntegrator::copy_states "void +copy_states(num_array &destination) const -%feature("docstring") cmf::water::NeumannFlux::right_node "flux_node::ptr right_node() const +Copies the states to a numeric vector using use_OpenMP. "; -returns the right node of this connection "; +%feature("docstring") cmf::math::RKFIntegrator::copy_states "void +copy_states(real *destination) const "; -%feature("docstring") cmf::water::NeumannFlux::set_tracer_filter "void set_tracer_filter(real value) +%feature("docstring") cmf::math::RKFIntegrator::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; -A value ranging from 0 to 1 to filter tracers out of the water flux. +%feature("docstring") cmf::math::RKFIntegrator::get_state "real +get_state(ptrdiff_t position) const -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +Returns the statevariable at position Simplifies the assessment of +state variables. "; -%feature("docstring") cmf::water::NeumannFlux::set_tracer_filter "void set_tracer_filter(solute S, real value) "; +%feature("docstring") cmf::math::RKFIntegrator::get_states "cmf::math::num_array get_states() const "; -%feature("docstring") cmf::water::NeumannFlux::short_string "virtual -std::string short_string() const "; +%feature("docstring") cmf::math::RKFIntegrator::get_states "StateVariableList get_states() -%feature("docstring") cmf::water::NeumannFlux::to_string "virtual -std::string to_string() const "; +gets the state variables of the integrator "; +%feature("docstring") cmf::math::RKFIntegrator::integrate "int +integrate(cmf::math::Time MaxTime, cmf::math::Time TimeStep) -// File: classcmf_1_1water_1_1node__list.xml -%feature("docstring") cmf::water::node_list " +Integrates the vector of state variables. -A collection of nodes for fast access of the waterbalance. +Parameters: +----------- -In setups with many storages and rather fast computations, the speed -of data access for output generation can take a high portion of the -total run time. To accelerate data access, one can use the node_list -object +MaxTime: To stop the model (if running in a model framework) at time +steps of value exchange e.g. full hours, the next value exchange time +can be given -Todo Add a get_volume / set_volume function pair, to complement -get_potential / set_potential +TimeStep: Takes the proposed timestep, and changes it into the +effictivly used timestep according to the local stiffness of the +problem and MaxTime "; -C++ includes: collections.h "; +%feature("docstring") cmf::math::RKFIntegrator::set_state "void +set_state(ptrdiff_t position, real newState) -%feature("docstring") cmf::water::node_list::node_list "node_list() +Simplifies the assessment of state variables. "; -Creates an empty node_lust. "; +%feature("docstring") cmf::math::RKFIntegrator::set_states "void +set_states(const num_array &newStates) -%feature("docstring") cmf::water::node_list::node_list "node_list(const cmf::water::node_list &forcopy) +Copies the new states to the actual states. "; -Copy the node_list. "; +%feature("docstring") cmf::math::RKFIntegrator::set_states "void +set_states(real *newStates) "; -%feature("docstring") cmf::water::node_list::~node_list "virtual -~node_list() "; +%feature("docstring") cmf::math::RKFIntegrator::size "size_t size() +const -%feature("docstring") cmf::water::node_list::append "void -append(flux_node::ptr node) +returns the number of state variables "; -Adds a flux node to the list. "; -%feature("docstring") cmf::water::node_list::begin "node_vector::iterator begin() "; +// File: classcmf_1_1upslope_1_1_e_t_1_1_root_uptake_stess_function.xml +%feature("docstring") cmf::upslope::ET::RootUptakeStessFunction " -%feature("docstring") cmf::water::node_list::begin "node_vector::const_iterator begin() const "; +An abstract class to calculate the actual transpiration from potential +transpiration. -%feature("docstring") cmf::water::node_list::conc "cmf::math::num_array conc(cmf::math::Time t, const cmf::water::solute -&_Solute) const +Implementations of WaterStressFunction are used by ET connections +derived from cmf::upslope::ET::stressedET -Returns an array holding the concentration of all the flux nodes for -the given solute. "; +C++ includes: waterstress.h "; -%feature("docstring") cmf::water::node_list::end "node_vector::iterator end() "; +%feature("docstring") +cmf::upslope::ET::RootUptakeStessFunction::~RootUptakeStessFunction "virtual ~RootUptakeStessFunction() "; -%feature("docstring") cmf::water::node_list::end "node_vector::const_iterator end() const "; +%feature("docstring") cmf::upslope::ET::RootUptakeStessFunction::copy +"virtual cmf::upslope::ET::RootUptakeStessFunction* copy() const =0 -%feature("docstring") cmf::water::node_list::get "flux_node::ptr -get(ptrdiff_t index) const +Creates a new copy of this wetness. "; -Returns a node in the node_list. "; +%feature("docstring") cmf::upslope::ET::RootUptakeStessFunction::Tact +"virtual real Tact(const stressedET *connection, real Tpot) const =0 -%feature("docstring") cmf::water::node_list::get_fluxes3d "cmf::geometry::point_vector get_fluxes3d(cmf::math::Time t) const +Calculates the water stress for a layer. -Returns the current flow vector for each node. "; +Parameters: +----------- -%feature("docstring") cmf::water::node_list::get_fluxes3d_to "cmf::geometry::point_vector get_fluxes3d_to(const -cmf::water::node_list &targets, cmf::math::Time t) const +connection: The stressedET connection this stress function belongs to -Returns the flux vectors to the nodes of a given target node_list. "; +Tpot: Potential Transpiration in mm/day (for the full profile) -%feature("docstring") cmf::water::node_list::get_fluxes_to "cmf::math::num_array get_fluxes_to(const cmf::water::node_list -&targets, cmf::math::Time t) const +Actual flux from layer in m3/day "; -A fast method to perform flux queries as a batch. +%feature("docstring") +cmf::upslope::ET::RootUptakeStessFunction::to_string "virtual +std::string to_string() const =0 "; -The node lists left and right should have the same length. -The vector containing the flux from left to right at the same position +// File: classcmf__core_1_1_root_uptake_stess_function.xml +%feature("docstring") cmf_core::RootUptakeStessFunction " -Parameters: ------------ +An abstract class to calculate the actual transpiration from potential +transpiration. Implementations of WaterStressFunction are used by ET +connections derived from cmf::upslope::ET::stressedET C++ includes: +waterstress.h "; -targets: A node_list containing the source nodes +%feature("docstring") cmf_core::RootUptakeStessFunction::__init__ "def __init__(self, args, kwargs) "; -t: The time for the fluxes +%feature("docstring") cmf_core::RootUptakeStessFunction::copy "def +copy(self, args, kwargs) -Replaces slow Python code like: "; +copy(RootUptakeStessFunction self) -> RootUptakeStessFunction virtual +cmf::upslope::ET::RootUptakeStessFunction* copy() const =0 Creates a +new copy of this wetness. "; -%feature("docstring") cmf::water::node_list::get_positions "cmf::geometry::point_vector get_positions() const +%feature("docstring") cmf_core::RootUptakeStessFunction::Tact "def +Tact(self, args, kwargs) -Returns the positions of the nodes. "; +Tact(RootUptakeStessFunction self, stressedET connection, real Tpot) +-> real virtual real Tact(const stressedET *connection, real Tpot) +const =0 Calculates the water stress for a layer. Parameters: +----------- connection: The stressedET connection this stress +function belongs to Tpot: Potential Transpiration in mm/day (for the +full profile) Actual flux from layer in m3/day "; -%feature("docstring") cmf::water::node_list::get_potentials "cmf::math::num_array get_potentials() +%feature("docstring") cmf_core::RootUptakeStessFunction::to_string "def to_string(self, args, kwargs) -Returns the potential of the nodes. "; +to_string(RootUptakeStessFunction self) -> std::string virtual +std::string to_string() const =0 "; -%feature("docstring") cmf::water::node_list::get_states "cmf::math::StateVariableList get_states() -Implements StateVariableOwner. "; +// File: classcmf__core_1_1_rutter_interception.xml +%feature("docstring") cmf_core::RutterInterception " -%feature("docstring") cmf::water::node_list::getslice "node_list -getslice(ptrdiff_t begin, ptrdiff_t end, ptrdiff_t step=1) const +Interception storage overflow according to the Rutter and Morton +(1977) model. Calculates the interception overflow as a storage +depending fraction of incoming rainfall The Rutter model of +interception reads as follows after Meuser, A., 1990. Effects of +afforestation on run-off characteristics. Agric. For. Meteorol. 50: +125-138.: .. math:: \\\\\\\\frac{dI_C(t)}{dt}=P(t)(1-p_F- +p_S)-P(t)(1-p_F- p_S)\\\\\\\\frac{I_C(t)}{I_CMAX}-f_I(E-e)(t) With +:math:`I_C` the current canopy storage and :math:`P(t)` the current +rainfall. The second term of the equation denotes the flux from the +canopy to the ground. The implemented formula for canopy storage +overflow reads then as: .. math:: q_{CO}(t) = +P_{net}(t)\\\\\\\\frac{V_{act}[mm]}{V_{max}[mm]} With: +:math:`q_{CO}(t)[\\\\\\\\frac{m^3}{day}]`: The flux from canopy to the +ground :math:`P_{net}(t)[\\\\\\\\frac{m^3}{day}]`: The flux from the +rain to the canopy :math:`V_{act}[mm]=1000 [mm/m] +\\\\\\\\frac{V_{canopy}[m^3]}{A_{cell} [m^2]}` The stored water of the +canopy in mm :math:`V_{max}[mm]=c_{LAI}[mm]\\\\\\\\cdot LAI` The +capacity of the canopy in mm, defined by the factor +CanopyCapacityPerLAI [mm/LAI], and the leaf area index LAI. (see: +cmf::upslope::vegetation::Vegetation) C++ includes: surfacefluxes.h +"; + +%feature("docstring") cmf_core::RutterInterception::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::connections::RutterInterception self, +cmf::water::WaterStorage::ptr Canopy, cmf::water::flux_node::ptr +target, Cell cell) -> RutterInterception +RutterInterception(cmf::water::WaterStorage::ptr Canopy, +cmf::water::flux_node::ptr target, cmf::upslope::Cell &cell) "; -Returns a slice of the node_list. "; +%feature("docstring") cmf_core::RutterInterception::__contains__ "def __contains__(self, cmp) "; -%feature("docstring") cmf::water::node_list::global_water_balance "real global_water_balance(cmf::math::Time t) const +%feature("docstring") cmf_core::RutterInterception::__eq__ "def +__eq__(self, args, kwargs) -Returns the sum of the water balances of the nodes. +__eq__(flux_connection self, flux_connection other) -> bool "; +%feature("docstring") cmf_core::RutterInterception::__getitem__ "def +__getitem__(self, index) "; +%feature("docstring") cmf_core::RutterInterception::__iter__ "def +__iter__(self) "; -.. math:: +%feature("docstring") cmf_core::RutterInterception::__repr__ "def +__repr__(self) "; - \\\\sigma_{global} = - \\\\sum_{i=0}^N{\\\\sum_{j=0}^{C_i}{q_{ij}(t)}} +%feature("docstring") cmf_core::RutterInterception::conc "def +conc(self, args, kwargs) -Replaces slow Python code like: "; +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -%feature("docstring") cmf::water::node_list::remove "bool -remove(flux_node::ptr node) +%feature("docstring") cmf_core::RutterInterception::exchange_target "def exchange_target(self, args, kwargs) -Removes a flux node from the list, returns true if successful. "; +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") cmf::water::node_list::set_potentials "ptrdiff_t set_potentials(const cmf::math::num_array &potentials) +%feature("docstring") cmf_core::RutterInterception::get_target "def +get_target(self, args) -Sets the potentials of the node_list. +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -If nodes do not have changeable potentials, they are skipped silently -The number of nodes with changed potential "; +%feature("docstring") cmf_core::RutterInterception::get_tracer_filter +"def get_tracer_filter(self, args) -%feature("docstring") cmf::water::node_list::set_solute_source "ptrdiff_t set_solute_source(const cmf::water::solute &_Solute, -cmf::math::num_array source_fluxes) +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -Sets the source flux of a solute storage associated with a node (node -has to be a water storage) "; +%feature("docstring") cmf_core::RutterInterception::kill_me "def +kill_me(self, args, kwargs) -%feature("docstring") cmf::water::node_list::size "size_t size() -const +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -The number of nodes. "; +%feature("docstring") cmf_core::RutterInterception::left_node "def +left_node(self, args, kwargs) -%feature("docstring") cmf::water::node_list::water_balance "cmf::math::num_array water_balance(cmf::math::Time t) const +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -Returns the water balance of each vector as a vector. +%feature("docstring") cmf_core::RutterInterception::q "def q(self, +args, kwargs) +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; +%feature("docstring") cmf_core::RutterInterception::refresh "def +refresh(self, args, kwargs) -.. math:: +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; - \\\\sigma_i = \\\\sum_{j=0}^{C_i}{q_{ij}(t)} +%feature("docstring") cmf_core::RutterInterception::right_node "def +right_node(self, args, kwargs) -Replaces slow Python code like: "; +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; +%feature("docstring") cmf_core::RutterInterception::set_tracer_filter +"def set_tracer_filter(self, args) -// File: classcmf_1_1math_1_1root__finding_1_1not__finite__error.xml -%feature("docstring") cmf::math::root_finding::not_finite_error ""; +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; -%feature("docstring") -cmf::math::root_finding::not_finite_error::not_finite_error "not_finite_error(std::string msg) "; +%feature("docstring") cmf_core::RutterInterception::short_string "def short_string(self, args, kwargs) +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -// File: classcmf_1_1water_1_1_null_adsorption.xml -%feature("docstring") cmf::water::NullAdsorption " +%feature("docstring") cmf_core::RutterInterception::to_string "def +to_string(self, args, kwargs) -A class for tracers without interaction with the storage container. -freesolute returns xt. +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -C++ includes: adsorption.h "; +%feature("docstring") cmf_core::RutterInterception::use_for_cell "def use_for_cell(args, kwargs) -%feature("docstring") cmf::water::NullAdsorption::~NullAdsorption "virtual ~NullAdsorption() "; +use_for_cell(Cell cell) -> RutterInterception "; -%feature("docstring") cmf::water::NullAdsorption::copy "virtual -NullAdsorption* copy(real m=-1) const -returns a copy of the Adsorption object. +// File: classcmf_1_1upslope_1_1connections_1_1_rutter_interception.xml +%feature("docstring") cmf::upslope::connections::RutterInterception " -If the adsorption is depending on the sorbent mass, you can give a -positive value for the sorbent mass m. If the value is not given or -negative, m is used from the original object. "; +Interception storage overflow according to the Rutter and Morton +(1977) model. -%feature("docstring") cmf::water::NullAdsorption::freesolute "virtual real freesolute(real xt, real V) const +Calculates the interception overflow as a storage depending fraction +of incoming rainfall The Rutter model of interception reads as follows +after Meuser, A., 1990. Effects of afforestation on run-off +characteristics. Agric. For. Meteorol. 50: 125-138.: -Returns the mass of dissolved tracer as a function of the total tracer -mass in the solute storage and the water volume. -Parameters: ------------ +.. math:: -xt: :math:`x_t` the total tracer mass in the storage + \\\\frac{dI_C(t)}{dt}=P(t)(1-p_F-p_S)-P(t)(1-p_F- + p_S)\\\\frac{I_C(t)}{I_CMAX}-f_I(E-e)(t) -V: :math:`V m^3` the water volume in the storage +With :math:`I_C` the current +canopy storage and :math:`P(t)` the current rainfall. -:math:`x_f` the dissolved mass of the tracer "; +The second term of the equation denotes the flux from the canopy to +the ground. The implemented formula for canopy storage overflow reads +then as: -%feature("docstring") cmf::water::NullAdsorption::totalsolute "virtual real totalsolute(real xf, real V) const +.. math:: -Returns the total mass of the tracer from the dissolved concetration -in tracer unit/m3. + q_{CO}(t) = + P_{net}(t)\\\\frac{V_{act}[mm]}{V_{max}[mm]} -Parameters: ------------ +With: +:math:`q_{CO}(t)[\\\\frac{m^3}{day}]`: The flux from canopy to the ground -xf: :math:`x_f` the dissolved tracer mass in the storage +:math:`P_{net}(t)[\\\\frac{m^3}{day}]`: The flux from the rain to the canopy -V: :math:`V m^3` the water volume in the storage +:math:`V_{act}[mm]=1000 [mm/m] \\\\frac{V_{canopy}[m^3]}{A_{cell} [m^2]}` +The stored water of the canopy in mm -:math:`x_t` the total mass of the tracer "; +:math:`V_{max}[mm]=c_{LAI}[mm]\\\\cdot LAI` The capacity of the canopy in +mm, defined by the factor CanopyCapacityPerLAI [mm/LAI], and the leaf +area index LAI. (see: cmf::upslope::vegetation::Vegetation) +C++ includes: surfacefluxes.h "; -// File: classcmf_1_1math_1_1num__array.xml -%feature("docstring") cmf::math::num_array " +%feature("docstring") +cmf::upslope::connections::RutterInterception::RutterInterception "RutterInterception(cmf::water::WaterStorage::ptr Canopy, +cmf::water::flux_node::ptr target, cmf::upslope::Cell &cell) "; -A valarray kind of vector implementation with OpenMP capabilities. +%feature("docstring") +cmf::upslope::connections::RutterInterception::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) -C++ includes: num_array.h "; +Returns the concentration of the flux. -%feature("docstring") cmf::math::num_array::num_array "num_array() +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; -constructors "; +%feature("docstring") +cmf::upslope::connections::RutterInterception::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") cmf::math::num_array::num_array "num_array(const num_array &Vector) "; +%feature("docstring") +cmf::upslope::connections::RutterInterception::get_ptr "ptr get_ptr() +const "; -%feature("docstring") cmf::math::num_array::num_array "num_array(const_iterator begin, const_iterator end) "; +%feature("docstring") +cmf::upslope::connections::RutterInterception::get_target "flux_node::ptr get_target(const flux_node &inquirer) -%feature("docstring") cmf::math::num_array::num_array "num_array(ptrdiff_t count, real Value=0.0) "; +Returns the other end of a connection than the asking end. "; -%feature("docstring") cmf::math::num_array::num_array "num_array(size_t count, real Value=0.0) "; +%feature("docstring") +cmf::upslope::connections::RutterInterception::get_target "flux_node::ptr get_target(int index) const -%feature("docstring") cmf::math::num_array::num_array "num_array(size_t count, real *data) "; +With index 0, the left node is returned, with index 1 the right node +of the connection. "; -%feature("docstring") cmf::math::num_array::~num_array "~num_array() +%feature("docstring") +cmf::upslope::connections::RutterInterception::get_tracer_filter "real get_tracer_filter() -destructor "; +A value ranging from 0 to 1 to filter tracers out of the water flux. -%feature("docstring") cmf::math::num_array::apply "num_array -apply(real funct(real)) const "; +1.0 is no filter and 0.0 means no solute is crossing this connection +"; -%feature("docstring") cmf::math::num_array::axpy "void axpy(const -real fac, const num_array &other) "; +%feature("docstring") +cmf::upslope::connections::RutterInterception::get_tracer_filter "real get_tracer_filter(solute S) -%feature("docstring") cmf::math::num_array::begin "iterator begin() -const "; +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; -%feature("docstring") cmf::math::num_array::dot "real dot(const -num_array &) const "; +%feature("docstring") +cmf::upslope::connections::RutterInterception::kill_me "bool +kill_me() -%feature("docstring") cmf::math::num_array::end "iterator end() -const "; +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; -%feature("docstring") cmf::math::num_array::is_nan "bool is_nan() -const "; +%feature("docstring") +cmf::upslope::connections::RutterInterception::left_node "flux_node::ptr left_node() const -%feature("docstring") cmf::math::num_array::max "real max() const "; +Returns the left node of this connection. "; -%feature("docstring") cmf::math::num_array::mean "real mean() const -"; +%feature("docstring") +cmf::upslope::connections::RutterInterception::q "real q(const +flux_node &inquirer, cmf::math::Time t) -%feature("docstring") cmf::math::num_array::min "real min() const "; +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; -%feature("docstring") cmf::math::num_array::norm "real norm(int -normtype=0) const "; +%feature("docstring") +cmf::upslope::connections::RutterInterception::refresh "void +refresh(cmf::math::Time t) -%feature("docstring") cmf::math::num_array::power "num_array -power(const num_array &) const "; +Performes a new calculation of the flux. "; -%feature("docstring") cmf::math::num_array::power "num_array -power(real exponent) const "; +%feature("docstring") +cmf::upslope::connections::RutterInterception::right_node "flux_node::ptr right_node() const -%feature("docstring") cmf::math::num_array::release "iterator -release() "; +returns the right node of this connection "; -%feature("docstring") cmf::math::num_array::resize "void -resize(ptrdiff_t count) "; +%feature("docstring") +cmf::upslope::connections::RutterInterception::set_tracer_filter "void set_tracer_filter(real value) -%feature("docstring") cmf::math::num_array::scale "void scale(const -real fac) "; +A value ranging from 0 to 1 to filter tracers out of the water flux. -%feature("docstring") cmf::math::num_array::scale_add "void -scale_add(const real fac, const num_array &other) "; +1.0 is no filter and 0.0 means no solute is crossing this connection +"; -%feature("docstring") cmf::math::num_array::set "void set(const -num_array &other) +%feature("docstring") +cmf::upslope::connections::RutterInterception::set_tracer_filter "void set_tracer_filter(solute S, real value) "; -Prevents deletion of the stored data. +%feature("docstring") +cmf::upslope::connections::RutterInterception::short_string "virtual +std::string short_string() const "; -Use with care, and only if you know what you are doing. "; +%feature("docstring") +cmf::upslope::connections::RutterInterception::to_string "virtual +std::string to_string() const "; -%feature("docstring") cmf::math::num_array::set "void set(const real -fac, const num_array &other) "; -%feature("docstring") cmf::math::num_array::size "ptrdiff_t size() -const "; +// File: classcmf_1_1draw_1_1shapemap_1_1_shape_map.xml +%feature("docstring") cmf::draw::shapemap::ShapeMap " -%feature("docstring") cmf::math::num_array::sum "real sum() const "; +self.fc_function: A callable taking a feature and returning a color +(fillcolor) self.lw_function: A callable taking a feature and +returning a scalar (line width) "; +%feature("docstring") cmf::draw::shapemap::ShapeMap::__init__ "def +__init__(self, features, kwargs) "; -// File: classcmf_1_1river_1_1_open_water_storage.xml -%feature("docstring") cmf::river::OpenWaterStorage " +%feature("docstring") cmf::draw::shapemap::ShapeMap::refresh "def +refresh(self) "; -An open water body. -The potential is calculated from the stored water using a water table -function +// File: classcmf__core_1_1_shuttleworth_wallace.xml +%feature("docstring") cmf_core::ShuttleworthWallace " -C++ includes: OpenWaterStorage.h "; +Calculates the sum of soil evaporation and transpiration according to +Shuttleworth & Wallace 1985, as implemented in BROOK 90 (Federer 1990) +The difference to BROOK90 is, that the actual transpiration is not +calculated by plant resitance and potential gradient between plant and +soil, but by an piecewise linear function of the pF value :math:`pF = +\\\\\\\\log_{10}\\\\\\\\left(-\\\\\\\\Psi [hPa]\\\\\\\\right)`: .. +math:: \\\\\\\\frac{T_{act}}{T_{pot}} = \\\\\\\\begin{cases}1 & +pF \\\\\\\\le 3.35 \\\\\\\\\\\\\\\\ \\\\\\\\frac{pF - 4.2}{3.35 - +4.2} & pF \\\\\\\\in [3.35 .. 4.2] \\\\\\\\\\\\\\\\ 0 & pF +\\\\\\\\ge 4.2\\\\\\\\end{cases} Calculation procedure, as in BROOK +90: Evapotranspiration from the canopy: :math:`\\\\\\\\lambda +ET_{canopy} = \\\\\\\\frac{r_{ac} \\\\\\\\Delta\\\\\\\\ R_{n,canopy} + +c_p\\\\\\\\rho D_0}{\\\\\\\\Delta \\\\\\\\gamma r_{ac} + \\\\\\\\gamma +r_{sc}}` Evaporation from the ground: :math:`\\\\\\\\lambda +E_{ground} = \\\\\\\\frac{r_{as} \\\\\\\\Delta\\\\\\\\ R_{n,ground} + +c_p\\\\\\\\rho D_0}{\\\\\\\\Delta \\\\\\\\gamma r_{as} + \\\\\\\\gamma +r_{ss}}` In case of a complete surface water covered ground, the +surface resistance :math:`r_{ss}` becomes 0. (GIR) with +:math:`\\\\\\\\Delta = \\\\\\\\frac{de_s}{dT} = 4098\\\\\\\\ 0.6108 +\\\\\\\\exp\\\\\\\\left(\\\\\\\\frac{17.27 +T}{T+237.3}\\\\\\\\right)(T+237.3)^{-2}`, the slope of the sat. vap. +press. T function :math:`R_{n,ground} = R_n \\\\\\\\exp(-C_R LAI)`, +the net radiation flux to the ground :math:`R_{n,canopy} = R_n - +R_{n,ground}`, the net radiation flux to the canopy +:math:`\\\\\\\\lambda,c_p\\\\\\\\rho,\\\\\\\\gamma` latent heat of +vaporization, heat capacity of air, psychrometer constant :math:`D_0` +vapor pressure deficit at effective source height, see function D0 +:math:`r_{ac}, r_{sc}, r_{as}, r_{ss}` Resistances for the vapor +pressure (see below) C++ includes: ShuttleworthWallace.h "; + +%feature("docstring") cmf_core::ShuttleworthWallace::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::ET::ShuttleworthWallace self, Cell cell, bool +allow_dew=True) -> ShuttleworthWallace +ShuttleworthWallace(cmf::upslope::Cell &cell, bool allow_dew=true) +Calculates the transpiration and the soil evaporation from dry +surfaces. "; -/* Overrides of flux_node */ +%feature("docstring") cmf_core::ShuttleworthWallace::evap_from_canopy +"def evap_from_canopy(self, args, kwargs) -%feature("docstring") cmf::river::OpenWaterStorage::RecalcFluxes "virtual bool RecalcFluxes(cmf::math::Time t) +evap_from_canopy(ShuttleworthWallace self, +cmf::water::WaterStorage::ptr canopy, Time t) -> double double +evap_from_canopy(cmf::water::WaterStorage::ptr canopy, cmf::math::Time +t) "; -Pure flux_nodes do not influence fluxes, therefore no recalculation of -fluxes is required by flux_node. +%feature("docstring") cmf_core::ShuttleworthWallace::evap_from_layer +"def evap_from_layer(self, args, kwargs) -WaterStorage overrides this, since state changes require an update of -the fluxes "; +evap_from_layer(ShuttleworthWallace self, cmf::upslope::SoilLayer::ptr +sl, Time t) -> double double +evap_from_layer(cmf::upslope::SoilLayer::ptr sl, cmf::math::Time t) "; -%feature("docstring") cmf::river::OpenWaterStorage::is_empty "virtual double is_empty() const +%feature("docstring") cmf_core::ShuttleworthWallace::evap_from_snow "def evap_from_snow(self, args, kwargs) -Returns true if the node has no water. "; +evap_from_snow(ShuttleworthWallace self, cmf::water::WaterStorage::ptr +snow, Time t) -> double double +evap_from_snow(cmf::water::WaterStorage::ptr snow, cmf::math::Time t) +"; -%feature("docstring") cmf::river::OpenWaterStorage::to_string "virtual std::string to_string() const "; +%feature("docstring") +cmf_core::ShuttleworthWallace::evap_from_surfacewater "def +evap_from_surfacewater(self, args, kwargs) -%feature("docstring") cmf::river::OpenWaterStorage::conc "real -conc(cmf::math::Time t, const cmf::water::solute &solute) const +evap_from_surfacewater(ShuttleworthWallace self, +cmf::river::OpenWaterStorage::ptr ows, Time t) -> double double +evap_from_surfacewater(cmf::river::OpenWaterStorage::ptr ows, +cmf::math::Time t) "; -Returns the water quality of the flux_node, if it is not overridden -this is the mix of the incoming fluxes. "; +%feature("docstring") +cmf_core::ShuttleworthWallace::get_aerodynamic_resistance "def +get_aerodynamic_resistance(self, args, kwargs) -%feature("docstring") cmf::river::OpenWaterStorage::conc "real -conc(const cmf::water::solute &_Solute) const +get_aerodynamic_resistance(aerodynamic_resistance self, double & r_ag, +double & r_ac, Time t) virtual void get_aerodynamic_resistance(double +&r_ag, double &r_ac, cmf::math::Time t) const =0 aerodynamic +resistance from ground to atmosphere (r_ag) and from canopy to +atmosphere (r_ac) "; -Returns the concentration of the given solute. "; +%feature("docstring") cmf_core::ShuttleworthWallace::refresh "def +refresh(self, args) -%feature("docstring") cmf::river::OpenWaterStorage::conc "void -conc(const cmf::water::solute &_Solute, real NewConcetration) +refresh(ShuttleworthWallace self, Time t) refresh(ShuttleworthWallace +self) void refresh() "; -Sets a new concentration. "; +%feature("docstring") +cmf_core::ShuttleworthWallace::set_RSS_parameters "def +set_RSS_parameters(args, kwargs) -%feature("docstring") cmf::river::OpenWaterStorage::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node -&target) +set_RSS_parameters(double _RSSa=500., double _RSSb=1.0, double +_RSSa_pot=-3.22) "; -Returns the connection between this and target. "; +%feature("docstring") +cmf_core::ShuttleworthWallace::transp_from_layer "def +transp_from_layer(self, args, kwargs) -%feature("docstring") cmf::river::OpenWaterStorage::dxdt "virtual -real dxdt(const cmf::math::Time &time) +transp_from_layer(ShuttleworthWallace self, +cmf::upslope::SoilLayer::ptr sl, Time t) -> double double +transp_from_layer(cmf::upslope::SoilLayer::ptr sl, cmf::math::Time t) +"; -Returns the derivate of the state variable at time time. "; +%feature("docstring") cmf_core::ShuttleworthWallace::use_for_cell "def use_for_cell(args, kwargs) -%feature("docstring") cmf::river::OpenWaterStorage::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, -cmf::math::Time t) "; +use_for_cell(Cell cell) -> cmf::upslope::ET::ShuttleworthWallace::ptr +"; -%feature("docstring") cmf::river::OpenWaterStorage::flux_to "real -flux_to(const cmf::water::flux_node &target, cmf::math::Time t) -Returns the actual flux between this and target (positive sign means -\"from this into target\") "; +// File: classcmf_1_1upslope_1_1_e_t_1_1_shuttleworth_wallace.xml +%feature("docstring") cmf::upslope::ET::ShuttleworthWallace " -%feature("docstring") cmf::river::OpenWaterStorage::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) +Calculates the sum of soil evaporation and transpiration according to +Shuttleworth & Wallace 1985, as implemented in BROOK 90 (Federer 1990) -Returns the sum of all flux vectors. "; +The difference to BROOK90 is, that the actual transpiration is not +calculated by plant resitance and potential gradient between plant and +soil, but by an piecewise linear function of the pF value :math:`pF = \\\\log_{10}\\\\left(-\\\\Psi [hPa]\\\\right)`: -%feature("docstring") cmf::river::OpenWaterStorage::get_abs_errtol "real get_abs_errtol(real rel_errtol) const "; +.. math:: -%feature("docstring") cmf::river::OpenWaterStorage::get_connections "cmf::water::connection_list get_connections() const "; + + \\\\frac{T_{act}}{T_{pot}} = \\\\begin{cases}1 & pF \\\\le 3.35 + \\\\\\\\ \\\\frac{pF - 4.2}{3.35 - 4.2} & pF \\\\in [3.35 .. 4.2] + \\\\\\\\ 0 & pF \\\\ge 4.2\\\\end{cases} -%feature("docstring") cmf::river::OpenWaterStorage::get_depth "real -get_depth() const +Calculation procedure, as in BROOK 90: -Returns the water table depth. "; +Evapotranspiration from the canopy: :math:`\\\\lambda ET_{canopy} = \\\\frac{r_{ac} \\\\Delta\\\\ R_{n,canopy} + c_p\\\\rho D_0}{\\\\Delta \\\\gamma r_{ac} + \\\\gamma r_{sc}}` -%feature("docstring") -cmf::river::OpenWaterStorage::get_height_function "virtual const -IVolumeHeightFunction& get_height_function() const +Evaporation from the ground: :math:`\\\\lambda E_{ground} = \\\\frac{r_{as} \\\\Delta\\\\ R_{n,ground} + c_p\\\\rho D_0}{\\\\Delta \\\\gamma r_{as} + \\\\gamma r_{ss}}` -The functional relation between volume, depth and exposed area. "; +In case of a complete surface water covered ground, the surface +resistance :math:`r_{ss}` becomes 0. (GIR) -%feature("docstring") cmf::river::OpenWaterStorage::get_potential "virtual real get_potential() const +with :math:`\\\\Delta = \\\\frac{de_s}{dT} = 4098\\\\ 0.6108 \\\\exp\\\\left(\\\\frac{17.27 T}{T+237.3}\\\\right)(T+237.3)^{-2}`, +the slope of the sat. vap. press. T function -Returns the water potential of the node in m waterhead. +:math:`R_{n,ground} = R_n \\\\exp(-C_R LAI)`, the net radiation flux to +the ground -The base class water storage always returns the height of the location -"; +:math:`R_{n,canopy} = R_n - R_{n,ground}`, the net radiation flux to the +canopy -%feature("docstring") cmf::river::OpenWaterStorage::get_project "cmf::project& get_project() const +:math:`\\\\lambda,c_p\\\\rho,\\\\gamma` latent heat of vaporization, heat +capacity of air, psychrometer constant -Returns the project, this node is part of. "; +:math:`D_0` vapor pressure deficit at effective source height, see +function D0 -%feature("docstring") cmf::river::OpenWaterStorage::get_state "real -get_state() const "; +:math:`r_{ac}, r_{sc}, r_{as}, r_{ss}` Resistances for the vapor pressure +(see below) + +C++ includes: ShuttleworthWallace.h "; %feature("docstring") -cmf::river::OpenWaterStorage::get_state_variable_content "char -get_state_variable_content() const +cmf::upslope::ET::ShuttleworthWallace::ShuttleworthWallace "ShuttleworthWallace(cmf::upslope::Cell &cell, bool allow_dew=true) -A character indicating the integrated variable (either 'V' for Volume -or 'h' for head) "; +Calculates the transpiration and the soil evaporation from dry +surfaces. "; -%feature("docstring") cmf::river::OpenWaterStorage::get_states "cmf::math::StateVariableList get_states() +%feature("docstring") +cmf::upslope::ET::ShuttleworthWallace::~ShuttleworthWallace "~ShuttleworthWallace() "; -Add the state variables, owned by an object derived from -StateVariableOwner, to the given vector. "; +%feature("docstring") +cmf::upslope::ET::ShuttleworthWallace::evap_from_canopy "double +evap_from_canopy(cmf::water::WaterStorage::ptr canopy, cmf::math::Time +t) "; -%feature("docstring") cmf::river::OpenWaterStorage::get_volume "virtual real get_volume() const +%feature("docstring") +cmf::upslope::ET::ShuttleworthWallace::evap_from_layer "double +evap_from_layer(cmf::upslope::SoilLayer::ptr sl, cmf::math::Time t) "; -Returns the volume of water in this storage in m3 "; +%feature("docstring") +cmf::upslope::ET::ShuttleworthWallace::evap_from_snow "double +evap_from_snow(cmf::water::WaterStorage::ptr snow, cmf::math::Time t) +"; -%feature("docstring") cmf::river::OpenWaterStorage::is_storage "virtual bool is_storage() const +%feature("docstring") +cmf::upslope::ET::ShuttleworthWallace::evap_from_surfacewater "double +evap_from_surfacewater(cmf::river::OpenWaterStorage::ptr ows, +cmf::math::Time t) "; -Returns true, since this is a storage. "; +%feature("docstring") +cmf::upslope::ET::ShuttleworthWallace::get_aerodynamic_resistance "virtual void get_aerodynamic_resistance(double &r_ag, double &r_ac, +cmf::math::Time t) const -%feature("docstring") cmf::river::OpenWaterStorage::remove_connection -"bool remove_connection(cmf::water::flux_node::ptr To) +aerodynamic resistance from ground to atmosphere (r_ag) and from +canopy to atmosphere (r_ac) "; -Remove the connection. "; +%feature("docstring") cmf::upslope::ET::ShuttleworthWallace::refresh +"void refresh(cmf::math::Time t) -%feature("docstring") cmf::river::OpenWaterStorage::set_depth "void -set_depth(real new_depth) "; +Calculates all the values. "; + +%feature("docstring") cmf::upslope::ET::ShuttleworthWallace::refresh +"void refresh() "; %feature("docstring") -cmf::river::OpenWaterStorage::set_height_function "virtual void -set_height_function(const IVolumeHeightFunction &val) "; +cmf::upslope::ET::ShuttleworthWallace::transp_from_layer "double +transp_from_layer(cmf::upslope::SoilLayer::ptr sl, cmf::math::Time t) +"; -%feature("docstring") cmf::river::OpenWaterStorage::set_potential "virtual void set_potential(real newpotential) -Sets the potential of this flux node. "; +// File: classcmf_1_1math_1_1root__finding_1_1sign__error.xml +%feature("docstring") cmf::math::root_finding::sign_error ""; -%feature("docstring") cmf::river::OpenWaterStorage::set_state "void -set_state(real newState) "; +%feature("docstring") cmf::math::root_finding::sign_error::sign_error +"sign_error(const std::string &msg) "; -%feature("docstring") -cmf::river::OpenWaterStorage::set_state_variable_content "void -set_state_variable_content(char content) -A character indicating the integrated variable (either 'V' for Volume -or 'h' for head) "; +// File: classcmf_1_1upslope_1_1connections_1_1_simple_infiltration.xml +%feature("docstring") cmf::upslope::connections::SimpleInfiltration " -%feature("docstring") cmf::river::OpenWaterStorage::set_volume "virtual void set_volume(real newwatercontent) +Connects the surfacewater and the most upper layer using a simplified +infiltration model suitable for conceptional models. -Sets the volume of water in this storage in m3 "; -%feature("docstring") cmf::river::OpenWaterStorage::Solute "SoluteStorage& Solute(const cmf::water::solute _Solute) -Returns the water quality of the water storage. "; +.. math:: -%feature("docstring") cmf::river::OpenWaterStorage::Solute "const -SoluteStorage& Solute(const cmf::water::solute _Solute) const "; + q_{inf} = \\\\left(1-e_{sat}\\\\left(W, W_0\\\\right)\\\\right) + q_{inf,pot} -%feature("docstring") cmf::river::OpenWaterStorage::waterbalance "real waterbalance(cmf::math::Time t, const flux_connection *Without=0) -const +where: :math:`q_{inf}` Effective infiltration from +surface to first layer (soil) -Returns the sum of all fluxes (positive and negative) at time t. +:math:`e_{sat}(W, W_0)` Saturation excess, ranging from 0 (nowhere saturated +soil layer) to 1 (fully saturated). :math:`W` is the average wetness +calculated from the soil layer, :math:`W_0` is a parameter denoting the +wetness, where 50% of the layer is saturated using a sigmoidal +function: :math:`e_{sat}(W_{soil}, W_0) = \\\\left(1+e^{-(W-W_0)0.2(1-W_0)}\\\\right)^{-1}` -Single fluxes can be excluded from the calculation +:math:`q_{inf,pot}` is the potential infiltration, given by the incoming +fluxes limited by the saturated conductivity: :math:`q_{inf,pot} = \\\\min(q_{in}, K_{sat} A)` :math:`q_{in}` Sum of incoming fluxes to the +surfacewater in :math:`m^3/day` -Parameters: ------------ +:math:`K_{sat}` Saturated conductivity in :math:`m/day` -t: Time of the query +:math:`A` Cell area in :math:`m^2` -Without: A flux_connection that is excluded from the waterbalance -(e.g. to prevent closed circuits) "; +C++ includes: infiltration.h "; -%feature("docstring") cmf::river::OpenWaterStorage::wet_area "real -wet_area() const +%feature("docstring") +cmf::upslope::connections::SimpleInfiltration::SimpleInfiltration "SimpleInfiltration(cmf::upslope::SoilLayer::ptr soilwater, +cmf::water::flux_node::ptr surfacewater, real W0=0.9) -Returns the exposed surface area in m2. "; +Creates the connection between surfacewater and first soil layer. +Parameters: +----------- -// File: classcmf_1_1upslope_1_1_e_t_1_1_penman_evaporation.xml -%feature("docstring") cmf::upslope::ET::PenmanEvaporation " +soilwater: the infiltration target -Calculates evaporation from an open water body. +surfacewater: the infiltration source -C++ includes: ET.h "; +W0: the 50% saturation value "; %feature("docstring") -cmf::upslope::ET::PenmanEvaporation::PenmanEvaporation "PenmanEvaporation(cmf::river::OpenWaterStorage::ptr source, -cmf::water::flux_node::ptr Evap_target, const -cmf::atmosphere::Meteorology &meteo) "; - -%feature("docstring") cmf::upslope::ET::PenmanEvaporation::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) +cmf::upslope::connections::SimpleInfiltration::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns the concentration of the flux. @@ -10334,25 +28173,26 @@ If not overridden, it returns the concentration of the source of the flux (direction depending) "; %feature("docstring") -cmf::upslope::ET::PenmanEvaporation::exchange_target "void +cmf::upslope::connections::SimpleInfiltration::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") cmf::upslope::ET::PenmanEvaporation::get_ptr "ptr get_ptr() const "; +%feature("docstring") +cmf::upslope::connections::SimpleInfiltration::get_ptr "ptr get_ptr() +const "; -%feature("docstring") cmf::upslope::ET::PenmanEvaporation::get_target -"flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") +cmf::upslope::connections::SimpleInfiltration::get_target "flux_node::ptr get_target(const flux_node &inquirer) Returns the other end of a connection than the asking end. "; -%feature("docstring") cmf::upslope::ET::PenmanEvaporation::get_target -"flux_node::ptr get_target(int index) const +%feature("docstring") +cmf::upslope::connections::SimpleInfiltration::get_target "flux_node::ptr get_target(int index) const With index 0, the left node is returned, with index 1 the right node of the connection. "; %feature("docstring") -cmf::upslope::ET::PenmanEvaporation::get_tracer_filter "real -get_tracer_filter() +cmf::upslope::connections::SimpleInfiltration::get_tracer_filter "real get_tracer_filter() A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -10360,40 +28200,43 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::ET::PenmanEvaporation::get_tracer_filter "real -get_tracer_filter(solute S) +cmf::upslope::connections::SimpleInfiltration::get_tracer_filter "real get_tracer_filter(solute S) A value ranging from 0 to 1 to filter tracers out of the water flux. "; -%feature("docstring") cmf::upslope::ET::PenmanEvaporation::kill_me "bool kill_me() +%feature("docstring") +cmf::upslope::connections::SimpleInfiltration::kill_me "bool +kill_me() Deregisters this connection from its nodes. Returns true if only one reference is left. "; -%feature("docstring") cmf::upslope::ET::PenmanEvaporation::left_node -"flux_node::ptr left_node() const +%feature("docstring") +cmf::upslope::connections::SimpleInfiltration::left_node "flux_node::ptr left_node() const Returns the left node of this connection. "; -%feature("docstring") cmf::upslope::ET::PenmanEvaporation::q "real -q(const flux_node &inquirer, cmf::math::Time t) +%feature("docstring") +cmf::upslope::connections::SimpleInfiltration::q "real q(const +flux_node &inquirer, cmf::math::Time t) Returns the current flux through a connection. Negative signs mean out of the inquirer, positive are inflows to the inquirer. "; -%feature("docstring") cmf::upslope::ET::PenmanEvaporation::refresh "void refresh(cmf::math::Time t) +%feature("docstring") +cmf::upslope::connections::SimpleInfiltration::refresh "void +refresh(cmf::math::Time t) Performes a new calculation of the flux. "; -%feature("docstring") cmf::upslope::ET::PenmanEvaporation::right_node -"flux_node::ptr right_node() const +%feature("docstring") +cmf::upslope::connections::SimpleInfiltration::right_node "flux_node::ptr right_node() const returns the right node of this connection "; %feature("docstring") -cmf::upslope::ET::PenmanEvaporation::set_tracer_filter "void -set_tracer_filter(real value) +cmf::upslope::connections::SimpleInfiltration::set_tracer_filter "void set_tracer_filter(real value) A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -10401,493 +28244,603 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::ET::PenmanEvaporation::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; +cmf::upslope::connections::SimpleInfiltration::set_tracer_filter "void set_tracer_filter(solute S, real value) "; %feature("docstring") -cmf::upslope::ET::PenmanEvaporation::short_string "virtual +cmf::upslope::connections::SimpleInfiltration::short_string "virtual std::string short_string() const "; -%feature("docstring") cmf::upslope::ET::PenmanEvaporation::to_string -"virtual std::string to_string() const "; - - -// File: classcmf_1_1upslope_1_1_e_t_1_1_penman_monteith_e_t.xml -%feature("docstring") cmf::upslope::ET::PenmanMonteithET " +%feature("docstring") +cmf::upslope::connections::SimpleInfiltration::to_string "virtual +std::string to_string() const "; -Calculates the potential evapotranspiration according to FAO(1998) -Governing equations: +// File: classcmf__core_1_1_simple_infiltration.xml +%feature("docstring") cmf_core::SimpleInfiltration " -.. math:: +Connects the surfacewater and the most upper layer using a simplified +infiltration model suitable for conceptional models. .. math:: +q_{inf} = \\\\\\\\left(1-e_{sat}\\\\\\\\left(W, +W_0\\\\\\\\right)\\\\\\\\right) q_{inf,pot} where: +:math:`q_{inf}` Effective infiltration from surface to first layer +(soil) :math:`e_{sat}(W, W_0)` Saturation excess, ranging from 0 +(nowhere saturated soil layer) to 1 (fully saturated). :math:`W` is +the average wetness calculated from the soil layer, :math:`W_0` is a +parameter denoting the wetness, where 50% of the layer is saturated +using a sigmoidal function: :math:`e_{sat}(W_{soil}, W_0) = +\\\\\\\\left(1+e^{-(W-W_0)0.2(1-W_0)}\\\\\\\\right)^{-1}` +:math:`q_{inf,pot}` is the potential infiltration, given by the +incoming fluxes limited by the saturated conductivity: +:math:`q_{inf,pot} = \\\\\\\\min(q_{in}, K_{sat} A)` :math:`q_{in}` +Sum of incoming fluxes to the surfacewater in :math:`m^3/day` +:math:`K_{sat}` Saturated conductivity in :math:`m/day` :math:`A` +Cell area in :math:`m^2` C++ includes: infiltration.h "; + +%feature("docstring") cmf_core::SimpleInfiltration::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::connections::SimpleInfiltration self, +cmf::upslope::SoilLayer::ptr soilwater, cmf::water::flux_node::ptr +surfacewater, real W0=0.9) -> SimpleInfiltration +SimpleInfiltration(cmf::upslope::SoilLayer::ptr soilwater, +cmf::water::flux_node::ptr surfacewater, real W0=0.9) Creates the +connection between surfacewater and first soil layer. Parameters: +----------- soilwater: the infiltration target surfacewater: the +infiltration source W0: the 50% saturation value "; + +%feature("docstring") cmf_core::SimpleInfiltration::__contains__ "def __contains__(self, cmp) "; + +%feature("docstring") cmf_core::SimpleInfiltration::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::SimpleInfiltration::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::SimpleInfiltration::__iter__ "def +__iter__(self) "; - \\\\lambda ET &=& - \\\\frac{\\\\Delta\\\\left(R_n - G\\\\right)+\\\\rho_a c_p - \\\\frac{e_s - e_a}{r_a}}{\\\\Delta + - \\\\gamma\\\\left(1+\\\\frac{r_s}{r_a}\\\\right)} \\\\mbox{ FAO 1998, - Eq. 3} \\\\\\\\ \\\\mbox{With:} \\\\\\\\ \\\\Delta &=& 4098 - \\\\frac{0.6108 e^{17.27 T}}{(T+237.3)^2} \\\\frac{kPa}{^\\\\circ C} - \\\\mbox{ (FAO 1998, Eq. 13)} \\\\\\\\ T &=& \\\\mbox{Actual - Temperature in } ^\\\\circ C \\\\\\\\ R_n &=& \\\\mbox{net Radiation - (see Atmosphere) in } \\\\frac{MJ}{m^2day} \\\\\\\\ G &=& 0 \\\\ - \\\\frac{MJ}{m^2day} \\\\mbox{ if daily average (FAO 1998, Eq. 42)} - \\\\\\\\ && 0.1 R_n \\\\ \\\\mbox{ if day time (FAO 1998, Eq. 45)} - \\\\\\\\ && 0.5 R_n \\\\ \\\\mbox{ if night time (FAO 1998, Eq. 46)} - \\\\\\\\ \\\\gamma &=& \\\\frac{c_p P}{\\\\epsilon \\\\lambda} - \\\\mbox{ (FAO 1998,Eq. 8): Psychrometric constant } - \\\\frac{kPa}{^\\\\circ C} \\\\\\\\ c_p &=& 0.001013 - \\\\frac{MJ}{kg\\\\ ^\\\\circ C}\\\\mbox{ specific heat at constant - pressure } \\\\\\\\ P &=& 101.3 - \\\\left(\\\\frac{293-0.0065z}{293}\\\\right)^{5.26} \\\\mbox{ (FAO - 1998,Eq. 7)} \\\\\\\\ \\\\epsilon &=& 0.622 \\\\frac{mol/g \\\\mbox{ - vapor}}{mol/g \\\\mbox{ liquid water}} \\\\\\\\ \\\\lambda &=& 2.45 - \\\\frac{MJ}{kg} \\\\mbox{ (FAO 1998,Eq. 8)} \\\\\\\\ R &=& 0.287 - \\\\frac{kJ}{kg\\\\ k}\\\\mbox{ Spec. gas const.} \\\\\\\\ \\\\rho_a - &=& \\\\frac{P}{1.01(T+273)R} \\\\mbox{ (FAO 1998,Box. 6)} \\\\\\\\ - e_s &=& \\\\mbox{ Sat. vapor press. } [kPa] \\\\\\\\ e_a &=& \\\\mbox{ - Act. vapor press. } [kPa] \\\\\\\\ r_a &=& - \\\\frac{\\\\ln\\\\left(\\\\frac{2-d}{z_{om}}\\\\right)\\\\ln\\\\left(\\\\frac{2-d}{z_{oh}}\\\\right)}{k^2 - u_2} \\\\mbox{ (FAO 1998, Eq. 4/Box 4} \\\\frac s m \\\\\\\\ && - d=\\\\frac 2 3 h,z_{om}=0.123 h,z_{oh}=0.1 z_{om}, k=0.41 \\\\\\\\ h - &=& \\\\mbox{ Vegetation height in }m \\\\\\\\ u_2 &=& \\\\mbox{ - Windspeed in 2m above canopy } \\\\frac m s \\\\\\\\ r_s &=& - \\\\frac{r_l}{LAI_{Active}} \\\\mbox{ (FAO 1998, Eq. 5/Box 5)} - \\\\frac s m \\\\\\\\ && r_l=100 \\\\frac s m, LAI_{Active}=0.5 LAI - +%feature("docstring") cmf_core::SimpleInfiltration::__repr__ "def +__repr__(self) "; +%feature("docstring") cmf_core::SimpleInfiltration::conc "def +conc(self, args, kwargs) +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -C++ includes: ET.h "; +%feature("docstring") cmf_core::SimpleInfiltration::exchange_target "def exchange_target(self, args, kwargs) -%feature("docstring") -cmf::upslope::ET::PenmanMonteithET::PenmanMonteithET "PenmanMonteithET(cmf::upslope::SoilLayer::ptr source, -cmf::water::flux_node::ptr ET_target) "; +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") cmf::upslope::ET::PenmanMonteithET::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +%feature("docstring") cmf_core::SimpleInfiltration::get_target "def +get_target(self, args) -Returns the concentration of the flux. +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +%feature("docstring") cmf_core::SimpleInfiltration::get_tracer_filter +"def get_tracer_filter(self, args) -%feature("docstring") cmf::upslope::ET::PenmanMonteithET::ETpot "virtual real ETpot(cmf::math::Time t) const "; +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -%feature("docstring") -cmf::upslope::ET::PenmanMonteithET::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +%feature("docstring") cmf_core::SimpleInfiltration::kill_me "def +kill_me(self, args, kwargs) -%feature("docstring") cmf::upslope::ET::PenmanMonteithET::get_layer "SoilLayer::ptr get_layer() const "; +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -%feature("docstring") cmf::upslope::ET::PenmanMonteithET::get_ptr "ptr get_ptr() const "; +%feature("docstring") cmf_core::SimpleInfiltration::left_node "def +left_node(self, args, kwargs) -%feature("docstring") cmf::upslope::ET::PenmanMonteithET::get_target -"flux_node::ptr get_target(const flux_node &inquirer) +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -Returns the other end of a connection than the asking end. "; +%feature("docstring") cmf_core::SimpleInfiltration::q "def q(self, +args, kwargs) -%feature("docstring") cmf::upslope::ET::PenmanMonteithET::get_target -"flux_node::ptr get_target(int index) const +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +%feature("docstring") cmf_core::SimpleInfiltration::refresh "def +refresh(self, args, kwargs) -%feature("docstring") -cmf::upslope::ET::PenmanMonteithET::get_tracer_filter "real -get_tracer_filter() +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; -A value ranging from 0 to 1 to filter tracers out of the water flux. +%feature("docstring") cmf_core::SimpleInfiltration::right_node "def +right_node(self, args, kwargs) -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; -%feature("docstring") -cmf::upslope::ET::PenmanMonteithET::get_tracer_filter "real -get_tracer_filter(solute S) +%feature("docstring") cmf_core::SimpleInfiltration::set_tracer_filter +"def set_tracer_filter(self, args) -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; -%feature("docstring") cmf::upslope::ET::PenmanMonteithET::kill_me "bool kill_me() +%feature("docstring") cmf_core::SimpleInfiltration::short_string "def short_string(self, args, kwargs) -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -%feature("docstring") cmf::upslope::ET::PenmanMonteithET::left_node "flux_node::ptr left_node() const +%feature("docstring") cmf_core::SimpleInfiltration::to_string "def +to_string(self, args, kwargs) -Returns the left node of this connection. "; +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -%feature("docstring") cmf::upslope::ET::PenmanMonteithET::q "real -q(const flux_node &inquirer, cmf::math::Time t) +%feature("docstring") cmf_core::SimpleInfiltration::use_for_cell "def use_for_cell(args, kwargs) -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +use_for_cell(Cell c) "; -%feature("docstring") cmf::upslope::ET::PenmanMonteithET::refresh "void refresh(cmf::math::Time t) -Performes a new calculation of the flux. "; +// File: classcmf_1_1maps_1_1_simple_quad_tree.xml +%feature("docstring") cmf::maps::SimpleQuadTree ""; -%feature("docstring") cmf::upslope::ET::PenmanMonteithET::right_node -"flux_node::ptr right_node() const +%feature("docstring") cmf::maps::SimpleQuadTree::__init__ "def +__init__(self, dx=20, dy=20) "; -returns the right node of this connection "; +%feature("docstring") cmf::maps::SimpleQuadTree::add_object "def +add_object(self, object, bounds) "; -%feature("docstring") -cmf::upslope::ET::PenmanMonteithET::set_stressfunction "void -set_stressfunction(const RootUptakeStessFunction &stressfunction) +%feature("docstring") cmf::maps::SimpleQuadTree::get_objects "def +get_objects(self, bounds) "; -Sets the stress function to limit water uptake. "; -%feature("docstring") -cmf::upslope::ET::PenmanMonteithET::set_tracer_filter "void -set_tracer_filter(real value) +// File: classcmf__core_1_1_simple_tindex_snow_melt.xml +%feature("docstring") cmf_core::SimpleTindexSnowMelt " -A value ranging from 0 to 1 to filter tracers out of the water flux. +Calculates snow melt using a simple degree day method. .. math:: +q_{melt} [mm/day] = (T-T_{thres}) * r Usage: C++ includes: +surfacefluxes.h "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::SimpleTindexSnowMelt::__init__ "def +__init__(self, args, kwargs) -%feature("docstring") -cmf::upslope::ET::PenmanMonteithET::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; +__init__(cmf::upslope::connections::SimpleTindexSnowMelt self, +cmf::water::WaterStorage::ptr snow, cmf::water::flux_node::ptr +surface_water, Cell cell, real rate=7.0) -> SimpleTindexSnowMelt +SimpleTindexSnowMelt(cmf::water::WaterStorage::ptr snow, +cmf::water::flux_node::ptr surface_water, cmf::upslope::Cell &cell, +real rate=7.0) Creates a new snow melt connection. Parameters: +----------- snow: Snow storage, usually cel.snow surface_water: +target of the melted water (usually cell.surfacewater) cell: The +cell, needed to get weather and area rate: The rate of snow melt, +given in mm/(degC day), default = 7.0 "; -%feature("docstring") -cmf::upslope::ET::PenmanMonteithET::short_string "virtual std::string -short_string() const "; +%feature("docstring") cmf_core::SimpleTindexSnowMelt::__contains__ "def __contains__(self, cmp) "; -%feature("docstring") cmf::upslope::ET::PenmanMonteithET::to_string "std::string to_string() const "; +%feature("docstring") cmf_core::SimpleTindexSnowMelt::__eq__ "def +__eq__(self, args, kwargs) +__eq__(flux_connection self, flux_connection other) -> bool "; -// File: classcmf_1_1river_1_1_pipe_reach.xml -%feature("docstring") cmf::river::PipeReach " +%feature("docstring") cmf_core::SimpleTindexSnowMelt::__getitem__ "def __getitem__(self, index) "; -Describes the geometry of a closed pipe. +%feature("docstring") cmf_core::SimpleTindexSnowMelt::__iter__ "def +__iter__(self) "; -C++ includes: ReachType.h "; +%feature("docstring") cmf_core::SimpleTindexSnowMelt::__repr__ "def +__repr__(self) "; -%feature("docstring") cmf::river::PipeReach::PipeReach "PipeReach(double l, double diameter) +%feature("docstring") cmf_core::SimpleTindexSnowMelt::conc "def +conc(self, args, kwargs) -Creates a tube IChannel with diameter [m]. "; +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -%feature("docstring") cmf::river::PipeReach::PipeReach "PipeReach(const PipeReach ©) "; +%feature("docstring") cmf_core::SimpleTindexSnowMelt::exchange_target +"def exchange_target(self, args, kwargs) -%feature("docstring") cmf::river::PipeReach::~PipeReach "virtual -~PipeReach() "; +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") cmf::river::PipeReach::A "virtual double -A(double V) const +%feature("docstring") cmf_core::SimpleTindexSnowMelt::get_target "def get_target(self, args) -Returns the area of the surface for a given volume. "; +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -%feature("docstring") cmf::river::PipeReach::copy "PipeReach* copy() -const "; +%feature("docstring") +cmf_core::SimpleTindexSnowMelt::get_tracer_filter "def +get_tracer_filter(self, args) -%feature("docstring") cmf::river::PipeReach::get_channel_width "virtual double get_channel_width(double depth) const +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; +%feature("docstring") cmf_core::SimpleTindexSnowMelt::kill_me "def +kill_me(self, args, kwargs) +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -.. math:: +%feature("docstring") cmf_core::SimpleTindexSnowMelt::left_node "def +left_node(self, args, kwargs) - w=2\\\\sqrt{\\\\left|r^2-(r-d)^2\\\\right|} +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -"; +%feature("docstring") cmf_core::SimpleTindexSnowMelt::q "def q(self, +args, kwargs) -%feature("docstring") cmf::river::PipeReach::get_depth "virtual -double get_depth(double area) const +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; +%feature("docstring") cmf_core::SimpleTindexSnowMelt::refresh "def +refresh(self, args, kwargs) +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; -.. math:: +%feature("docstring") cmf_core::SimpleTindexSnowMelt::right_node "def right_node(self, args, kwargs) - d=r\\\\left(1-\\\\cos{\\\\frac{A}{r^2}}\\\\right) +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; -"; +%feature("docstring") +cmf_core::SimpleTindexSnowMelt::set_tracer_filter "def +set_tracer_filter(self, args) -%feature("docstring") cmf::river::PipeReach::get_flux_crossection "virtual double get_flux_crossection(double depth) const +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; +%feature("docstring") cmf_core::SimpleTindexSnowMelt::short_string "def short_string(self, args, kwargs) +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -.. math:: +%feature("docstring") cmf_core::SimpleTindexSnowMelt::to_string "def +to_string(self, args, kwargs) - A=r^2\\\\arccos{\\\\frac{r-d}{r}{r}} +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -"; +%feature("docstring") cmf_core::SimpleTindexSnowMelt::use_for_cell "def use_for_cell(args, kwargs) -%feature("docstring") cmf::river::PipeReach::get_length "double -get_length() const +use_for_cell(Cell cell) "; -Length of the reach. "; -%feature("docstring") cmf::river::PipeReach::get_nManning "virtual -double get_nManning() const "; +// File: classcmf_1_1upslope_1_1connections_1_1_simple_tindex_snow_melt.xml +%feature("docstring") cmf::upslope::connections::SimpleTindexSnowMelt +" -%feature("docstring") cmf::river::PipeReach::get_wetted_perimeter "virtual double get_wetted_perimeter(double depth) const +Calculates snow melt using a simple degree day method. .. math:: - P=r\\\\arccos{\\\\frac{r-d}{r}} - -"; - -%feature("docstring") cmf::river::PipeReach::h "virtual double -h(double V) const - -Returns the depth of a given volume. "; + q_{melt} [mm/day] = (T-T_{thres}) * r -%feature("docstring") cmf::river::PipeReach::q "virtual double -q(double h, double slope) const "; +Usage: -%feature("docstring") cmf::river::PipeReach::qManning "virtual -double qManning(double A, double slope) const +C++ includes: surfacefluxes.h "; -Calculates the flow rate from a given water volume in the reach +%feature("docstring") +cmf::upslope::connections::SimpleTindexSnowMelt::SimpleTindexSnowMelt +"SimpleTindexSnowMelt(cmf::water::WaterStorage::ptr snow, +cmf::water::flux_node::ptr surface_water, cmf::upslope::Cell &cell, +real rate=7.0) +Creates a new snow melt connection. -.. math:: +Parameters: +----------- - q_{Manning}&=& A R^{\\\\frac 2 3} - \\\\sqrt{\\\\frac {\\\\Delta_z} n} \\\\\\\\ A &=& \\\\frac V l - \\\\mbox{, (Crosssectional area of the wetted crossection, Volume per - length)} \\\\\\\\ R &=& \\\\frac A {P(d)} \\\\\\\\ P(d) &=& \\\\mbox{ - the perimeter of the wetted crosssection, a function of reach depth} - \\\\\\\\ d(V) &=& \\\\mbox{ the depth of the reach a function of the - volume} \\\\\\\\ \\\\Delta_z &=& \\\\frac{z_{max} - z_{min}}{l} - \\\\mbox{ Slope of the reach} +snow: Snow storage, usually cel.snow -. +surface_water: target of the melted water (usually cell.surfacewater) -Flow rate [m3/s] +cell: The cell, needed to get weather and area -Parameters: ------------ +rate: The rate of snow melt, given in mm/(degC day), default = 7.0 "; -A: The area of the cross section [m2] +%feature("docstring") +cmf::upslope::connections::SimpleTindexSnowMelt::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) -slope: The slope of the reach [m/m] "; +Returns the concentration of the flux. -%feature("docstring") cmf::river::PipeReach::set_nManning "virtual -void set_nManning(double nManning) "; +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; -%feature("docstring") cmf::river::PipeReach::typecode "char -typecode() const "; +%feature("docstring") +cmf::upslope::connections::SimpleTindexSnowMelt::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr +newTarget) "; -%feature("docstring") cmf::river::PipeReach::V "virtual double -V(double h) const "; +%feature("docstring") +cmf::upslope::connections::SimpleTindexSnowMelt::get_ptr "ptr +get_ptr() const "; +%feature("docstring") +cmf::upslope::connections::SimpleTindexSnowMelt::get_target "flux_node::ptr get_target(const flux_node &inquirer) -// File: classcmf_1_1geometry_1_1point.xml -%feature("docstring") cmf::geometry::point " +Returns the other end of a connection than the asking end. "; -2D-Point Class. +%feature("docstring") +cmf::upslope::connections::SimpleTindexSnowMelt::get_target "flux_node::ptr get_target(int index) const -Used as location property anywhere in the text Calculation of -distances +With index 0, the left node is returned, with index 1 the right node +of the connection. "; -+,-,-=,*= Operators overloaded +%feature("docstring") +cmf::upslope::connections::SimpleTindexSnowMelt::get_tracer_filter "real get_tracer_filter() -C++ includes: geometry.h "; +A value ranging from 0 to 1 to filter tracers out of the water flux. -%feature("docstring") cmf::geometry::point::point "point() +1.0 is no filter and 0.0 means no solute is crossing this connection +"; -Empty Constructor. Creates an (0 0) location. "; +%feature("docstring") +cmf::upslope::connections::SimpleTindexSnowMelt::get_tracer_filter "real get_tracer_filter(solute S) -%feature("docstring") cmf::geometry::point::point "point(const point -&p) +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; -Copy Constructor. "; +%feature("docstring") +cmf::upslope::connections::SimpleTindexSnowMelt::kill_me "bool +kill_me() -%feature("docstring") cmf::geometry::point::point "point(double x_, -double y_, double z_=0.0) +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; -Creates a point from two doubles. "; +%feature("docstring") +cmf::upslope::connections::SimpleTindexSnowMelt::left_node "flux_node::ptr left_node() const -%feature("docstring") cmf::geometry::point::angleToXAxis "double -angleToXAxis(point p) const +Returns the left node of this connection. "; -Returns the angle between the line :math:`\\\\overline{this,p}` to the -x-Axis in degrees. "; +%feature("docstring") +cmf::upslope::connections::SimpleTindexSnowMelt::q "real q(const +flux_node &inquirer, cmf::math::Time t) -%feature("docstring") cmf::geometry::point::azimuth "double -azimuth(point p) const +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; -Returns the azimuth angle of the line :math:`\\\\overline{this,p}` to the -Azimuth in degrees. "; +%feature("docstring") +cmf::upslope::connections::SimpleTindexSnowMelt::refresh "void +refresh(cmf::math::Time t) -%feature("docstring") cmf::geometry::point::distance3DTo "double -distance3DTo(point p) const +Performes a new calculation of the flux. "; -Returns the euclidian distance in space to another point p. "; +%feature("docstring") +cmf::upslope::connections::SimpleTindexSnowMelt::right_node "flux_node::ptr right_node() const -%feature("docstring") cmf::geometry::point::distance_max "double -distance_max(point p) const +returns the right node of this connection "; -Returns the distance by the maximum orthogonal offset. "; +%feature("docstring") +cmf::upslope::connections::SimpleTindexSnowMelt::set_tracer_filter "void set_tracer_filter(real value) -%feature("docstring") cmf::geometry::point::distanceTo "double -distanceTo(point p) const +A value ranging from 0 to 1 to filter tracers out of the water flux. -Returns the horizontal euclidian distance to another point p. +1.0 is no filter and 0.0 means no solute is crossing this connection +"; -:math:`\\\\sqrt{(this.x-p.x)^2+(this.y-p.y)^2}` "; +%feature("docstring") +cmf::upslope::connections::SimpleTindexSnowMelt::set_tracer_filter "void set_tracer_filter(solute S, real value) "; -%feature("docstring") cmf::geometry::point::length "double length() -const "; +%feature("docstring") +cmf::upslope::connections::SimpleTindexSnowMelt::short_string "virtual std::string short_string() const "; -%feature("docstring") cmf::geometry::point::sum "double sum() const +%feature("docstring") +cmf::upslope::connections::SimpleTindexSnowMelt::to_string "virtual +std::string to_string() const "; -Returns x+y+z. "; -%feature("docstring") cmf::geometry::point::z_weight_distance "double z_weight_distance(point p, double z_weight) const +// File: classcmf__core_1_1_simpl_richards.xml +%feature("docstring") cmf_core::SimplRichards " -Returns the horizontal euclidian distance plus the absolute of the -height difference times a factor. +Calculates flow according to a simplified Richards equation. .. +math:: q_{Richards} &=& (K(\\\\\\\\theta) - K(\\\\\\\\theta_r)) +A \\\\\\\\\\\\\\\\ where :math:`d [m]` is the distance between the +two soil layers :math:`K(\\\\\\\\theta)\\\\\\\\left[\\\\\\\\frac +m{day}\\\\\\\\right]` is the geometric mean conductivity (see +SoilType::Kunsat) :math:`A [m^2]` is the crosssectional area of the +flux C++ includes: Percolation.h "; -:math:`\\\\sqrt{(this.x-p.x)^2+(this.y-p.y)^2}\\\\ +\\\\ w_{z}|this.z-p.z|` -"; +%feature("docstring") cmf_core::SimplRichards::__init__ "def +__init__(self, args, kwargs) +__init__(cmf::upslope::connections::SimplRichards self, +cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right) +-> SimplRichards SimplRichards(cmf::upslope::SoilLayer::ptr left, +cmf::water::flux_node::ptr right) "; -// File: classcmf_1_1geometry_1_1point__vector.xml -%feature("docstring") cmf::geometry::point_vector " +%feature("docstring") cmf_core::SimplRichards::__contains__ "def +__contains__(self, cmp) "; -Holds three arrays x,y and z for fast access of point coordinates. +%feature("docstring") cmf_core::SimplRichards::__eq__ "def +__eq__(self, args, kwargs) -C++ includes: geometry.h "; +__eq__(flux_connection self, flux_connection other) -> bool "; -%feature("docstring") cmf::geometry::point_vector::point_vector "point_vector(ptrdiff_t size) +%feature("docstring") cmf_core::SimplRichards::__getitem__ "def +__getitem__(self, index) "; -Create a point vector of a specific size. "; +%feature("docstring") cmf_core::SimplRichards::__iter__ "def +__iter__(self) "; -%feature("docstring") cmf::geometry::point_vector::get "point -get(ptrdiff_t index) const +%feature("docstring") cmf_core::SimplRichards::__repr__ "def +__repr__(self) "; -Return a point at index. "; +%feature("docstring") cmf_core::SimplRichards::conc "def conc(self, +args, kwargs) -%feature("docstring") cmf::geometry::point_vector::set "void -set(ptrdiff_t index, cmf::geometry::point p) +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -Change the point at index. "; +%feature("docstring") cmf_core::SimplRichards::exchange_target "def +exchange_target(self, args, kwargs) -%feature("docstring") cmf::geometry::point_vector::size "size_t -size() const +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -Return the number of points in the point_vector. "; +%feature("docstring") cmf_core::SimplRichards::get_target "def +get_target(self, args) +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -// File: classcmf_1_1maps_1_1_polygon_map.xml -%feature("docstring") cmf::maps::PolygonMap " +%feature("docstring") cmf_core::SimplRichards::get_tracer_filter "def get_tracer_filter(self, args) -A map of polygons. Each object is referenced with a shapely polygon. -Returns the object of the first polygon, within the query position -lays. "; +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -%feature("docstring") cmf::maps::PolygonMap::__init__ "def -__init__(self, quad_tree_raster_size=20) "; +%feature("docstring") cmf_core::SimplRichards::kill_me "def +kill_me(self, args, kwargs) -%feature("docstring") cmf::maps::PolygonMap::__call__ "def -__call__(self, x, y, z=0) "; +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -%feature("docstring") cmf::maps::PolygonMap::__iter__ "def -__iter__(self) "; +%feature("docstring") cmf_core::SimplRichards::left_node "def +left_node(self, args, kwargs) -%feature("docstring") cmf::maps::PolygonMap::__nonzero__ "def -__nonzero__(self) "; +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -%feature("docstring") cmf::maps::PolygonMap::append "def -append(self, polygon, object) "; +%feature("docstring") cmf_core::SimplRichards::q "def q(self, args, +kwargs) -%feature("docstring") cmf::maps::PolygonMap::remove "def -remove(self, polygon) "; +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; -%feature("docstring") cmf::maps::PolygonMap::values "def -values(self) "; +%feature("docstring") cmf_core::SimplRichards::refresh "def +refresh(self, args, kwargs) +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; -// File: classcmf_1_1water_1_1_power_law_connection.xml -%feature("docstring") cmf::water::PowerLawConnection " +%feature("docstring") cmf_core::SimplRichards::right_node "def +right_node(self, args, kwargs) -Calculates flux out of a storage as a linear function of its volume to -a power. +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; -This connection serves the same purpose as the old kinematic_wave -connection, but the parameters are easier to explain. +%feature("docstring") cmf_core::SimplRichards::set_tracer_filter "def set_tracer_filter(self, args) +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; +%feature("docstring") cmf_core::SimplRichards::short_string "def +short_string(self, args, kwargs) -.. math:: +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; - q = Q_0 {\\\\left(\\\\frac{V - V_{residual}}{V_0} - \\\\right)^\\\\beta} +%feature("docstring") cmf_core::SimplRichards::to_string "def +to_string(self, args, kwargs) -where: :math:`V` The actual volume of water -stored in source +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -:math:`V_{residual} [m^3]` The volume of water not flowing out (default = 0) +%feature("docstring") cmf_core::SimplRichards::use_for_cell "def +use_for_cell(args, kwargs) -:math:`V_0` A reference volume to scale the outflux. One can see :math:`V_0` as -the inflection point of the outflow curve +use_for_cell(Cell cell, bool no_override=True) "; -:math:`\\\\beta` A parameter to shape the response curve. :math:`Q_0` is the -outflow from the source in :math:`\\\\frac{m^3}{day}`, when :math:`V = V_0`. -WARNING: :math:`\\\\beta < 0.5` may lead to numerical troubles and have a -dubious hydrological meaning. Please avoid. +// File: classcmf_1_1upslope_1_1connections_1_1_simpl_richards.xml +%feature("docstring") cmf::upslope::connections::SimplRichards " -C++ includes: simple_connections.h "; +Calculates flow according to a simplified Richards equation. -%feature("docstring") -cmf::water::PowerLawConnection::PowerLawConnection "PowerLawConnection(WaterStorage::ptr source, flux_node::ptr target, -real Q0, real V0, real beta=1.0, real residual=0.0) -Creates a power law connection. -Parameters: ------------ +.. math:: -source: Water storage from which the water flows out. Flux is a -function of source.volume + q_{Richards} &=& (K(\\\\theta) - K(\\\\theta_r)) + A \\\\\\\\ -target: Target node (boundary condition or storage). Does not -influence the strength of the flow + where :math:`d [m]` is the distance between +the two soil layers -Q0: Reference flow :math:`Q_0 = q(V_0)` Outflow when the source storage -equals the reference volume +:math:`K(\\\\theta)\\\\left[\\\\frac m{day}\\\\right]` is the geometric +mean conductivity (see SoilType::Kunsat) -V0: Reference volume :math:`V_0` The reference volume to scale the exponent +:math:`A [m^2]` is the crosssectional area of the flux -beta: :math:`\\\\beta [-]` An empirical exponent to shape the flux -function (default = 1 (linear function)) +C++ includes: Percolation.h "; -residual: :math:`V_{residual} [m^3]` The volume of water not flowing out -(default = 0) "; +%feature("docstring") +cmf::upslope::connections::SimplRichards::SimplRichards "SimplRichards(cmf::upslope::SoilLayer::ptr left, +cmf::water::flux_node::ptr right) "; -%feature("docstring") cmf::water::PowerLawConnection::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +%feature("docstring") cmf::upslope::connections::SimplRichards::conc +"real conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns the concentration of the flux. If not overridden, it returns the concentration of the source of the flux (direction depending) "; -%feature("docstring") cmf::water::PowerLawConnection::exchange_target -"void exchange_target(flux_node::ptr oldtarget, flux_node::ptr -newTarget) "; +%feature("docstring") +cmf::upslope::connections::SimplRichards::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") cmf::water::PowerLawConnection::get_ptr "ptr -get_ptr() const "; +%feature("docstring") +cmf::upslope::connections::SimplRichards::get_ptr "ptr get_ptr() +const "; -%feature("docstring") cmf::water::PowerLawConnection::get_target "flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") +cmf::upslope::connections::SimplRichards::get_target "flux_node::ptr +get_target(const flux_node &inquirer) Returns the other end of a connection than the asking end. "; -%feature("docstring") cmf::water::PowerLawConnection::get_target "flux_node::ptr get_target(int index) const +%feature("docstring") +cmf::upslope::connections::SimplRichards::get_target "flux_node::ptr +get_target(int index) const With index 0, the left node is returned, with index 1 the right node of the connection. "; %feature("docstring") -cmf::water::PowerLawConnection::get_tracer_filter "real +cmf::upslope::connections::SimplRichards::get_tracer_filter "real get_tracer_filter() A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -10896,39 +28849,43 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::water::PowerLawConnection::get_tracer_filter "real +cmf::upslope::connections::SimplRichards::get_tracer_filter "real get_tracer_filter(solute S) A value ranging from 0 to 1 to filter tracers out of the water flux. "; -%feature("docstring") cmf::water::PowerLawConnection::kill_me "bool -kill_me() +%feature("docstring") +cmf::upslope::connections::SimplRichards::kill_me "bool kill_me() Deregisters this connection from its nodes. Returns true if only one reference is left. "; -%feature("docstring") cmf::water::PowerLawConnection::left_node "flux_node::ptr left_node() const +%feature("docstring") +cmf::upslope::connections::SimplRichards::left_node "flux_node::ptr +left_node() const Returns the left node of this connection. "; -%feature("docstring") cmf::water::PowerLawConnection::q "real -q(const flux_node &inquirer, cmf::math::Time t) +%feature("docstring") cmf::upslope::connections::SimplRichards::q "real q(const flux_node &inquirer, cmf::math::Time t) Returns the current flux through a connection. Negative signs mean out of the inquirer, positive are inflows to the inquirer. "; -%feature("docstring") cmf::water::PowerLawConnection::refresh "void +%feature("docstring") +cmf::upslope::connections::SimplRichards::refresh "void refresh(cmf::math::Time t) Performes a new calculation of the flux. "; -%feature("docstring") cmf::water::PowerLawConnection::right_node "flux_node::ptr right_node() const +%feature("docstring") +cmf::upslope::connections::SimplRichards::right_node "flux_node::ptr +right_node() const returns the right node of this connection "; %feature("docstring") -cmf::water::PowerLawConnection::set_tracer_filter "void +cmf::upslope::connections::SimplRichards::set_tracer_filter "void set_tracer_filter(real value) A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -10937,84 +28894,55 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::water::PowerLawConnection::set_tracer_filter "void +cmf::upslope::connections::SimplRichards::set_tracer_filter "void set_tracer_filter(solute S, real value) "; -%feature("docstring") cmf::water::PowerLawConnection::short_string "virtual std::string short_string() const "; - -%feature("docstring") cmf::water::PowerLawConnection::to_string "virtual std::string to_string() const "; - - -// File: classcmf_1_1math_1_1precalculatable.xml -%feature("docstring") cmf::math::precalculatable ""; - -%feature("docstring") cmf::math::precalculatable::do_action "virtual -void do_action(Time t, bool use_OpenMP=true)=0 "; - - -// File: classcmf_1_1upslope_1_1_e_t_1_1_priestley_taylor_e_t.xml -%feature("docstring") cmf::upslope::ET::PriestleyTaylorET " - -Calculates the Evapotranspiration using Priestley-Taylor equation. - - - -.. math:: - - lambda ET = \\\\alpha \\\\frac{\\\\Delta}{\\\\Delta + \\\\gamma} - \\\\left(R_n - G\\\\right) - -where: :math:`\\\\Delta = 4098 \\\\frac{0.6108 e^{17.27 T}}{(T+237.3)^2} \\\\frac{kPa}{^\\\\circ C}`, -the slope of the vapor pressure/ temperature curve - -:math:`\\\\gamma = \\\\frac{c_p P}{\\\\epsilon \\\\lambda} \\\\frac{kPa}{^\\\\circ C}` Psychrometric constant +%feature("docstring") +cmf::upslope::connections::SimplRichards::short_string "virtual +std::string short_string() const "; -:math:`\\\\lambda = 2.45 \\\\frac{MJ}{kg}` the latent heat of vaporization +%feature("docstring") +cmf::upslope::connections::SimplRichards::to_string "virtual +std::string to_string() const "; -:math:`R_n \\\\frac{MJ}{m^2day}` net Radiation (see Atmosphere) -:math:`G` Ground heat flux +// File: classcmf_1_1upslope_1_1connections_1_1_snowfall.xml +%feature("docstring") cmf::upslope::connections::Snowfall " -:math:`\\\\alpha` the Priestley-Taylor constant (default 1.26 for humid -climates) +A connection routing snowfall (precipitation below freezing Temp) to +the snow pack. -C++ includes: ET.h "; +C++ includes: AtmosphericFluxes.h "; -%feature("docstring") -cmf::upslope::ET::PriestleyTaylorET::PriestleyTaylorET "PriestleyTaylorET(cmf::upslope::SoilLayer::ptr source, -cmf::water::flux_node::ptr ET_target, real alpha=1.26) "; +%feature("docstring") cmf::upslope::connections::Snowfall::Snowfall "Snowfall(cmf::water::flux_node::ptr target, cmf::upslope::Cell &cell) +"; -%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) +%feature("docstring") cmf::upslope::connections::Snowfall::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns the concentration of the flux. If not overridden, it returns the concentration of the source of the flux (direction depending) "; -%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::ETpot "real ETpot(cmf::math::Time t) const "; - %feature("docstring") -cmf::upslope::ET::PriestleyTaylorET::exchange_target "void +cmf::upslope::connections::Snowfall::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::get_layer -"SoilLayer::ptr get_layer() const "; - -%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::get_ptr "ptr get_ptr() const "; +%feature("docstring") cmf::upslope::connections::Snowfall::get_ptr "ptr get_ptr() const "; -%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::get_target +%feature("docstring") cmf::upslope::connections::Snowfall::get_target "flux_node::ptr get_target(const flux_node &inquirer) Returns the other end of a connection than the asking end. "; -%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::get_target +%feature("docstring") cmf::upslope::connections::Snowfall::get_target "flux_node::ptr get_target(int index) const With index 0, the left node is returned, with index 1 the right node of the connection. "; %feature("docstring") -cmf::upslope::ET::PriestleyTaylorET::get_tracer_filter "real +cmf::upslope::connections::Snowfall::get_tracer_filter "real get_tracer_filter() A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -11023,45 +28951,39 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::ET::PriestleyTaylorET::get_tracer_filter "real +cmf::upslope::connections::Snowfall::get_tracer_filter "real get_tracer_filter(solute S) A value ranging from 0 to 1 to filter tracers out of the water flux. "; -%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::kill_me "bool kill_me() +%feature("docstring") cmf::upslope::connections::Snowfall::kill_me "bool kill_me() Deregisters this connection from its nodes. Returns true if only one reference is left. "; -%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::left_node +%feature("docstring") cmf::upslope::connections::Snowfall::left_node "flux_node::ptr left_node() const Returns the left node of this connection. "; -%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::q "real +%feature("docstring") cmf::upslope::connections::Snowfall::q "real q(const flux_node &inquirer, cmf::math::Time t) Returns the current flux through a connection. Negative signs mean out of the inquirer, positive are inflows to the inquirer. "; -%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::refresh "void refresh(cmf::math::Time t) +%feature("docstring") cmf::upslope::connections::Snowfall::refresh "void refresh(cmf::math::Time t) Performes a new calculation of the flux. "; -%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::right_node +%feature("docstring") cmf::upslope::connections::Snowfall::right_node "flux_node::ptr right_node() const returns the right node of this connection "; %feature("docstring") -cmf::upslope::ET::PriestleyTaylorET::set_stressfunction "void -set_stressfunction(const RootUptakeStessFunction &stressfunction) - -Sets the stress function to limit water uptake. "; - -%feature("docstring") -cmf::upslope::ET::PriestleyTaylorET::set_tracer_filter "void +cmf::upslope::connections::Snowfall::set_tracer_filter "void set_tracer_filter(real value) A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -11070,677 +28992,648 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::ET::PriestleyTaylorET::set_tracer_filter "void +cmf::upslope::connections::Snowfall::set_tracer_filter "void set_tracer_filter(solute S, real value) "; %feature("docstring") -cmf::upslope::ET::PriestleyTaylorET::short_string "virtual +cmf::upslope::connections::Snowfall::short_string "virtual std::string short_string() const "; -%feature("docstring") cmf::upslope::ET::PriestleyTaylorET::to_string -"std::string to_string() const "; - - -// File: classcmf_1_1river_1_1_prism.xml -%feature("docstring") cmf::river::Prism " - -the height of a volume in a Prism with a defined base area - -C++ includes: ReachType.h "; - -%feature("docstring") cmf::river::Prism::Prism "Prism(double -base_area, double thickness_of_rough_ground=0.01) "; - -%feature("docstring") cmf::river::Prism::~Prism "~Prism() "; - -%feature("docstring") cmf::river::Prism::A "double A(double V) const - -:math:`A(V) = A_{base}` "; - -%feature("docstring") cmf::river::Prism::copy "Prism* copy() const -"; - -%feature("docstring") cmf::river::Prism::h "double h(double V) const - -:math:`h(V) = \\\\frac V A_{base}` "; - -%feature("docstring") cmf::river::Prism::q "virtual double q(double -h, double slope) const "; - -%feature("docstring") cmf::river::Prism::V "double V(double h) const -"; - - -// File: classcmf_1_1project.xml -%feature("docstring") cmf::project " - -The study area, holding all cells, outlets and streams. - -Todo Describe tracers - -C++ includes: project.h "; - -%feature("docstring") cmf::project::project "project(std::string -solute_names=\"\") - -Creates a new project. - -Parameters: ------------ - -solute_names: A string representing the names of the solutes to be -used in the project. Sepereate solute names with space. "; - -%feature("docstring") cmf::project::~project "~project() "; - -%feature("docstring") cmf::project::get_cell "upslope::Cell& -get_cell(ptrdiff_t index) - -Returns the reference to the cell at index in the project. "; - -%feature("docstring") cmf::project::get_cells "const -upslope::cell_vector& get_cells() const - -Returns the cells in the project. "; - -%feature("docstring") cmf::project::get_node "cmf::water::flux_node::ptr get_node(ptrdiff_t index) +%feature("docstring") cmf::upslope::connections::Snowfall::to_string +"virtual std::string to_string() const "; -Returns the node from the project nodes at index. "; -%feature("docstring") cmf::project::get_reach "cmf::river::Reach::ptr get_reach(ptrdiff_t index) +// File: classcmf__core_1_1_snowfall.xml +%feature("docstring") cmf_core::Snowfall " -Returns the reach at index. "; +A connection routing snowfall (precipitation below freezing Temp) to +the snow pack. C++ includes: AtmosphericFluxes.h "; -%feature("docstring") cmf::project::get_states "cmf::math::StateVariableList get_states() +%feature("docstring") cmf_core::Snowfall::__init__ "def +__init__(self, args, kwargs) -Returns all state variables of the project. Mostly for internal use. +__init__(cmf::upslope::connections::Snowfall self, +cmf::water::flux_node::ptr target, Cell cell) -> Snowfall +Snowfall(cmf::water::flux_node::ptr target, cmf::upslope::Cell &cell) "; -%feature("docstring") cmf::project::get_storages "cmf::water::node_list get_storages() +%feature("docstring") cmf_core::Snowfall::__contains__ "def +__contains__(self, cmp) "; -Returns a list of all storages of this project. "; +%feature("docstring") cmf_core::Snowfall::__eq__ "def __eq__(self, +args, kwargs) -%feature("docstring") cmf::project::NewCell "cmf::upslope::Cell* -NewCell(double x, double y, double z, double area, bool -with_surfacewater=false) +__eq__(flux_connection self, flux_connection other) -> bool "; -Creates a new cell. +%feature("docstring") cmf_core::Snowfall::__getitem__ "def +__getitem__(self, index) "; -A new cell, owned by the project +%feature("docstring") cmf_core::Snowfall::__iter__ "def +__iter__(self) "; -Parameters: ------------ +%feature("docstring") cmf_core::Snowfall::__repr__ "def +__repr__(self) "; -x: y: z: Position of the cell center in project coordinates (m) +%feature("docstring") cmf_core::Snowfall::conc "def conc(self, args, +kwargs) -area: Area of the cell in m^2 +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -with_surfacewater: If true, the cell will own a surfacewater storage -upon creation "; +%feature("docstring") cmf_core::Snowfall::exchange_target "def +exchange_target(self, args, kwargs) -%feature("docstring") cmf::project::NewNeumannBoundary "cmf::water::NeumannBoundary::ptr NewNeumannBoundary(std::string name, -cmf::water::WaterStorage::ptr target) +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -Creates a new Neumann boundary for a target water storage. +%feature("docstring") cmf_core::Snowfall::get_target "def +get_target(self, args) -The boundary is stored with the project A new Neumann boundary +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -Parameters: ------------ +%feature("docstring") cmf_core::Snowfall::get_tracer_filter "def +get_tracer_filter(self, args) -name: The name of the boundary condition +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -target: The water storage to which the Neumann boundary is bound "; +%feature("docstring") cmf_core::Snowfall::kill_me "def kill_me(self, +args, kwargs) -%feature("docstring") cmf::project::NewOpenStorage "cmf::river::OpenWaterStorage::ptr NewOpenStorage(std::string name, -double x, double y, double z, double area) +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -Creates a new open water storage with a prism geometry. +%feature("docstring") cmf_core::Snowfall::left_node "def +left_node(self, args, kwargs) -The open water storage is added to the project nodes A new open water -storage, owned by the project +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -Parameters: ------------ +%feature("docstring") cmf_core::Snowfall::q "def q(self, args, +kwargs) -name: Name of the open water storage for output +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; -x: y: z: Position of the open water storage in project coordinates +%feature("docstring") cmf_core::Snowfall::refresh "def refresh(self, +args, kwargs) -area: Surface area of the open water storage "; +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; -%feature("docstring") cmf::project::NewOutlet "cmf::water::DirichletBoundary::ptr NewOutlet(std::string name, double -x=0, double y=0, double z=0) +%feature("docstring") cmf_core::Snowfall::right_node "def +right_node(self, args, kwargs) -Creates a new Dirichlet boundary condition and adds it to the list of -outlets The potential of the Dirichlet boundary equals z, but can be -changed. +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; -Parameters: ------------ +%feature("docstring") cmf_core::Snowfall::set_tracer_filter "def +set_tracer_filter(self, args) -name: Name of the boundary condition for output +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; -x: y: z: Position of the boundary condition in project coordinates -"; +%feature("docstring") cmf_core::Snowfall::short_string "def +short_string(self, args, kwargs) -%feature("docstring") cmf::project::NewReach "cmf::river::Reach::ptr -NewReach(double x, double y, double z, cmf::river::IChannel &shape, -bool diffusive=false) +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -Creates a new reach. +%feature("docstring") cmf_core::Snowfall::to_string "def +to_string(self, args, kwargs) -A new reach, owned by the project +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -Parameters: ------------ -x: y: z: Position of the reach in project coordinates +// File: classcmf__core_1_1_soil_layer.xml +%feature("docstring") cmf_core::SoilLayer " -shape: Crossectional geometry of the river. Any class inheriting from -cmf::water::IChannel +A representation of a SoilLayer. C++ includes: SoilLayer.h "; -diffusive: If true, this reach uses by default a diffusive wave -connection "; +%feature("docstring") cmf_core::SoilLayer::__init__ "def +__init__(self, args, kwargs) "; -%feature("docstring") cmf::project::NewStorage "cmf::water::WaterStorage::ptr NewStorage(std::string name, double x=0, -double y=0, double z=0) +%feature("docstring") cmf_core::SoilLayer::__call__ "def +__call__(self, args, kwargs) -Creates a new generic water storage at position x,y,z. +__call__(flux_node self, Time t) -> real "; -The storage is added to the project nodes A new water storage, owned -by the project +%feature("docstring") cmf_core::SoilLayer::__eq__ "def __eq__(self, +args, kwargs) -Parameters: ------------ +__eq__(flux_node self, flux_node other) -> bool "; -name: Name of the generic water storage for output +%feature("docstring") cmf_core::SoilLayer::__getitem__ "def +__getitem__(self, args, kwargs) -x: y: z: Position of the generic water storage condition in project -coordinates "; +__getitem__(WaterStorage self, solute X) -> SoluteStorage "; -%feature("docstring") cmf::project::node_count "size_t node_count() -const +%feature("docstring") cmf_core::SoilLayer::__repr__ "def +__repr__(self) "; -Returns the number of nodes saved with this project. "; +%feature("docstring") cmf_core::SoilLayer::cast "def cast(args, +kwargs) -%feature("docstring") cmf::project::reach_count "size_t -reach_count() const +cast(cmf::water::flux_node::ptr node) -> cmf::upslope::SoilLayer::ptr +"; -Returns the number of reaches in this project. "; +%feature("docstring") cmf_core::SoilLayer::conc "def conc(self, +args, kwargs) -%feature("docstring") cmf::project::remove_node "size_t -remove_node(cmf::water::flux_node::ptr node) +conc(flux_node self, Time t, solute Solute) -> real virtual real +conc(cmf::math::Time t, const cmf::water::solute &Solute) const +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; -Removes a node from the repository. +%feature("docstring") cmf_core::SoilLayer::conc "def conc(self, +args) -Removes a node (boundary condition or water storage) from the node -repository of the project. NOTE: If you have other references to this -node, the node is not deleted. If you are creating a new solver, the -node will not be part of the solver. "; +conc(WaterStorage self, solute _Solute) -> real conc(WaterStorage +self, Time t, solute _Solute) -> real conc(WaterStorage self, solute +_Solute, real NewConcetration) void conc(const cmf::water::solute +&_Solute, real NewConcetration) Sets a new concentration. "; -%feature("docstring") cmf::project::size "size_t size() const +%feature("docstring") cmf_core::SoilLayer::connected_nodes "def +connected_nodes(self) "; -The number of cells in the project. "; +%feature("docstring") cmf_core::SoilLayer::connection_to "def +connection_to(self, args, kwargs) -%feature("docstring") cmf::project::use_IDW_meteo "void -use_IDW_meteo(double z_weight=0, double power=2) +connection_to(flux_node self, flux_node target) -> flux_connection +cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) Returns the connection between this and target. "; -Uses IDW interpolation to generate meterological data for each cell of -project. +%feature("docstring") cmf_core::SoilLayer::create "def create(args, +kwargs) -Creates a meteo-data source for each cell, using spatial interpolated -data from all meteorological stations of the project using Inverse -Distance Weighted (IDW) interpolation. The meteorolgical value f is -calculated with IDW for position x,y,z and time t as follows: +create(project _project, real initial_state=0.0, real scale=1.0) -> +std::shared_ptr< cmf::water::WaterStorage > "; +%feature("docstring") cmf_core::SoilLayer::dxdt "def dxdt(self, +args, kwargs) -.. math:: +dxdt(StateVariable self, Time time) -> real virtual real dxdt(const +cmf::math::Time &time)=0 Returns the derivate of the state variable +at time time. "; - f(x,y,z,t) &=& \\\\sum^N_{i=1}{f_i(t) w_i(x,y,z)} - \\\\\\\\ w_i(x,y,z) &=& - \\\\frac{d_i(x,y,z)^{-p}}{\\\\sum^N_{j=0}{d_j(x,y,z)^{-p}}} \\\\\\\\ - d_i(x,y,z) &=& w_z \\\\left|z-z_i\\\\right| + - \\\\sqrt{\\\\left(x-x_i\\\\right)^2 + \\\\left(y-y_i\\\\right)^2} - +%feature("docstring") cmf_core::SoilLayer::flux3d_to "def +flux3d_to(self, args, kwargs) - :math:`N` is the number of stations +flux3d_to(flux_node self, flux_node target, Time t) -> point +cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; -:math:`f_i(t)` the meteorological value at time t, eg. Temperature, Humidity +%feature("docstring") cmf_core::SoilLayer::flux_to "def +flux_to(self, args, kwargs) -:math:`w_i` is the weight of station i +flux_to(flux_node self, flux_node target, Time t) -> real real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; -:math:`d_i` is the distance from x,y,z to station i +%feature("docstring") cmf_core::SoilLayer::fluxes "def fluxes(self, +t) "; -:math:`p` the power of the weighting function, usually 2. +%feature("docstring") cmf_core::SoilLayer::from_node "def +from_node(args, kwargs) -:math:`x_i,y_i,z_i` is the position of station i in space +from_node(cmf::water::flux_node::ptr node) -> std::shared_ptr< +cmf::water::WaterStorage > "; -:math:`w_z` is a factor to weight the vertical distance between stations and -the cell. 0 results in a pure horizontal interpolation (normal IDW). -If :math:`w_z=1`, height difference is as important as horizontal distance, -and with :math:`w_z>1` the height difference is weighted more important than -horizontal distance See: IDW_Meteorology +%feature("docstring") cmf_core::SoilLayer::get_3d_flux "def +get_3d_flux(self, args, kwargs) -Parameters: ------------ +get_3d_flux(flux_node self, Time t) -> point cmf::geometry::point +get_3d_flux(cmf::math::Time t) Returns the sum of all flux vectors. +"; -z_weight: :math:`w_z` the weight of height difference between cell and -station +%feature("docstring") cmf_core::SoilLayer::get_abs_errtol "def +get_abs_errtol(self, args, kwargs) -power: the power of the distance weight "; +get_abs_errtol(StateVariable self, real rel_errtol) -> real virtual +real get_abs_errtol(real rel_errtol) const "; -%feature("docstring") cmf::project::use_IDW_rainfall "void -use_IDW_rainfall(double z_weight=0, double power=2) +%feature("docstring") cmf_core::SoilLayer::get_capacity "def +get_capacity(self, args, kwargs) -Uses IDW interpolation to generate rainfall data for each cell of -project. +get_capacity(SoilLayer self) -> real virtual real get_capacity() +const Returns the capacity of the water storage in m3. "; -Creates a rainfall-data source for each cell, using spatial -interpolated data from all meteorological stations of the project -using Inverse Distance Weighted (IDW) interpolation. The rainfall -intensity P is calculated with IDW for position x,y,z and time t as -follows: +%feature("docstring") cmf_core::SoilLayer::get_flow_crosssection "def get_flow_crosssection(self, args, kwargs) -.. math:: +get_flow_crosssection(SoilLayer self, SoilLayer target, bool +HorizontalLayers=False) -> real real get_flow_crosssection(const +cmf::upslope::SoilLayer &target, bool HorizontalLayers=false) const +Calculates the shared crosssectional area of this and another soil +water storage. If both layers belong to the same cell, the area of +the cell is returned, if they belong to different cells the area of +the vertical shared boundary is returned get_area in m2 Parameters: +----------- target: The other soil water storage HorizontalLayers: +If true, the layers are assumed to be parallel to the gravitational +potential, otherwise they are assumed to be parallel to the ground +topography "; - P(x,y,z,t) &=& \\\\sum^N_{i=1}{P_i(t) - w_i(x,y,z)} \\\\\\\\ w_i(x,y,z) &=& - \\\\frac{d_i(x,y,z)^{-p}}{\\\\sum^N_{j=0}{d_j(x,y,z)^{-p}}} \\\\\\\\ - d_i(x,y,z) &=& w_z \\\\left|z-z_i\\\\right| + - \\\\sqrt{\\\\left(x-x_i\\\\right)^2 + \\\\left(y-y_i\\\\right)^2} - +%feature("docstring") cmf_core::SoilLayer::get_K "def get_K(self, +args, kwargs) - :math:`N` is the number of stations +get_K(SoilLayer self, point direction) -> real virtual real +get_K(cmf::geometry::point direction) const Returns the actual +anisotropic conductivity along a direction :math:`K = (k_f +\\\\\\\\cdot d) K`. "; -:math:`P_i(t)` the meteorological value at time t, eg. Temperature, Humidity +%feature("docstring") cmf_core::SoilLayer::get_saturated_depth "def +get_saturated_depth(self, args, kwargs) -:math:`w_i` is the weight of station i +get_saturated_depth(SoilLayer self) -> real virtual real +get_saturated_depth() const Returns the depth for saturation .. +math:: z_{sat,this} = +\\\\\\\\left\\\\\\\\{z_{cell}-\\\\\\\\Psi_{tot} \\\\\\\\mbox{ if } W<1 +\\\\\\\\\\\\\\\\ z_{sat,upper layer} \\\\\\\\right. . "; -:math:`d_i` is the distance from x,y,z to station i +%feature("docstring") cmf_core::SoilLayer::get_soil "def +get_soil(self, args, kwargs) -:math:`p` the power of the weighting function, usually 2. +get_soil(SoilLayer self) -> RetentionCurve virtual +cmf::upslope::RetentionCurve& get_soil() const Returns the soil +properties of the water storage. "; -:math:`x_i,y_i,z_i` is the position of station i in space +%feature("docstring") cmf_core::SoilLayer::get_states "def +get_states(self, args, kwargs) -:math:`w_z` is a factor to weight the vertical distance between stations and -the cell. 0 results in a pure horizontal interpolation (normal IDW). -If :math:`w_z=1`, height difference is as important as horizontal distance, -and with :math:`w_z>1` the height difference is weighted more important than -horizontal distance See: IDW_Meteorology +get_states(StateVariableOwner self) -> StateVariableList virtual +StateVariableList get_states()=0 Add the state variables, owned by an +object derived from StateVariableOwner, to the given vector. "; -Parameters: ------------ +%feature("docstring") cmf_core::SoilLayer::is_connected "def +is_connected(self, args, kwargs) -z_weight: :math:`w_z` the weight of height difference between cell and -station +is_connected(StateVariable self, StateVariable other) -> bool virtual +bool is_connected(const cmf::math::StateVariable &other) const "; -power: the power of the distance weight "; +%feature("docstring") cmf_core::SoilLayer::is_empty "def +is_empty(self, args, kwargs) -%feature("docstring") cmf::project::use_nearest_meteo "void -use_nearest_meteo(double z_weight=0) +is_empty(flux_node self) -> double virtual double is_empty() const +Returns true if the node has no water. "; -Connects all cells of the project with its nearest meteorological -station. +%feature("docstring") cmf_core::SoilLayer::is_storage "def +is_storage(self, args, kwargs) -Distance is calculated as follows: +is_storage(flux_node self) -> bool virtual bool is_storage() const +true, if this is a waterstorage "; -.. math:: +%feature("docstring") cmf_core::SoilLayer::RecalcFluxes "def +RecalcFluxes(self, args, kwargs) - d_i(x,y,z) = w_z - \\\\left|z-z_i\\\\right| + \\\\sqrt{\\\\left(x-x_i\\\\right)^2 + - \\\\left(y-y_i\\\\right)^2} +RecalcFluxes(flux_node self, Time t) -> bool virtual bool +RecalcFluxes(cmf::math::Time t) Pure flux_nodes do not influence +fluxes, therefore no recalculation of fluxes is required by flux_node. +WaterStorage overrides this, since state changes require an update of +the fluxes "; -:math:`d_i` is the distance from x,y,z to -station i +%feature("docstring") cmf_core::SoilLayer::remove_connection "def +remove_connection(self, args, kwargs) -:math:`p` the power of the weighting function, usually 2. +remove_connection(flux_node self, cmf::water::flux_node::ptr To) -> +bool bool remove_connection(cmf::water::flux_node::ptr To) Remove +the connection. "; -:math:`x_i,y_i,z_i` is the position of station i in space +%feature("docstring") cmf_core::SoilLayer::set_soil "def +set_soil(self, args, kwargs) -:math:`w_z` is a factor to weight the vertical distance between stations and -the cell. 0 results in a pure horizontal interpolation (normal IDW). -If :math:`w_z=1`, height difference is as important as horizontal distance, -and with :math:`w_z>1` the height difference is weighted more important than -horizontal distance +set_soil(SoilLayer self, RetentionCurve r_curve) virtual void +set_soil(const cmf::upslope::RetentionCurve &r_curve) "; -Parameters: ------------ +%feature("docstring") cmf_core::SoilLayer::Solute "def Solute(self, +args) -z_weight: :math:`w_z` the weight of height difference between cell and -station "; +Solute(WaterStorage self, solute _Solute) -> SoluteStorage +Solute(WaterStorage self, solute _Solute) -> SoluteStorage const +SoluteStorage& Solute(const cmf::water::solute _Solute) const "; -%feature("docstring") cmf::project::use_nearest_rainfall "void -use_nearest_rainfall(double z_weight=0) +%feature("docstring") cmf_core::SoilLayer::to_string "def +to_string(self, args, kwargs) -Connects all cells of the project with its nearest rainfall station. +to_string(StateVariable self) -> std::string virtual std::string +to_string() const =0 "; -Distance is calculated as follows: +%feature("docstring") cmf_core::SoilLayer::to_string "def +to_string(self, args, kwargs) -.. math:: +to_string(flux_node self) -> std::string virtual std::string +to_string() const "; - d_i(x,y,z) = w_z - \\\\left|z-z_i\\\\right| + \\\\sqrt{\\\\left(x-x_i\\\\right)^2 + - \\\\left(y-y_i\\\\right)^2} +%feature("docstring") cmf_core::SoilLayer::waterbalance "def +waterbalance(self, args, kwargs) -:math:`d_i` is the distance from x,y,z to -station i +waterbalance(flux_node self, Time t, flux_connection Without=None) -> +real real waterbalance(cmf::math::Time t, const flux_connection +*Without=0) const Returns the sum of all fluxes (positive and +negative) at time t. Single fluxes can be excluded from the +calculation Parameters: ----------- t: Time of the query Without: +A flux_connection that is excluded from the waterbalance (e.g. to +prevent closed circuits) "; -:math:`p` the power of the weighting function, usually 2. -:math:`x_i,y_i,z_i` is the position of station i in space +// File: classcmf_1_1upslope_1_1_soil_layer.xml +%feature("docstring") cmf::upslope::SoilLayer " -:math:`w_z` is a factor to weight the vertical distance between stations and -the cell. 0 results in a pure horizontal interpolation (normal IDW). -If :math:`w_z=1`, height difference is as important as horizontal distance, -and with :math:`w_z>1` the height difference is weighted more important than -horizontal distance +A representation of a SoilLayer. -Parameters: ------------ +C++ includes: SoilLayer.h "; -z_weight: :math:`w_z` the weight of height difference between cell and -station "; +/* Overrides of flux_node */ +%feature("docstring") cmf::upslope::SoilLayer::RecalcFluxes "virtual +bool RecalcFluxes(cmf::math::Time t) -// File: classcmf_1_1geometry_1_1qtree_1_1_quadtree.xml -%feature("docstring") cmf::geometry::qtree::Quadtree " +Pure flux_nodes do not influence fluxes, therefore no recalculation of +fluxes is required by flux_node. -A simple quad tree to check if the boundaries of geometries overlap or -not "; +WaterStorage overrides this, since state changes require an update of +the fluxes "; -%feature("docstring") cmf::geometry::qtree::Quadtree::__init__ "def -__init__(self, area, divisions=50) +%feature("docstring") cmf::upslope::SoilLayer::is_empty "virtual +double is_empty() const -:param area: The total area of the study area in m2 :param divisions: -The number of divisions of the area, default is 20 "; +Returns true if the node has no water. "; -%feature("docstring") cmf::geometry::qtree::Quadtree::__call__ "def -__call__(self, bounds) +%feature("docstring") cmf::upslope::SoilLayer::to_string "virtual +std::string to_string() const "; -Get all objects in the given boundaries :param bounds: The boundary -rectangle of the tree. A 4 item sequence (xmin, ymin, xmax, ymax) -:return: "; +%feature("docstring") cmf::upslope::SoilLayer::add_connected_states "virtual void add_connected_states(cmf::math::StateVariable::list +&states) "; -%feature("docstring") cmf::geometry::qtree::Quadtree::append "def -append(self, obj, bounds) +%feature("docstring") cmf::upslope::SoilLayer::conc "real conc(const +cmf::water::solute &_Solute) const -Appends an object to the qtree using the given bounds. :param obj: An -object to append to the tree, must be hashable :param bounds: The -boundary rectangle of the object. A 4 item sequence (xmin, ymin, xmax, -ymax) "; +Returns the concentration of the given solute. "; -%feature("docstring") cmf::geometry::qtree::Quadtree::extend "def -extend(self, objects_with_boundaries) +%feature("docstring") cmf::upslope::SoilLayer::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) const -Extends the Quadtree with objects :param objects_with_boundaries: an -iterable of (object, bounds) tuples :return: "; +Returns the current WaterQuality (concentration of all solutes) "; -%feature("docstring") cmf::geometry::qtree::Quadtree::iterbounds "def iterbounds(self, bounds) +%feature("docstring") cmf::upslope::SoilLayer::conc "void conc(const +cmf::water::solute &_Solute, real NewConcetration) -Iterates through all positions in the boundaries :param bounds: The -boundary rectangle. A 4 item sequence (xmin, ymin, xmax, ymax) -:return: (i,j) position tuple "; +Sets a new concentration. "; +%feature("docstring") cmf::upslope::SoilLayer::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) -// File: classcmf_1_1upslope_1_1connections_1_1_rainfall.xml -%feature("docstring") cmf::upslope::connections::Rainfall " +Returns the connection between this and target. "; -A connection routing rainfall to surface water and to an eventually -existing canopy storage. +%feature("docstring") cmf::upslope::SoilLayer::dxdt "virtual real +dxdt(const cmf::math::Time &time) "; -C++ includes: AtmosphericFluxes.h "; +%feature("docstring") cmf::upslope::SoilLayer::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; -%feature("docstring") cmf::upslope::connections::Rainfall::Rainfall "Rainfall(cmf::water::flux_node::ptr target, cmf::upslope::Cell &cell, -bool getthroughfall=true, bool getintercepted=true) +%feature("docstring") cmf::upslope::SoilLayer::flux_to "real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) -Creates a new Rainfall connection. "; +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; -%feature("docstring") cmf::upslope::connections::Rainfall::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) +%feature("docstring") cmf::upslope::SoilLayer::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) -Returns the concentration of the flux. +Returns the sum of all flux vectors. "; -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +%feature("docstring") cmf::upslope::SoilLayer::get_abs_errtol "real +get_abs_errtol(real rel_errtol) const "; -%feature("docstring") -cmf::upslope::connections::Rainfall::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +%feature("docstring") cmf::upslope::SoilLayer::get_capacity "virtual +real get_capacity() const -%feature("docstring") cmf::upslope::connections::Rainfall::get_ptr "ptr get_ptr() const "; +Returns the capacity of the water storage in m3. "; -%feature("docstring") cmf::upslope::connections::Rainfall::get_target -"flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") cmf::upslope::SoilLayer::get_connections "cmf::water::connection_list get_connections() const "; -Returns the other end of a connection than the asking end. "; +%feature("docstring") cmf::upslope::SoilLayer::get_flow_crosssection +"real get_flow_crosssection(const cmf::upslope::SoilLayer &target, +bool HorizontalLayers=false) const -%feature("docstring") cmf::upslope::connections::Rainfall::get_target -"flux_node::ptr get_target(int index) const +Calculates the shared crosssectional area of this and another soil +water storage. -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +If both layers belong to the same cell, the area of the cell is +returned, if they belong to different cells the area of the vertical +shared boundary is returned get_area in m2 -%feature("docstring") -cmf::upslope::connections::Rainfall::get_tracer_filter "real -get_tracer_filter() +Parameters: +----------- -A value ranging from 0 to 1 to filter tracers out of the water flux. +target: The other soil water storage -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +HorizontalLayers: If true, the layers are assumed to be parallel to +the gravitational potential, otherwise they are assumed to be parallel +to the ground topography "; %feature("docstring") -cmf::upslope::connections::Rainfall::get_tracer_filter "real -get_tracer_filter(solute S) - -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +cmf::upslope::SoilLayer::get_gravitational_potential "real +get_gravitational_potential() const -%feature("docstring") cmf::upslope::connections::Rainfall::kill_me "bool kill_me() +Gravitational get_potential in m, reference height is sea level. -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +If the layer is saturated, it returns the saturated depth above sea +level, otherwise it returns the upperboundary of the layer -%feature("docstring") cmf::upslope::connections::Rainfall::left_node -"flux_node::ptr left_node() const +.. math:: -Returns the left node of this connection. "; + + \\\\Psi_G=h -%feature("docstring") cmf::upslope::connections::Rainfall::q "real -q(const flux_node &inquirer, cmf::math::Time t) +"; -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +%feature("docstring") cmf::upslope::SoilLayer::get_ice_fraction "real get_ice_fraction() const -%feature("docstring") cmf::upslope::connections::Rainfall::refresh "void refresh(cmf::math::Time t) +real (Ice_fraction) "; -Performes a new calculation of the flux. "; +%feature("docstring") cmf::upslope::SoilLayer::get_K "real get_K() +const -%feature("docstring") cmf::upslope::connections::Rainfall::right_node -"flux_node::ptr right_node() const +Returns the actual isotropic conductivity using the function from soil +:math:`\\\\frac{m}{day}`. "; -returns the right node of this connection "; +%feature("docstring") cmf::upslope::SoilLayer::get_K "virtual real +get_K(cmf::geometry::point direction) const -%feature("docstring") -cmf::upslope::connections::Rainfall::set_tracer_filter "void -set_tracer_filter(real value) +Returns the actual anisotropic conductivity along a direction :math:`K = (k_f \\\\cdot d) K`. "; -A value ranging from 0 to 1 to filter tracers out of the water flux. +%feature("docstring") cmf::upslope::SoilLayer::get_Ksat "real +get_Ksat() const "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf::upslope::SoilLayer::get_lower "ptr +get_lower() const "; -%feature("docstring") -cmf::upslope::connections::Rainfall::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; +%feature("docstring") cmf::upslope::SoilLayer::get_lower_boundary "virtual real get_lower_boundary() const -%feature("docstring") -cmf::upslope::connections::Rainfall::short_string "virtual -std::string short_string() const "; +Returns the lower boundary of the water storage below ground in m. "; -%feature("docstring") cmf::upslope::connections::Rainfall::to_string -"virtual std::string to_string() const "; +%feature("docstring") cmf::upslope::SoilLayer::get_matrix_potential "virtual real get_matrix_potential() const +Calls RetentionCurve::Matrixpotential. "; -// File: classcmf_1_1atmosphere_1_1_rainfall_station.xml -%feature("docstring") cmf::atmosphere::RainfallStation " +%feature("docstring") cmf::upslope::SoilLayer::get_porosity "real +get_porosity() const -RainfallStation describes a rainfall timeseries in mm/day at a certain -place. +Returns the mean porosity in the layer. "; -Use RainfallStationReference or IDWRainfall to distribute the data -into space +%feature("docstring") cmf::upslope::SoilLayer::get_potential "virtual real get_potential() const -C++ includes: precipitation.h "; +Returns the total potential in m -%feature("docstring") -cmf::atmosphere::RainfallStation::RainfallStation "RainfallStation(const RainfallStation ©) +.. math:: -copy c'tor "; + \\\\Psi = \\\\Psi_M + \\\\Psi_G + -%feature("docstring") cmf::atmosphere::RainfallStation::tostring "std::string tostring() const +. "; -Returns the name and the mean yearly rainfall. "; +%feature("docstring") cmf::upslope::SoilLayer::get_project "cmf::project& get_project() const -%feature("docstring") cmf::atmosphere::RainfallStation::use_for_cell -"void use_for_cell(cmf::upslope::Cell &c) +Returns the project, this node is part of. "; -Connects a cell with this rainfall station. "; +%feature("docstring") cmf::upslope::SoilLayer::get_rootfraction "real get_rootfraction() const +Returns the root fraction of the layer. If it is not explicitly set, +it uses the parameters of the vegetation object of the cell. "; -// File: classcmf_1_1atmosphere_1_1_rainfall_station_list.xml -%feature("docstring") cmf::atmosphere::RainfallStationList " +%feature("docstring") cmf::upslope::SoilLayer::get_saturated_depth "virtual real get_saturated_depth() const -A list of rainfall stations. +Returns the depth for saturation -C++ includes: precipitation.h "; +.. math:: -%feature("docstring") cmf::atmosphere::RainfallStationList::add "RainfallStation::ptr add(std::string Name, cmf::math::timeseries Data, -cmf::geometry::point Position) + z_{sat,this} = + \\\\left\\\\{z_{cell}-\\\\Psi_{tot} \\\\mbox{ if } W<1 \\\\\\\\ + z_{sat,upper layer} \\\\right. -Creates a new RainfallStation and adds it to the list. +. "; -Usage: The position of the rainfall station will be used as identifier -A new rainfall station +%feature("docstring") cmf::upslope::SoilLayer::get_soil "virtual +cmf::upslope::RetentionCurve& get_soil() const -Parameters: ------------ +Returns the soil properties of the water storage. "; -Name: Name of the station +%feature("docstring") cmf::upslope::SoilLayer::get_state "real +get_state() const "; -Data: Rainfall timeseries +%feature("docstring") +cmf::upslope::SoilLayer::get_state_variable_content "char +get_state_variable_content() const -Position: Spatial position of the new station "; +A character indicating the integrated variable (either 'V' for Volume +or 'h' for head) "; -%feature("docstring") cmf::atmosphere::RainfallStationList::remove "void remove(ptrdiff_t index) +%feature("docstring") cmf::upslope::SoilLayer::get_states "cmf::math::StateVariableList get_states() -Removes the station at index from this list. "; +Add the state variables, owned by an object derived from +StateVariableOwner, to the given vector. "; -%feature("docstring") cmf::atmosphere::RainfallStationList::size "size_t size() const +%feature("docstring") cmf::upslope::SoilLayer::get_theta "virtual +real get_theta() const -Returns the number of rainfall stations. "; +Returns the actual volumetric water content of the water storage. "; +%feature("docstring") cmf::upslope::SoilLayer::get_thickness "real +get_thickness() const "; -// File: classcmf_1_1atmosphere_1_1_rainfall_station_reference.xml -%feature("docstring") cmf::atmosphere::RainfallStationReference " +%feature("docstring") cmf::upslope::SoilLayer::get_upper "ptr +get_upper() const "; -References a single RainfallStation to provide rainfall intensity -data. +%feature("docstring") cmf::upslope::SoilLayer::get_upper_boundary "virtual real get_upper_boundary() const -C++ includes: precipitation.h "; +Returns the upper boundary of the water storage below ground in m. "; -%feature("docstring") cmf::atmosphere::RainfallStationReference::conc -"real conc(cmf::math::Time t, const cmf::water::solute &Solute) const +%feature("docstring") cmf::upslope::SoilLayer::get_volume "virtual +real get_volume() const -Returns the concentration of a solute in [solute unit]/m3 at time t in -rainfall. "; +Returns the volume of water in this storage in m3 "; -%feature("docstring") -cmf::atmosphere::RainfallStationReference::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node -&target) +%feature("docstring") cmf::upslope::SoilLayer::get_wetness "virtual +real get_wetness() const -Returns the connection between this and target. "; +Returns the wetness of the soil :math:`\\\\frac{V_{H_2O}}{V_{pores}}`. "; -%feature("docstring") -cmf::atmosphere::RainfallStationReference::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, -cmf::math::Time t) "; +%feature("docstring") cmf::upslope::SoilLayer::is_connected "virtual +bool is_connected(const cmf::math::StateVariable &other) const -%feature("docstring") -cmf::atmosphere::RainfallStationReference::flux_to "real -flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +Returns True if this waterstorage is effected by another state. "; -Returns the actual flux between this and target (positive sign means -\"from this into target\") "; +%feature("docstring") cmf::upslope::SoilLayer::is_storage "virtual +bool is_storage() const -%feature("docstring") -cmf::atmosphere::RainfallStationReference::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) +Returns true, since this is a storage. "; -Returns the sum of all flux vectors. "; +%feature("docstring") cmf::upslope::SoilLayer::remove_connection "bool remove_connection(cmf::water::flux_node::ptr To) -%feature("docstring") -cmf::atmosphere::RainfallStationReference::get_connections "cmf::water::connection_list get_connections() const "; +Remove the connection. "; -%feature("docstring") -cmf::atmosphere::RainfallStationReference::get_intensity "real -get_intensity(cmf::math::Time t) const +%feature("docstring") cmf::upslope::SoilLayer::set_ice_fraction "void set_ice_fraction(real val) -Returns the rainfall intensity in mm/day at time t. "; +Parameters: +----------- -%feature("docstring") -cmf::atmosphere::RainfallStationReference::get_potential "virtual -real get_potential() const +val: Ice_fraction (real) "; -Returns the water potential of the node in m waterhead. +%feature("docstring") cmf::upslope::SoilLayer::set_potential "virtual void set_potential(real waterhead) -The base class water storage always returns the height of the location -"; +Sets the potential of this soil water storage. "; -%feature("docstring") -cmf::atmosphere::RainfallStationReference::get_project "cmf::project& -get_project() const +%feature("docstring") cmf::upslope::SoilLayer::set_rootfraction "void set_rootfraction(real rootfraction) -Returns the project, this node is part of. "; +Sets the root fraction in this layer explicitly. "; -%feature("docstring") -cmf::atmosphere::RainfallStationReference::is_empty "virtual double -is_empty() const +%feature("docstring") cmf::upslope::SoilLayer::set_soil "virtual +void set_soil(const cmf::upslope::RetentionCurve &r_curve) "; -Returns false. "; +%feature("docstring") cmf::upslope::SoilLayer::set_state "void +set_state(real newState) "; %feature("docstring") -cmf::atmosphere::RainfallStationReference::is_storage "virtual bool -is_storage() const - -true, if this is a waterstorage "; +cmf::upslope::SoilLayer::set_state_variable_content "void +set_state_variable_content(char content) -%feature("docstring") -cmf::atmosphere::RainfallStationReference::RecalcFluxes "virtual bool -RecalcFluxes(cmf::math::Time t) +A character indicating the integrated variable (either 'V' for Volume +or 'h' for head) "; -Pure flux_nodes do not influence fluxes, therefore no recalculation of -fluxes is required by flux_node. +%feature("docstring") cmf::upslope::SoilLayer::set_theta "virtual +void set_theta(real Value) "; -WaterStorage overrides this, since state changes require an update of -the fluxes "; +%feature("docstring") cmf::upslope::SoilLayer::set_volume "virtual +void set_volume(real newwatercontent) -%feature("docstring") -cmf::atmosphere::RainfallStationReference::remove_connection "bool -remove_connection(cmf::water::flux_node::ptr To) +Sets the volume of water in this storage in m3 "; -Remove the connection. "; +%feature("docstring") cmf::upslope::SoilLayer::set_wetness "virtual +void set_wetness(real wetness) "; -%feature("docstring") -cmf::atmosphere::RainfallStationReference::set_potential "virtual -void set_potential(real new_potential) +%feature("docstring") cmf::upslope::SoilLayer::Solute "SoluteStorage& Solute(const cmf::water::solute _Solute) -Sets the potential of this flux node. "; +Returns the water quality of the water storage. "; -%feature("docstring") -cmf::atmosphere::RainfallStationReference::to_string "virtual -std::string to_string() const "; +%feature("docstring") cmf::upslope::SoilLayer::Solute "const +SoluteStorage& Solute(const cmf::water::solute _Solute) const "; -%feature("docstring") -cmf::atmosphere::RainfallStationReference::waterbalance "real +%feature("docstring") cmf::upslope::SoilLayer::waterbalance "real waterbalance(cmf::math::Time t, const flux_connection *Without=0) const @@ -11757,659 +29650,795 @@ Without: A flux_connection that is excluded from the waterbalance (e.g. to prevent closed circuits) "; -// File: classcmf_1_1atmosphere_1_1_rain_source.xml -%feature("docstring") cmf::atmosphere::RainSource " +// File: classcmf__core_1_1solute.xml +%feature("docstring") cmf_core::solute " -An abstract class for different types of rainfall sources. +A structure to identify a solute. C++ includes: Solute.h "; -C++ includes: precipitation.h "; +%feature("docstring") cmf_core::solute::__init__ "def __init__(self, +args, kwargs) -%feature("docstring") cmf::atmosphere::RainSource::conc "virtual -real conc(cmf::math::Time t, const cmf::water::solute &Solute) const -=0 +__init__(cmf::water::solute self, solute copy) -> solute solute(const +solute ©) "; -Returns the concentration of a solute in the rainfall at time t. "; +%feature("docstring") cmf_core::solute::__eq__ "def __eq__(self, +args, kwargs) -%feature("docstring") cmf::atmosphere::RainSource::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node -&target) +__eq__(solute self, solute cmp) -> bool "; + +%feature("docstring") cmf_core::solute::__ge__ "def __ge__(self, +args, kwargs) + +__ge__(solute self, solute cmp) -> bool "; + +%feature("docstring") cmf_core::solute::__gt__ "def __gt__(self, +args, kwargs) + +__gt__(solute self, solute cmp) -> bool "; + +%feature("docstring") cmf_core::solute::__le__ "def __le__(self, +args, kwargs) + +__le__(solute self, solute cmp) -> bool "; + +%feature("docstring") cmf_core::solute::__lt__ "def __lt__(self, +args, kwargs) + +__lt__(solute self, solute cmp) -> bool "; -Returns the connection between this and target. "; +%feature("docstring") cmf_core::solute::__ne__ "def __ne__(self, +args, kwargs) -%feature("docstring") cmf::atmosphere::RainSource::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, -cmf::math::Time t) "; +__ne__(solute self, solute cmp) -> bool "; -%feature("docstring") cmf::atmosphere::RainSource::flux_to "real -flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +%feature("docstring") cmf_core::solute::__repr__ "def __repr__(self, +args, kwargs) -Returns the actual flux between this and target (positive sign means -\"from this into target\") "; +__repr__(solute self) -> std::string "; -%feature("docstring") cmf::atmosphere::RainSource::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) -Returns the sum of all flux vectors. "; +// File: structcmf_1_1water_1_1solute.xml +%feature("docstring") cmf::water::solute " -%feature("docstring") cmf::atmosphere::RainSource::get_connections "cmf::water::connection_list get_connections() const "; +A structure to identify a solute. -%feature("docstring") cmf::atmosphere::RainSource::get_intensity "virtual real get_intensity(cmf::math::Time t) const =0 +C++ includes: Solute.h "; -Returns the actual rainfall intensity in mm/day. "; +%feature("docstring") cmf::water::solute::solute "solute(const +solute ©) "; -%feature("docstring") cmf::atmosphere::RainSource::get_potential "virtual real get_potential() const -Returns the water potential of the node in m waterhead. +// File: classcmf__core_1_1solute__vector.xml +%feature("docstring") cmf_core::solute_vector " -The base class water storage always returns the height of the location -"; +Manages the solutes of the model. C++ includes: Solute.h "; -%feature("docstring") cmf::atmosphere::RainSource::get_project "cmf::project& get_project() const +%feature("docstring") cmf_core::solute_vector::__init__ "def +__init__(self, args, kwargs) -Returns the project, this node is part of. "; +__init__(cmf::water::solute_vector self, std::string str) -> +solute_vector solute_vector(std::string str) Creates a solute vector +from solute names, separated by whitespace. E.g. solutes= +solute_vector(\"dO18 dH2\") "; -%feature("docstring") cmf::atmosphere::RainSource::is_empty "virtual -double is_empty() const +%feature("docstring") cmf_core::solute_vector::__getitem__ "def +__getitem__(self, args, kwargs) -Returns false. "; +__getitem__(solute_vector self, int i) -> solute "; -%feature("docstring") cmf::atmosphere::RainSource::is_storage "virtual bool is_storage() const +%feature("docstring") cmf_core::solute_vector::__iter__ "def +__iter__(self) "; -true, if this is a waterstorage "; +%feature("docstring") cmf_core::solute_vector::__len__ "def +__len__(self, args, kwargs) -%feature("docstring") cmf::atmosphere::RainSource::RecalcFluxes "virtual bool RecalcFluxes(cmf::math::Time t) +__len__(solute_vector self) -> size_t "; -Pure flux_nodes do not influence fluxes, therefore no recalculation of -fluxes is required by flux_node. +%feature("docstring") cmf_core::solute_vector::__repr__ "def +__repr__(self) "; -WaterStorage overrides this, since state changes require an update of -the fluxes "; +%feature("docstring") cmf_core::solute_vector::get_solute "def +get_solute(self, args, kwargs) -%feature("docstring") cmf::atmosphere::RainSource::remove_connection -"bool remove_connection(cmf::water::flux_node::ptr To) +get_solute(solute_vector self, int position) -> solute +cmf::water::solute* get_solute(int position) "; -Remove the connection. "; +%feature("docstring") cmf_core::solute_vector::size "def size(self, +args, kwargs) -%feature("docstring") cmf::atmosphere::RainSource::set_potential "virtual void set_potential(real new_potential) +size(solute_vector self) -> size_t size_t size() const "; -Sets the potential of this flux node. "; -%feature("docstring") cmf::atmosphere::RainSource::to_string "virtual std::string to_string() const "; +// File: classcmf_1_1water_1_1solute__vector.xml +%feature("docstring") cmf::water::solute_vector " -%feature("docstring") cmf::atmosphere::RainSource::waterbalance "real waterbalance(cmf::math::Time t, const flux_connection *Without=0) -const +Manages the solutes of the model. -Returns the sum of all fluxes (positive and negative) at time t. +C++ includes: Solute.h "; -Single fluxes can be excluded from the calculation +%feature("docstring") cmf::water::solute_vector::solute_vector "solute_vector(std::string str) -Parameters: ------------ +Creates a solute vector from solute names, separated by whitespace. +E.g. solutes= solute_vector(\"dO18 dH2\") "; -t: Time of the query +%feature("docstring") cmf::water::solute_vector::begin "const_iterator begin() const "; -Without: A flux_connection that is excluded from the waterbalance -(e.g. to prevent closed circuits) "; +%feature("docstring") cmf::water::solute_vector::end "const_iterator +end() const "; +%feature("docstring") cmf::water::solute_vector::get_solute "cmf::water::solute* get_solute(int position) "; -// File: classcmf_1_1river_1_1_reach.xml -%feature("docstring") cmf::river::Reach " +%feature("docstring") cmf::water::solute_vector::size "size_t size() +const "; -A reach represents the section of a riover and is a specialization of -an open water storage. -The OpenWaterStorage attributes and methods are extended by -topological features, for the creation of a network of reaches. +// File: classcmf__core_1_1_solute_storage.xml +%feature("docstring") cmf_core::SoluteStorage " -C++ includes: Reach.h "; +A class for the storage of any tracer. The state is the amount (mol, +kg etc. see cmf::water) of the tracer in the storage. The derivative +function is given by: .. math:: +\\\\\\\\frac{dX}{dt}&=&\\\\\\\\sum_{f=1}^{F}\\\\\\\\left( q_f +[X]_f\\\\\\\\right) + X_{in} - r^-X +\\\\\\\\left[\\\\\\\\frac{mol}{day}\\\\\\\\right]\\\\\\\\\\\\\\\\ F&=& +\\\\\\\\mbox{Number of fluxes in water storage} \\\\\\\\\\\\\\\\ +q_f&=& \\\\\\\\mbox{Water flux in } \\\\\\\\frac{m^3}{day} +\\\\\\\\\\\\\\\\ \\\\\\\\left[X\\\\\\\\right]_f &=& +\\\\\\\\mbox{Concentration of solute X in flux }q_f \\\\\\\\mbox{ +in } \\\\\\\\frac{mol}{m^3} \\\\\\\\\\\\\\\\ X_{in} &=& +\\\\\\\\mbox{Absolute source or sink term} \\\\\\\\frac{mol}{day} +\\\\\\\\\\\\\\\\ r^- &=& \\\\\\\\mbox{Decay rate} \\\\\\\\frac +1{day} \\\\\\\\\\\\\\\\ V &=& \\\\\\\\mbox{Volume of water in +water storage }\\\\\\\\left[m^3\\\\\\\\right] C++ includes: +SoluteStorage.h "; -/* Overrides of flux_node */ +%feature("docstring") cmf_core::SoluteStorage::__init__ "def +__init__(self, args, kwargs) "; -%feature("docstring") cmf::river::Reach::RecalcFluxes "virtual bool -RecalcFluxes(cmf::math::Time t) +%feature("docstring") cmf_core::SoluteStorage::__repr__ "def +__repr__(self) "; -Pure flux_nodes do not influence fluxes, therefore no recalculation of -fluxes is required by flux_node. +%feature("docstring") cmf_core::SoluteStorage::add_connected_states "def add_connected_states(self, args, kwargs) -WaterStorage overrides this, since state changes require an update of -the fluxes "; +add_connected_states(SoluteStorage self, +cmf::math::StateVariable::list & states) virtual void +add_connected_states(cmf::math::StateVariable::list &states) "; -%feature("docstring") cmf::river::Reach::is_empty "virtual double -is_empty() const +%feature("docstring") cmf_core::SoluteStorage::dxdt "def dxdt(self, +args, kwargs) -Returns true if the node has no water. "; +dxdt(StateVariable self, Time time) -> real virtual real dxdt(const +cmf::math::Time &time)=0 Returns the derivate of the state variable +at time time. "; -%feature("docstring") cmf::river::Reach::to_string "virtual -std::string to_string() const "; +%feature("docstring") cmf_core::SoluteStorage::get_abs_errtol "def +get_abs_errtol(self, args, kwargs) -%feature("docstring") cmf::river::Reach::~Reach "virtual ~Reach() "; +get_abs_errtol(StateVariable self, real rel_errtol) -> real virtual +real get_abs_errtol(real rel_errtol) const "; -%feature("docstring") cmf::river::Reach::conc "real -conc(cmf::math::Time t, const cmf::water::solute &solute) const +%feature("docstring") cmf_core::SoluteStorage::get_water "def +get_water(self, args, kwargs) -Returns the water quality of the flux_node, if it is not overridden -this is the mix of the incoming fluxes. "; +get_water(SoluteStorage self) -> WaterStorage const WaterStorage& +get_water() const get the waterstorge of the solute storage "; -%feature("docstring") cmf::river::Reach::conc "real conc(const -cmf::water::solute &_Solute) const +%feature("docstring") cmf_core::SoluteStorage::is_connected "def +is_connected(self, args, kwargs) -Returns the concentration of the given solute. "; +is_connected(StateVariable self, StateVariable other) -> bool virtual +bool is_connected(const cmf::math::StateVariable &other) const "; -%feature("docstring") cmf::river::Reach::conc "void conc(const -cmf::water::solute &_Solute, real NewConcetration) +%feature("docstring") cmf_core::SoluteStorage::set_adsorption "def +set_adsorption(self, args, kwargs) -Sets a new concentration. "; +set_adsorption(SoluteStorage self, Adsorption newadsorption, real +m=-1) void set_adsorption(const Adsorption &newadsorption, real m=-1) +"; -%feature("docstring") cmf::river::Reach::connect_to_surfacewater "void connect_to_surfacewater(cmf::upslope::Cell *cell, real width, -bool diffusive) +%feature("docstring") cmf_core::SoluteStorage::to_string "def +to_string(self, args, kwargs) -Connects the surfacewater of a cell with this reach. +to_string(StateVariable self) -> std::string virtual std::string +to_string() const =0 "; -Parameters: ------------ -cell: The cell with the surface water to be connected with this reach +// File: classcmf_1_1water_1_1_solute_storage.xml +%feature("docstring") cmf::water::SoluteStorage " -width: The flow width from cell to this reach +A class for the storage of any tracer. -diffusive: If diffusive is false, a ManningKinematic connection is -used, else a ManningDiffusive connection "; +The state is the amount (mol, kg etc. see cmf::water) of the tracer in +the storage. -%feature("docstring") cmf::river::Reach::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node -&target) +The derivative function is given by: -Returns the connection between this and target. "; +.. math:: -%feature("docstring") cmf::river::Reach::distance_to_cell "double -distance_to_cell(cmf::upslope::Cell *cell) const + + \\\\frac{dX}{dt}&=&\\\\sum_{f=1}^{F}\\\\left( q_f [X]_f\\\\right) + + X_{in} - r^-X \\\\left[\\\\frac{mol}{day}\\\\right]\\\\\\\\ F&=& + \\\\mbox{Number of fluxes in water storage} \\\\\\\\ q_f&=& + \\\\mbox{Water flux in } \\\\frac{m^3}{day} \\\\\\\\ + \\\\left[X\\\\right]_f &=& \\\\mbox{Concentration of solute X in flux + }q_f \\\\mbox{ in } \\\\frac{mol}{m^3} \\\\\\\\ X_{in} &=& + \\\\mbox{Absolute source or sink term} \\\\frac{mol}{day} \\\\\\\\ r^- + &=& \\\\mbox{Decay rate} \\\\frac 1{day} \\\\\\\\ V &=& + \\\\mbox{Volume of water in water storage }\\\\left[m^3\\\\right] + -Returns the distance (d) for connections between this reach and a -cell. -If the effective inner cell distance (defined as :math:`R_{Cell} = 0.5\\\\frac{\\\\sqrt{A}}{\\\\pi}`) is smaller than the distance -between the center points, the cell radius is returned "; -%feature("docstring") cmf::river::Reach::dxdt "virtual real -dxdt(const cmf::math::Time &time) +C++ includes: SoluteStorage.h "; -Returns the derivate of the state variable at time time. "; +%feature("docstring") cmf::water::SoluteStorage::add_connected_states +"virtual void add_connected_states(cmf::math::StateVariable::list +&states) "; -%feature("docstring") cmf::river::Reach::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, -cmf::math::Time t) "; +%feature("docstring") cmf::water::SoluteStorage::dxdt "virtual real +dxdt(const cmf::math::Time &time) "; -%feature("docstring") cmf::river::Reach::flux_to "real flux_to(const -cmf::water::flux_node &target, cmf::math::Time t) +%feature("docstring") cmf::water::SoluteStorage::get_abs_errtol "virtual real get_abs_errtol(real rel_errtol) const "; -Returns the actual flux between this and target (positive sign means -\"from this into target\") "; +%feature("docstring") cmf::water::SoluteStorage::get_conc "real +get_conc() const -%feature("docstring") cmf::river::Reach::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) +Returns the concentration of the solute. "; -Returns the sum of all flux vectors. "; +%feature("docstring") cmf::water::SoluteStorage::get_state "real +get_state() const -%feature("docstring") cmf::river::Reach::get_abs_errtol "real -get_abs_errtol(real rel_errtol) const "; +Returns the current state of the variable. "; -%feature("docstring") cmf::river::Reach::get_connections "cmf::water::connection_list get_connections() const "; +%feature("docstring") cmf::water::SoluteStorage::get_water "const +WaterStorage& get_water() const -%feature("docstring") cmf::river::Reach::get_depth "real get_depth() -const +get the waterstorge of the solute storage "; -Returns the water table depth. "; +%feature("docstring") cmf::water::SoluteStorage::is_connected "virtual bool is_connected(const cmf::math::StateVariable &other) const -%feature("docstring") cmf::river::Reach::get_diffusive "bool -get_diffusive() const +Returns True if this solute storage is effected by another state. "; -Returns if flow is calculated using a diffusive wave model. "; +%feature("docstring") cmf::water::SoluteStorage::set_adsorption "void set_adsorption(const Adsorption &newadsorption, real m=-1) "; -%feature("docstring") cmf::river::Reach::get_downstream "cmf::water::flux_node::ptr get_downstream() const +%feature("docstring") cmf::water::SoluteStorage::set_conc "void +set_conc(real NewConcentration) -Returns the reach downstream of this (or null if there is no reach -downstream) "; +set a new concentration of dissolved tracers. -%feature("docstring") cmf::river::Reach::get_height_function "virtual const IVolumeHeightFunction& get_height_function() const +In case of adsorption functions, the isotherm is used "; -The functional relation between volume, depth and exposed area. "; +%feature("docstring") cmf::water::SoluteStorage::set_state "void +set_state(real newState) -%feature("docstring") cmf::river::Reach::get_length "real -get_length() const +Gives access to the state variable. "; -Returns the length of the reach. "; +%feature("docstring") cmf::water::SoluteStorage::to_string "virtual +std::string to_string() const "; -%feature("docstring") cmf::river::Reach::get_potential "virtual real -get_potential() const -Returns the water potential of the node in m waterhead. +// File: classcmf__core_1_1_solute_timeseries.xml +%feature("docstring") cmf_core::SoluteTimeseries " -The base class water storage always returns the height of the location -"; +A map of concentration time series for solutes. C++ includes: +Solute.h "; -%feature("docstring") cmf::river::Reach::get_project "cmf::project& -get_project() const +%feature("docstring") cmf_core::SoluteTimeseries::__init__ "def +__init__(self, args) -Returns the project, this node is part of. "; +__init__(cmf::water::SoluteTimeseries self) -> SoluteTimeseries +__init__(cmf::water::SoluteTimeseries self, solute_vector solutes, +Time begin, Time step) -> SoluteTimeseries +__init__(cmf::water::SoluteTimeseries self, SoluteTimeseries sts) -> +SoluteTimeseries SoluteTimeseries(const cmf::water::SoluteTimeseries +&sts) "; -%feature("docstring") cmf::river::Reach::get_reachtype "Channel -get_reachtype() const +%feature("docstring") cmf_core::SoluteTimeseries::__getitem__ "def +__getitem__(self, args, kwargs) -Returns the channel shape. "; +__getitem__(SoluteTimeseries self, solute solute) -> timeseries "; -%feature("docstring") cmf::river::Reach::get_root "ptr get_root() +%feature("docstring") cmf_core::SoluteTimeseries::__len__ "def +__len__(self, args, kwargs) -Returns the reach most downstream from this reach. "; +__len__(SoluteTimeseries self) -> size_t "; -%feature("docstring") cmf::river::Reach::get_state "real get_state() -const "; +%feature("docstring") cmf_core::SoluteTimeseries::__setitem__ "def +__setitem__(self, args, kwargs) -%feature("docstring") cmf::river::Reach::get_state_variable_content "char get_state_variable_content() const +__setitem__(SoluteTimeseries self, solute solute, timeseries +concentration) "; -A character indicating the integrated variable (either 'V' for Volume -or 'h' for head) "; +%feature("docstring") cmf_core::SoluteTimeseries::conc "def +conc(self, args, kwargs) -%feature("docstring") cmf::river::Reach::get_states "cmf::math::StateVariableList get_states() +conc(SoluteTimeseries self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) const "; -Add the state variables, owned by an object derived from -StateVariableOwner, to the given vector. "; +%feature("docstring") cmf_core::SoluteTimeseries::size "def +size(self, args, kwargs) -%feature("docstring") cmf::river::Reach::get_upstream "ptr -get_upstream(int index) const +size(SoluteTimeseries self) -> size_t size_t size() const Returns +the number of solutes in the solution. "; -Returns a reach upstream of this. "; -%feature("docstring") cmf::river::Reach::get_volume "virtual real -get_volume() const +// File: classcmf_1_1water_1_1_solute_timeseries.xml +%feature("docstring") cmf::water::SoluteTimeseries " -Returns the volume of water in this storage in m3 "; +A map of concentration time series for solutes. -%feature("docstring") cmf::river::Reach::get_width "real get_width() -const +C++ includes: Solute.h "; -Returns the average width of the reach. "; +%feature("docstring") cmf::water::SoluteTimeseries::SoluteTimeseries +"SoluteTimeseries() "; -%feature("docstring") cmf::river::Reach::is_storage "virtual bool -is_storage() const +%feature("docstring") cmf::water::SoluteTimeseries::SoluteTimeseries +"SoluteTimeseries(const solute_vector &solutes, cmf::math::Time +begin, cmf::math::Time step) "; -Returns true, since this is a storage. "; +%feature("docstring") cmf::water::SoluteTimeseries::SoluteTimeseries +"SoluteTimeseries(const cmf::water::SoluteTimeseries &sts) "; -%feature("docstring") cmf::river::Reach::remove_connection "bool -remove_connection(cmf::water::flux_node::ptr To) +%feature("docstring") cmf::water::SoluteTimeseries::begin "iterator +begin() "; -Remove the connection. "; +%feature("docstring") cmf::water::SoluteTimeseries::begin "const_iterator begin() const "; -%feature("docstring") cmf::river::Reach::set_dead_end "void -set_dead_end() +%feature("docstring") cmf::water::SoluteTimeseries::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) const "; -Deletes any downstream connection. "; +%feature("docstring") cmf::water::SoluteTimeseries::end "iterator +end() "; -%feature("docstring") cmf::river::Reach::set_depth "void -set_depth(real new_depth) "; +%feature("docstring") cmf::water::SoluteTimeseries::end "const_iterator end() const "; -%feature("docstring") cmf::river::Reach::set_diffusive "void -set_diffusive(bool use_diffusive_wave) +%feature("docstring") cmf::water::SoluteTimeseries::size "size_t +size() const -Sets all Manning kind connections to either diffusive or kinematic. "; +Returns the number of solutes in the solution. "; -%feature("docstring") cmf::river::Reach::set_downstream "void -set_downstream(ptr new_downstream, bool use_meanchannel=false) -Connects the reach to another one downstream. "; +// File: classcmf__core_1_1_solute_water_integrator.xml +%feature("docstring") cmf_core::SoluteWaterIntegrator " -%feature("docstring") cmf::river::Reach::set_height_function "virtual void set_height_function(const IVolumeHeightFunction &val) "; +A SoluteWaterIntegrator implements the cmf::math::Integrator +interface, but consists of two independent ODE-solvers. Added +statevariables are sorted by waterstorages and solute storages and +assigned to the correct solver. C++ includes: WaterSoluteIntegrator.h +"; -%feature("docstring") cmf::river::Reach::set_height_function "void -set_height_function(const IChannel &val) +%feature("docstring") cmf_core::SoluteWaterIntegrator::__init__ "def +__init__(self, args) -Sets the channel shape. "; +__init__(cmf::math::SoluteWaterIntegrator self, solute_vector solutes, +Integrator water_integrator, Integrator solute_integrator) -> +SoluteWaterIntegrator __init__(cmf::math::SoluteWaterIntegrator self, +solute_vector solutes, Integrator water_integrator, Integrator +solute_integrator, StateVariableOwner states) -> SoluteWaterIntegrator +SoluteWaterIntegrator(cmf::water::solute_vector solutes, const +cmf::math::Integrator &water_integrator, const cmf::math::Integrator +&solute_integrator, cmf::math::StateVariableOwner &states) Creates a +new SoluteWaterIntegrator. Parameters: ----------- solutes: Solutes +of the project water_integrator: Template for the integrator of +WaterStorage state variables solute_integrator: Template for the +integrator of soluteStorage state variables states: States to be +added to the integrators "; -%feature("docstring") cmf::river::Reach::set_outlet "void -set_outlet(cmf::water::flux_node::ptr outlet) +%feature("docstring") cmf_core::SoluteWaterIntegrator::__call__ "def +__call__(self, t, dt=None, reset=False) -Connects the reach to an outlet, e.g. a boundary condition. "; +Advances the integration until `t` A shortcut to .integrate_until +Parameters ---------- t : cmf.Time The time step to advance to. If +t < current time, the solver will advance to self.t + t dt : +cmf.Time, optional The timestep for the integration. If not given +try to integrate in one step reset : bool, optional If True, the +solver will perform a reset before starting Returns ------- cmf.Time +The new time stamp "; -%feature("docstring") cmf::river::Reach::set_potential "virtual void -set_potential(real newpotential) +%feature("docstring") cmf_core::SoluteWaterIntegrator::__getitem__ "def __getitem__(self, args, kwargs) -Sets the potential of this flux node. "; +__getitem__(Integrator self, long position) -> +cmf::math::StateVariable::ptr "; -%feature("docstring") cmf::river::Reach::set_state "void -set_state(real newState) "; +%feature("docstring") cmf_core::SoluteWaterIntegrator::__len__ "def +__len__(self, args, kwargs) -%feature("docstring") cmf::river::Reach::set_state_variable_content "void set_state_variable_content(char content) +__len__(Integrator self) -> size_t "; -A character indicating the integrated variable (either 'V' for Volume -or 'h' for head) "; +%feature("docstring") cmf_core::SoluteWaterIntegrator::__repr__ "def +__repr__(self) "; -%feature("docstring") cmf::river::Reach::set_volume "virtual void -set_volume(real newwatercontent) +%feature("docstring") +cmf_core::SoluteWaterIntegrator::add_single_state "def +add_single_state(self, args, kwargs) -Sets the volume of water in this storage in m3 "; +add_single_state(Integrator self, cmf::math::StateVariable::ptr state) +virtual void add_single_state(cmf::math::StateVariable::ptr state) +Adds a single state variable to the integrator. "; -%feature("docstring") cmf::river::Reach::Solute "SoluteStorage& -Solute(const cmf::water::solute _Solute) +%feature("docstring") cmf_core::SoluteWaterIntegrator::add_states "def add_states(self, args, kwargs) -Returns the water quality of the water storage. "; +add_states(Integrator self, StateVariableOwner stateOwner) virtual +void add_states(cmf::math::StateVariableOwner &stateOwner) Add state +variables from a StateVariableOwner. "; -%feature("docstring") cmf::river::Reach::Solute "const -SoluteStorage& Solute(const cmf::water::solute _Solute) const "; +%feature("docstring") cmf_core::SoluteWaterIntegrator::copy "def +copy(self, args, kwargs) -%feature("docstring") cmf::river::Reach::upstream_count "int -upstream_count() const +copy(SoluteWaterIntegrator self) -> SoluteWaterIntegrator virtual +cmf::math::SoluteWaterIntegrator* copy() const Polymorphic copy +constructor. "; -Returns the number of reaches upstream of this. "; +%feature("docstring") cmf_core::SoluteWaterIntegrator::get_dt "def +get_dt(self, args, kwargs) -%feature("docstring") cmf::river::Reach::waterbalance "real -waterbalance(cmf::math::Time t, const flux_connection *Without=0) -const +get_dt(Integrator self) -> Time cmf::math::Time get_dt() const +Returns the last time step. "; -Returns the sum of all fluxes (positive and negative) at time t. +%feature("docstring") cmf_core::SoluteWaterIntegrator::get_dxdt "def +get_dxdt(self, args, kwargs) -Single fluxes can be excluded from the calculation +get_dxdt(Integrator self, Time time) -> cmf::math::num_array +cmf::math::num_array get_dxdt(Time time) const "; -Parameters: ------------ +%feature("docstring") cmf_core::SoluteWaterIntegrator::get_state "def get_state(self, args, kwargs) -t: Time of the query +get_state(Integrator self, ptrdiff_t position) -> real real +get_state(ptrdiff_t position) const Returns the statevariable at +position Simplifies the assessment of state variables. "; -Without: A flux_connection that is excluded from the waterbalance -(e.g. to prevent closed circuits) "; +%feature("docstring") cmf_core::SoluteWaterIntegrator::get_states "def get_states(self, args) -%feature("docstring") cmf::river::Reach::wet_area "real wet_area() -const +get_states(Integrator self) -> cmf::math::num_array +get_states(Integrator self) -> StateVariableList StateVariableList +get_states() gets the state variables of the integrator "; -Returns the exposed surface area in m2. "; +%feature("docstring") cmf_core::SoluteWaterIntegrator::get_t "def +get_t(self, args, kwargs) +get_t(Integrator self) -> Time cmf::math::Time get_t() const Returns +the current model time. "; -// File: classcmf_1_1river_1_1_reach_iterator.xml -%feature("docstring") cmf::river::ReachIterator " +%feature("docstring") cmf_core::SoluteWaterIntegrator::integrate "def integrate(self, args, kwargs) -An iterator over every upstream reach from a start reach. +integrate(Integrator self, Time t_max, Time dt) -> int virtual int +integrate(cmf::math::Time t_max, cmf::math::Time dt)=0 Integrates the +vector of state variables. Parameters: ----------- t_max: To stop +the model (if running in a model framework) at time steps of value +exchange e.g. full hours, the next value exchange time can be given +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; -Implements both the Python and the C++ iterator interface Usage C++: -Usage Python: +%feature("docstring") +cmf_core::SoluteWaterIntegrator::integrate_until "def +integrate_until(self, args, kwargs) -C++ includes: Reach.h "; +integrate_until(Integrator self, Time t_max, Time dt, bool +reset=False) void integrate_until(cmf::math::Time t_max, +cmf::math::Time dt=Time(), bool reset=false) Integrates the vector of +state variables until t_max. Parameters: ----------- t_max: Time, +the solver should run to dt: Time step (may be omitted) reset: If +true, solver is reseted before integration starts "; -%feature("docstring") cmf::river::ReachIterator::ReachIterator "ReachIterator(Reach::ptr first) +%feature("docstring") cmf_core::SoluteWaterIntegrator::reset "def +reset(self, args, kwargs) -Creates a ReachIterator from a first reach. "; +reset(Integrator self) virtual void reset() Resets any saved history +(for multistep methods) "; -%feature("docstring") cmf::river::ReachIterator::next "Reach::ptr -next() +%feature("docstring") cmf_core::SoluteWaterIntegrator::run "def +run(self, start=None, end=None, step=day *1, max_errors=0, +reset=False) -Returns the next reach in the upstream queue. "; +Returns an iterator over the timesteps start..end **Examples:** >>> +solver=cmf.CVodeIntegrator(...) >>> for t in solver.run(solver.t, +solver.t + cmf.week, cmf.h): >>> print(t, solver[0].state) or with +list comprehension >>> states = [solver[0].state for t in +solver.run(solver.t, solver.t + cmf.week, cmf.h)] Parameters +---------- start : cmf.Time, optional Start time for the solver +iteration end : cmf.Time, optional End time of the iteration step : +cmf.Time, optional Step size for the integration max_errors: int +Number of tolerated errors. If >0, up to these number of runtime +errors will be saved with their time and the integration proceeds +after a reset of the solver. Some systems operate with values close to +their physical limits and inifinite values in the integration can +easily occur. For these kind of systems set max_errors to eg. 10. A +larger number of errors should be eliminated usually. reset: bool If +True, the solver performs a `reset` at every time step Yields ------ +cmf.Time the actual timestep "; -%feature("docstring") cmf::river::ReachIterator::position "double -position() const +%feature("docstring") cmf_core::SoluteWaterIntegrator::set_state "def set_state(self, args, kwargs) -Returns the distance to the root reach. "; +set_state(Integrator self, ptrdiff_t position, real newState) void +set_state(ptrdiff_t position, real newState) Simplifies the +assessment of state variables. "; -%feature("docstring") cmf::river::ReachIterator::reach "Reach::ptr -reach() const +%feature("docstring") cmf_core::SoluteWaterIntegrator::set_t "def +set_t(self, args, kwargs) -Returns the current reach. "; +set_t(Integrator self, Time val) void set_t(cmf::math::Time val) Sets +the current model time. "; -%feature("docstring") cmf::river::ReachIterator::valid "bool valid() -const +%feature("docstring") cmf_core::SoluteWaterIntegrator::size "def +size(self, args, kwargs) -Returns true, if reaches are left to iterate over. "; +size(Integrator self) -> size_t size_t size() const returns the +number of state variables "; +%feature("docstring") cmf_core::SoluteWaterIntegrator::to_string "def to_string(self, args, kwargs) -// File: classcmf_1_1river_1_1_rectangular_reach.xml -%feature("docstring") cmf::river::RectangularReach " +to_string(SoluteWaterIntegrator self) -> std::string std::string +to_string() const "; -Describes a IChannel with a rectangular crosssection. -C++ includes: ReachType.h "; +// File: classcmf_1_1math_1_1_solute_water_integrator.xml +%feature("docstring") cmf::math::SoluteWaterIntegrator " -%feature("docstring") cmf::river::RectangularReach::RectangularReach -"RectangularReach(double l, double width) +A SoluteWaterIntegrator implements the cmf::math::Integrator +interface, but consists of two independent ODE-solvers. -Creates a new rectangular reach type with width [m]. "; +Added statevariables are sorted by waterstorages and solute storages +and assigned to the correct solver. -%feature("docstring") cmf::river::RectangularReach::RectangularReach -"RectangularReach(const RectangularReach ©) "; +C++ includes: WaterSoluteIntegrator.h "; -%feature("docstring") cmf::river::RectangularReach::~RectangularReach -"virtual ~RectangularReach() "; +/* Accuracy parameters */ -%feature("docstring") cmf::river::RectangularReach::A "virtual -double A(double V) const +/* model time */ -Returns the area of the surface for a given volume. "; +%feature("docstring") cmf::math::SoluteWaterIntegrator::get_t "cmf::math::Time get_t() const -%feature("docstring") cmf::river::RectangularReach::copy "RectangularReach* copy() const "; +Returns the current model time. "; -%feature("docstring") cmf::river::RectangularReach::get_channel_width -"virtual double get_channel_width(double depth) const +%feature("docstring") cmf::math::SoluteWaterIntegrator::set_t "void +set_t(cmf::math::Time val) -Returns the width of the stream at a given depth +Sets the current model time. "; -.. math:: +%feature("docstring") cmf::math::SoluteWaterIntegrator::get_dt "cmf::math::Time get_dt() const - - w &=& const +Returns the last time step. "; -. "; +/* Integrate */ -%feature("docstring") cmf::river::RectangularReach::get_depth "virtual double get_depth(double area) const +%feature("docstring") +cmf::math::SoluteWaterIntegrator::integrate_until "void +integrate_until(cmf::math::Time t_max, cmf::math::Time dt=Time(), bool +reset=false) -Returns the depth at a given crossection area +Integrates the vector of state variables until t_max. -.. math:: +Parameters: +----------- - d - &=& \\\\frac A w +t_max: Time, the solver should run to -. "; +dt: Time step (may be omitted) + +reset: If true, solver is reseted before integration starts "; %feature("docstring") -cmf::river::RectangularReach::get_flux_crossection "virtual double -get_flux_crossection(double depth) const +cmf::math::SoluteWaterIntegrator::SoluteWaterIntegrator "SoluteWaterIntegrator(const cmf::water::solute_vector &solutes, const +cmf::math::Integrator &water_integrator, const cmf::math::Integrator +&solute_integrator) -Returns the crossection area at a given depth +Creates a new SoluteWaterIntegrator. -.. math:: +Parameters: +----------- - A - &=& d w +solutes: Solutes of the project -. "; +water_integrator: Template for the integrator of WaterStorage state +variables -%feature("docstring") cmf::river::RectangularReach::get_length "double get_length() const +solute_integrator: Template for the integrator of soluteStorage state +variables "; -Length of the reach. "; +%feature("docstring") +cmf::math::SoluteWaterIntegrator::SoluteWaterIntegrator "SoluteWaterIntegrator(cmf::water::solute_vector solutes, const +cmf::math::Integrator &water_integrator, const cmf::math::Integrator +&solute_integrator, cmf::math::StateVariableOwner &states) -%feature("docstring") cmf::river::RectangularReach::get_nManning "virtual double get_nManning() const "; +Creates a new SoluteWaterIntegrator. -%feature("docstring") -cmf::river::RectangularReach::get_wetted_perimeter "virtual double -get_wetted_perimeter(double depth) const +Parameters: +----------- -Returns the wetted perimeter at a given depth +solutes: Solutes of the project -.. math:: +water_integrator: Template for the integrator of WaterStorage state +variables - P - &=& 2 d + w +solute_integrator: Template for the integrator of soluteStorage state +variables -. "; +states: States to be added to the integrators "; -%feature("docstring") cmf::river::RectangularReach::h "virtual -double h(double V) const +%feature("docstring") +cmf::math::SoluteWaterIntegrator::~SoluteWaterIntegrator "~SoluteWaterIntegrator() "; -Returns the depth of a given volume. "; +%feature("docstring") +cmf::math::SoluteWaterIntegrator::add_single_state "virtual void +add_single_state(cmf::math::StateVariable::ptr state) -%feature("docstring") cmf::river::RectangularReach::q "virtual -double q(double h, double slope) const "; +Adds a single state variable to the integrator. "; -%feature("docstring") cmf::river::RectangularReach::qManning "virtual double qManning(double A, double slope) const +%feature("docstring") cmf::math::SoluteWaterIntegrator::add_states "void add_states(cmf::math::StateVariableOwner &stateOwner) -Calculates the flow rate from a given water volume in the reach +Add state variables from a StateVariableOwner. "; +%feature("docstring") +cmf::math::SoluteWaterIntegrator::add_values_to_states "void +add_values_to_states(const num_array &operands) -.. math:: +Adds the values in operands to the current states. "; - q_{Manning}&=& A R^{\\\\frac 2 3} - \\\\sqrt{\\\\frac {\\\\Delta_z} n} \\\\\\\\ A &=& \\\\frac V l - \\\\mbox{, (Crosssectional area of the wetted crossection, Volume per - length)} \\\\\\\\ R &=& \\\\frac A {P(d)} \\\\\\\\ P(d) &=& \\\\mbox{ - the perimeter of the wetted crosssection, a function of reach depth} - \\\\\\\\ d(V) &=& \\\\mbox{ the depth of the reach a function of the - volume} \\\\\\\\ \\\\Delta_z &=& \\\\frac{z_{max} - z_{min}}{l} - \\\\mbox{ Slope of the reach} +%feature("docstring") cmf::math::SoluteWaterIntegrator::copy "virtual cmf::math::SoluteWaterIntegrator* copy() const -. +Polymorphic copy constructor. "; -Flow rate [m3/s] +%feature("docstring") cmf::math::SoluteWaterIntegrator::copy_dxdt "void copy_dxdt(Time time, num_array &destination, real factor=1) const + +Copies the derivatives at time step \"time\" to a numeric vector using +use_OpenMP. Parameters: ----------- -A: The area of the cross section [m2] +time: Time at which the derivatives should be calculated -slope: The slope of the reach [m/m] "; +destination: Vector to be overwritten by the results -%feature("docstring") cmf::river::RectangularReach::set_nManning "virtual void set_nManning(double nManning) "; +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; -%feature("docstring") cmf::river::RectangularReach::typecode "char -typecode() const "; +%feature("docstring") cmf::math::SoluteWaterIntegrator::copy_dxdt "void copy_dxdt(Time time, real *destination, real factor=1) const -%feature("docstring") cmf::river::RectangularReach::V "virtual -double V(double h) const "; +Copies the derivatives at time step \"time\" to an preallocated c +array. +Parameters: +----------- -// File: classcmf_1_1upslope_1_1_retention_curve.xml -%feature("docstring") cmf::upslope::RetentionCurve " +time: Time at which the derivatives should be calculated -Abstract base class for different types of retention curves. +destination: Allocated c array -This class, and its children uses wetness instead of volumetric water -content. The wetness of a soil is defined as water content per void -volume +factor: A factor that is multiplied to the derivate (e.g. unit +conversion or integration length) "; -C++ includes: RetentionCurve.h "; +%feature("docstring") cmf::math::SoluteWaterIntegrator::copy_states "void copy_states(num_array &destination) const -%feature("docstring") cmf::upslope::RetentionCurve::~RetentionCurve "virtual ~RetentionCurve() "; +Copies the states to a numeric vector using use_OpenMP. "; -%feature("docstring") cmf::upslope::RetentionCurve::copy "virtual -RetentionCurve* copy() const =0 "; +%feature("docstring") cmf::math::SoluteWaterIntegrator::copy_states "void copy_states(real *destination) const "; -%feature("docstring") cmf::upslope::RetentionCurve::Diffusivity "virtual real Diffusivity(real wetness) const +%feature("docstring") cmf::math::SoluteWaterIntegrator::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; -Returns the Diffusivity of the soil. +%feature("docstring") cmf::math::SoluteWaterIntegrator::get_state "real get_state(ptrdiff_t position) const -Not implemented for all retention curves. Diffusivity is used by -MACROlikeMacroMicroExchange "; +Returns the statevariable at position Simplifies the assessment of +state variables. "; -%feature("docstring") cmf::upslope::RetentionCurve::Diffusivity "cmf::math::num_array Diffusivity(cmf::math::num_array &wetness) "; +%feature("docstring") cmf::math::SoluteWaterIntegrator::get_states "cmf::math::num_array get_states() const "; -%feature("docstring") cmf::upslope::RetentionCurve::dPsiM_dW "virtual real dPsiM_dW(real wetness) const "; +%feature("docstring") cmf::math::SoluteWaterIntegrator::get_states "StateVariableList get_states() -%feature("docstring") cmf::upslope::RetentionCurve::dPsiM_dW "cmf::math::num_array dPsiM_dW(const cmf::math::num_array &wetness) -const "; +gets the state variables of the integrator "; -%feature("docstring") cmf::upslope::RetentionCurve::FillHeight "virtual real FillHeight(real lowerDepth, real Area, real Volume) const +%feature("docstring") cmf::math::SoluteWaterIntegrator::integrate "int integrate(cmf::math::Time t_max, cmf::math::Time dt) -Returns the thickness of a soil column with a certain pore volume. "; +Integrates the vector of state variables. + +Parameters: +----------- + +t_max: To stop the model (if running in a model framework) at time +steps of value exchange e.g. full hours, the next value exchange time +can be given + +dt: Takes the proposed time step, and changes it into the effectively +used time step according to the local stiffness of the problem and +MaxTime "; -%feature("docstring") cmf::upslope::RetentionCurve::K "virtual real -K(real wetness) const +%feature("docstring") cmf::math::SoluteWaterIntegrator::reset "virtual void reset() -Returns the conductivity in m/day at a certain depth and water -content. "; +Resets the integrators (only needed for multistep methods) "; -%feature("docstring") cmf::upslope::RetentionCurve::K "cmf::math::num_array K(const cmf::math::num_array &wetness) const "; +%feature("docstring") cmf::math::SoluteWaterIntegrator::set_state "void set_state(ptrdiff_t position, real newState) -%feature("docstring") cmf::upslope::RetentionCurve::MatricPotential "virtual real MatricPotential(real wetness) const +Simplifies the assessment of state variables. "; -returns the wetness of the soil at given water content "; +%feature("docstring") cmf::math::SoluteWaterIntegrator::set_states "void set_states(const num_array &newStates) -%feature("docstring") cmf::upslope::RetentionCurve::MatricPotential "cmf::math::num_array MatricPotential(const cmf::math::num_array -&wetness) const "; +Copies the new states to the actual states. "; -%feature("docstring") cmf::upslope::RetentionCurve::Porosity "virtual real Porosity(real depth=0.0) const =0 +%feature("docstring") cmf::math::SoluteWaterIntegrator::set_states "void set_states(real *newStates) "; -Returns the porosity at a certain depth. "; +%feature("docstring") cmf::math::SoluteWaterIntegrator::size "size_t +size() const -%feature("docstring") cmf::upslope::RetentionCurve::theta "virtual -real theta(real wetness) const +returns the number of state variables "; -returns the water content :math:`theta` for a given wetness "; +%feature("docstring") cmf::math::SoluteWaterIntegrator::to_string "std::string to_string() const "; -%feature("docstring") cmf::upslope::RetentionCurve::theta "cmf::math::num_array theta(const cmf::math::num_array &wetness) const -"; -%feature("docstring") cmf::upslope::RetentionCurve::VoidVolume "virtual real VoidVolume(real upperDepth, real lowerDepth, real Area) -const +// File: classcmf__core_1_1sparse__structure.xml +%feature("docstring") cmf_core::sparse_structure " -Returns the void volume of a soil column. "; +Proxy of C++ cmf::math::sparse_structure class. "; -%feature("docstring") cmf::upslope::RetentionCurve::Wetness "virtual -real Wetness(real suction) const +%feature("docstring") cmf_core::sparse_structure::__init__ "def +__init__(self, args, kwargs) -returns the wetness (volumetric water content per pore space) at a -given suction pressure "; +__init__(cmf::math::sparse_structure self) -> sparse_structure +sparse_structure() Creates the sparse row compressed structure from +states variable list. "; -%feature("docstring") cmf::upslope::RetentionCurve::Wetness "cmf::math::num_array Wetness(const cmf::math::num_array &suction) -const "; +%feature("docstring") cmf_core::sparse_structure::generate "def +generate(self, args, kwargs) -%feature("docstring") cmf::upslope::RetentionCurve::Wetness_eff "virtual real Wetness_eff(real wetness, real pF_r=4.2) const +generate(sparse_structure self, StateVariableList states) -> size_t +size_t generate(const StateVariableList &states) "; -Returns the effective wetness, using a residual pF value -.. math:: +// File: structcmf_1_1math_1_1sparse__structure.xml +%feature("docstring") cmf::math::sparse_structure ""; - w_{eff} - = - \\\\frac{w_{act}-w\\\\left(pF_r\\\\right)}{1-w\\\\left(pF_r\\\\right)} +%feature("docstring") cmf::math::sparse_structure::sparse_structure "sparse_structure() -. +Creates the sparse row compressed structure from states variable list. "; -%feature("docstring") cmf::upslope::RetentionCurve::Wetness_pF "real -Wetness_pF(real pF) const +%feature("docstring") cmf::math::sparse_structure::generate "size_t +generate(const StateVariableList &states) "; -returns the volumetric water content at a given pF value "; -%feature("docstring") cmf::upslope::RetentionCurve::Wetness_pF "cmf::math::num_array Wetness_pF(const cmf::math::num_array &pF) const -"; +// File: classcmf_1_1water_1_1statecontrol__connection.xml +%feature("docstring") cmf::water::statecontrol_connection " +Calculates a flux to or from a water storage to hold it's state at a +more or less constant level. -// File: classcmf_1_1upslope_1_1connections_1_1_richards.xml -%feature("docstring") cmf::upslope::connections::Richards " -Calculates flow according to the Richards equation. +.. math:: + q=\\\\frac{h_1 - h_{target}}{t_c [days]} -.. math:: +where: :math:`q` the +resulting flux in m3/day - q_{Richards} &=& - \\\\frac{\\\\Delta\\\\Psi_{tot}}{d} K(\\\\theta) A \\\\\\\\ - \\\\Psi_{tot} &= &\\\\Psi_{M}(\\\\theta) + h +:math:`h_1` the reference state - where -:math:`\\\\Delta\\\\Psi_{tot} [m]` is the difference of the total water -potentials of the two soil layers +:math:`h_{target}` the state of the target (right) node -:math:`d [m]` is the distance between the two soil layers +:math:`t_c` the time to reach the target state -:math:`K(\\\\theta)\\\\left[\\\\frac m{day}\\\\right]` is the geometric -mean conductivity (see SoilType::Kunsat) +C++ includes: simple_connections.h "; -:math:`A [m^2]` is the crosssectional area of the flux +%feature("docstring") +cmf::water::statecontrol_connection::statecontrol_connection "statecontrol_connection(cmf::water::WaterStorage::ptr +controlled_storage, cmf::water::flux_node::ptr other_end, real +target_state, cmf::math::Time reaction_time) -:math:`\\\\Psi_M(\\\\theta) [m]` is the matrix potential (see -SoilType::MatrixPotential) +Creates a flux connection to control the state of a storage. -:math:`h [m]` is the height of a soil layer above sea level +Parameters: +----------- -C++ includes: Percolation.h "; +controlled_storage: Water storage, to be controlled -%feature("docstring") cmf::upslope::connections::Richards::Richards "Richards(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr -right) +other_end: source of missing water or target of excessive water -Creates a Richards equation connection between two soil layers (left -and right, rather top and bottom) of the same cell. "; +target_state: State the controlled storage should hold ( +:math:`h_{target}`) -%feature("docstring") cmf::upslope::connections::Richards::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) +reaction_time: Time to reach state ( :math:`t_c`) "; + +%feature("docstring") cmf::water::statecontrol_connection::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns the concentration of the flux. @@ -12417,24 +30446,24 @@ If not overridden, it returns the concentration of the source of the flux (direction depending) "; %feature("docstring") -cmf::upslope::connections::Richards::exchange_target "void +cmf::water::statecontrol_connection::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") cmf::upslope::connections::Richards::get_ptr "ptr get_ptr() const "; +%feature("docstring") cmf::water::statecontrol_connection::get_ptr "ptr get_ptr() const "; -%feature("docstring") cmf::upslope::connections::Richards::get_target +%feature("docstring") cmf::water::statecontrol_connection::get_target "flux_node::ptr get_target(const flux_node &inquirer) Returns the other end of a connection than the asking end. "; -%feature("docstring") cmf::upslope::connections::Richards::get_target +%feature("docstring") cmf::water::statecontrol_connection::get_target "flux_node::ptr get_target(int index) const With index 0, the left node is returned, with index 1 the right node of the connection. "; %feature("docstring") -cmf::upslope::connections::Richards::get_tracer_filter "real +cmf::water::statecontrol_connection::get_tracer_filter "real get_tracer_filter() A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -12443,39 +30472,39 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::connections::Richards::get_tracer_filter "real +cmf::water::statecontrol_connection::get_tracer_filter "real get_tracer_filter(solute S) A value ranging from 0 to 1 to filter tracers out of the water flux. "; -%feature("docstring") cmf::upslope::connections::Richards::kill_me "bool kill_me() +%feature("docstring") cmf::water::statecontrol_connection::kill_me "bool kill_me() Deregisters this connection from its nodes. Returns true if only one reference is left. "; -%feature("docstring") cmf::upslope::connections::Richards::left_node +%feature("docstring") cmf::water::statecontrol_connection::left_node "flux_node::ptr left_node() const Returns the left node of this connection. "; -%feature("docstring") cmf::upslope::connections::Richards::q "real +%feature("docstring") cmf::water::statecontrol_connection::q "real q(const flux_node &inquirer, cmf::math::Time t) Returns the current flux through a connection. Negative signs mean out of the inquirer, positive are inflows to the inquirer. "; -%feature("docstring") cmf::upslope::connections::Richards::refresh "void refresh(cmf::math::Time t) +%feature("docstring") cmf::water::statecontrol_connection::refresh "void refresh(cmf::math::Time t) Performes a new calculation of the flux. "; -%feature("docstring") cmf::upslope::connections::Richards::right_node +%feature("docstring") cmf::water::statecontrol_connection::right_node "flux_node::ptr right_node() const returns the right node of this connection "; %feature("docstring") -cmf::upslope::connections::Richards::set_tracer_filter "void +cmf::water::statecontrol_connection::set_tracer_filter "void set_tracer_filter(real value) A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -12484,1080 +30513,1296 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::connections::Richards::set_tracer_filter "void +cmf::water::statecontrol_connection::set_tracer_filter "void set_tracer_filter(solute S, real value) "; %feature("docstring") -cmf::upslope::connections::Richards::short_string "virtual +cmf::water::statecontrol_connection::short_string "virtual std::string short_string() const "; -%feature("docstring") cmf::upslope::connections::Richards::to_string +%feature("docstring") cmf::water::statecontrol_connection::to_string "virtual std::string to_string() const "; -// File: classcmf_1_1upslope_1_1connections_1_1_richards__lateral.xml -%feature("docstring") cmf::upslope::connections::Richards_lateral " +// File: classcmf__core_1_1statecontrol__connection.xml +%feature("docstring") cmf_core::statecontrol_connection " -Calculates the flux using Richard's equation for adjacent layers +Calculates a flux to or from a water storage to hold it's state at a +more or less constant level. .. math:: q=\\\\\\\\frac{h_1 - +h_{target}}{t_c [days]} where: :math:`q` the resulting flux in +m3/day :math:`h_1` the reference state :math:`h_{target}` the state +of the target (right) node :math:`t_c` the time to reach the target +state C++ includes: simple_connections.h "; + +%feature("docstring") cmf_core::statecontrol_connection::__init__ "def __init__(self, args, kwargs) + +__init__(cmf::water::statecontrol_connection self, +cmf::water::WaterStorage::ptr controlled_storage, +cmf::water::flux_node::ptr other_end, real target_state, Time +reaction_time) -> statecontrol_connection +statecontrol_connection(cmf::water::WaterStorage::ptr +controlled_storage, cmf::water::flux_node::ptr other_end, real +target_state, cmf::math::Time reaction_time) Creates a flux +connection to control the state of a storage. Parameters: ----------- +controlled_storage: Water storage, to be controlled other_end: +source of missing water or target of excessive water target_state: +State the controlled storage should hold ( :math:`h_{target}`) +reaction_time: Time to reach state ( :math:`t_c`) "; -.. math:: +%feature("docstring") cmf_core::statecontrol_connection::__contains__ +"def __contains__(self, cmp) "; - - q_{lat} = \\\\frac{\\\\Psi_1 - \\\\Psi_2}{\\\\|C_1-C_2\\\\|} - K(\\\\theta) A +%feature("docstring") cmf_core::statecontrol_connection::__eq__ "def +__eq__(self, args, kwargs) -where: +__eq__(flux_connection self, flux_connection other) -> bool "; -:math:`q_{lat}` the lateral flow in :math:`m^3/day` +%feature("docstring") cmf_core::statecontrol_connection::__getitem__ +"def __getitem__(self, index) "; -:math:`\\\\Psi_i` the head of node i +%feature("docstring") cmf_core::statecontrol_connection::__iter__ "def __iter__(self) "; -:math:`\\\\|C_1-C_2\\\\|` is the distance from Cell 1 to Cell 2 +%feature("docstring") cmf_core::statecontrol_connection::__repr__ "def __repr__(self) "; -:math:`K(\\\\theta_{1,2}) = \\\\sqrt{K(\\\\theta_1) K(\\\\theta_2)}` +%feature("docstring") cmf_core::statecontrol_connection::conc "def +conc(self, args, kwargs) -:math:`A` the crosssectional area of the interface between storages 1 and 2 +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -C++ includes: subsurfacefluxes.h "; +%feature("docstring") +cmf_core::statecontrol_connection::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::statecontrol_connection::get_target "def get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; %feature("docstring") -cmf::upslope::connections::Richards_lateral::Richards_lateral "Richards_lateral(cmf::upslope::SoilLayer::ptr left, -cmf::water::flux_node::ptr right, real FlowWidth=0, real Distance=0) +cmf_core::statecontrol_connection::get_tracer_filter "def +get_tracer_filter(self, args) -Creates the connection. +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -Parameters: ------------ +%feature("docstring") cmf_core::statecontrol_connection::kill_me "def kill_me(self, args, kwargs) -left: Left node of the connection (needs to be soil water storage) +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -right: Right node of the connection (can be any node) +%feature("docstring") cmf_core::statecontrol_connection::left_node "def left_node(self, args, kwargs) -FlowWidth: the width of the connection - is multiplied by layer -thickness to get the interface area +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -Distance: the length of the connection. If 0, the distance is -calculated from the position of the nodes "; +%feature("docstring") cmf_core::statecontrol_connection::q "def +q(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::Richards_lateral::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; -Returns the concentration of the flux. +%feature("docstring") cmf_core::statecontrol_connection::refresh "def refresh(self, args, kwargs) -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; -%feature("docstring") -cmf::upslope::connections::Richards_lateral::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +%feature("docstring") cmf_core::statecontrol_connection::right_node "def right_node(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::Richards_lateral::get_ptr "ptr get_ptr() -const "; +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; %feature("docstring") -cmf::upslope::connections::Richards_lateral::get_target "flux_node::ptr get_target(const flux_node &inquirer) +cmf_core::statecontrol_connection::set_tracer_filter "def +set_tracer_filter(self, args) -Returns the other end of a connection than the asking end. "; +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; -%feature("docstring") -cmf::upslope::connections::Richards_lateral::get_target "flux_node::ptr get_target(int index) const +%feature("docstring") cmf_core::statecontrol_connection::short_string +"def short_string(self, args, kwargs) -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -%feature("docstring") -cmf::upslope::connections::Richards_lateral::get_tracer_filter "real -get_tracer_filter() +%feature("docstring") cmf_core::statecontrol_connection::to_string "def to_string(self, args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; -%feature("docstring") -cmf::upslope::connections::Richards_lateral::get_tracer_filter "real -get_tracer_filter(solute S) +// File: classcmf__core_1_1_state_variable.xml +%feature("docstring") cmf_core::StateVariable " -A value ranging from 0 to 1 to filter tracers out of the water flux. +Proxy of C++ cmf::math::StateVariable class. "; + +%feature("docstring") cmf_core::StateVariable::__init__ "def +__init__(self, args, kwargs) "; + +%feature("docstring") cmf_core::StateVariable::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::StateVariable::dxdt "def dxdt(self, +args, kwargs) + +dxdt(StateVariable self, Time time) -> real virtual real dxdt(const +cmf::math::Time &time)=0 Returns the derivate of the state variable +at time time. "; + +%feature("docstring") cmf_core::StateVariable::get_abs_errtol "def +get_abs_errtol(self, args, kwargs) + +get_abs_errtol(StateVariable self, real rel_errtol) -> real virtual +real get_abs_errtol(real rel_errtol) const "; + +%feature("docstring") cmf_core::StateVariable::is_connected "def +is_connected(self, args, kwargs) + +is_connected(StateVariable self, StateVariable other) -> bool virtual +bool is_connected(const cmf::math::StateVariable &other) const "; + +%feature("docstring") cmf_core::StateVariable::to_string "def +to_string(self, args, kwargs) + +to_string(StateVariable self) -> std::string virtual std::string +to_string() const =0 "; + + +// File: classcmf_1_1math_1_1_state_variable.xml +%feature("docstring") cmf::math::StateVariable ""; + +%feature("docstring") cmf::math::StateVariable::StateVariable "StateVariable(real InitialState=0, real scale=1) + +ctor "; + +%feature("docstring") cmf::math::StateVariable::~StateVariable "virtual ~StateVariable() "; + +%feature("docstring") cmf::math::StateVariable::add_connected_states +"virtual void add_connected_states(list &states) "; + +%feature("docstring") cmf::math::StateVariable::dxdt "virtual real +dxdt(const cmf::math::Time &time)=0 + +Returns the derivate of the state variable at time time. "; + +%feature("docstring") cmf::math::StateVariable::get_abs_errtol "virtual real get_abs_errtol(real rel_errtol) const "; + +%feature("docstring") cmf::math::StateVariable::get_state "real +get_state() const + +Returns the current state of the variable. "; + +%feature("docstring") cmf::math::StateVariable::is_connected "virtual bool is_connected(const cmf::math::StateVariable &other) const "; -%feature("docstring") -cmf::upslope::connections::Richards_lateral::kill_me "bool kill_me() +%feature("docstring") cmf::math::StateVariable::set_state "void +set_state(real newState) -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +Gives access to the state variable. "; + +%feature("docstring") cmf::math::StateVariable::to_string "virtual +std::string to_string() const =0 "; + + +// File: classcmf__core_1_1_state_variable_list.xml +%feature("docstring") cmf_core::StateVariableList " + +Proxy of C++ cmf::math::StateVariableList class. "; + +%feature("docstring") cmf_core::StateVariableList::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::math::StateVariableList self) -> StateVariableList "; + +%feature("docstring") cmf_core::StateVariableList::__iadd__ "def +__iadd__(self, args) + +__iadd__(StateVariableList self, StateVariableList food) -> +StateVariableList __iadd__(StateVariableList self, StateVariableOwner +svo) -> StateVariableList "; + +%feature("docstring") cmf_core::StateVariableList::__len__ "def +__len__(self, args, kwargs) + +__len__(StateVariableList self) -> size_t "; + +%feature("docstring") cmf_core::StateVariableList::append "def +append(self, args, kwargs) + +append(StateVariableList self, cmf::math::StateVariable::ptr sv) void +append(StateVariable::ptr sv) "; + +%feature("docstring") cmf_core::StateVariableList::extend "def +extend(self, args, kwargs) + +extend(StateVariableList self, StateVariableOwner svo) void +extend(StateVariableOwner &svo) "; + +%feature("docstring") cmf_core::StateVariableList::get_states "def +get_states(self, args, kwargs) + +get_states(StateVariableOwner self) -> StateVariableList virtual +StateVariableList get_states()=0 Add the state variables, owned by an +object derived from StateVariableOwner, to the given vector. "; -%feature("docstring") -cmf::upslope::connections::Richards_lateral::left_node "flux_node::ptr left_node() const +%feature("docstring") cmf_core::StateVariableList::size "def +size(self, args, kwargs) -Returns the left node of this connection. "; +size(StateVariableList self) -> size_t size_t size() const "; -%feature("docstring") cmf::upslope::connections::Richards_lateral::q -"real q(const flux_node &inquirer, cmf::math::Time t) -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +// File: classcmf_1_1math_1_1_state_variable_list.xml +%feature("docstring") cmf::math::StateVariableList ""; %feature("docstring") -cmf::upslope::connections::Richards_lateral::refresh "void -refresh(cmf::math::Time t) +cmf::math::StateVariableList::~StateVariableList "virtual +~StateVariableList() "; -Performes a new calculation of the flux. "; +%feature("docstring") cmf::math::StateVariableList::append "void +append(StateVariable::ptr sv) "; -%feature("docstring") -cmf::upslope::connections::Richards_lateral::right_node "flux_node::ptr right_node() const +%feature("docstring") cmf::math::StateVariableList::begin "state_vector::iterator begin() "; -returns the right node of this connection "; +%feature("docstring") cmf::math::StateVariableList::begin "state_vector::const_iterator begin() const "; -%feature("docstring") -cmf::upslope::connections::Richards_lateral::set_tracer_filter "void -set_tracer_filter(real value) +%feature("docstring") cmf::math::StateVariableList::end "state_vector::iterator end() "; -A value ranging from 0 to 1 to filter tracers out of the water flux. +%feature("docstring") cmf::math::StateVariableList::end "state_vector::const_iterator end() const "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf::math::StateVariableList::extend "void +extend(StateVariableOwner &svo) "; -%feature("docstring") -cmf::upslope::connections::Richards_lateral::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; +%feature("docstring") cmf::math::StateVariableList::get_states "StateVariableList get_states() "; -%feature("docstring") -cmf::upslope::connections::Richards_lateral::short_string "virtual -std::string short_string() const "; +%feature("docstring") cmf::math::StateVariableList::size "size_t +size() const "; -%feature("docstring") -cmf::upslope::connections::Richards_lateral::to_string "virtual -std::string to_string() const "; +// File: classcmf_1_1math_1_1_state_variable_owner.xml +%feature("docstring") cmf::math::StateVariableOwner " -// File: classcmf_1_1math_1_1_r_k_f_integrator.xml -%feature("docstring") cmf::math::RKFIntegrator " +An abstract class, that owns one or more state variables, that can add +them to a vector of state variables in a certain order. -Integrates a vector of cmf::math::StateVariable with the Runge-Kutta- -Fehlberg (RKF54) method. +C++ includes: statevariable.h "; -C++ includes: RKFintegrator.h "; +%feature("docstring") +cmf::math::StateVariableOwner::~StateVariableOwner "virtual +~StateVariableOwner() "; -/* Accuracy parameters */ +%feature("docstring") cmf::math::StateVariableOwner::get_states "virtual StateVariableList get_states()=0 -/* model time */ +Add the state variables, owned by an object derived from +StateVariableOwner, to the given vector. "; -%feature("docstring") cmf::math::RKFIntegrator::get_t "cmf::math::Time get_t() const -Returns the current model time. "; +// File: classcmf__core_1_1_state_variable_owner.xml +%feature("docstring") cmf_core::StateVariableOwner " -%feature("docstring") cmf::math::RKFIntegrator::set_t "void -set_t(cmf::math::Time val) +An abstract class, that owns one or more state variables, that can add +them to a vector of state variables in a certain order. C++ includes: +statevariable.h "; -Sets the current model time. "; +%feature("docstring") cmf_core::StateVariableOwner::__init__ "def +__init__(self, args, kwargs) "; -%feature("docstring") cmf::math::RKFIntegrator::get_dt "cmf::math::Time get_dt() const +%feature("docstring") cmf_core::StateVariableOwner::get_states "def +get_states(self, args, kwargs) -Returns the last time step. "; +get_states(StateVariableOwner self) -> StateVariableList virtual +StateVariableList get_states()=0 Add the state variables, owned by an +object derived from StateVariableOwner, to the given vector. "; -%feature("docstring") cmf::math::RKFIntegrator::reset "virtual void -reset() -Resets any saved history (for multistep methods) "; +// File: classcmf_1_1stopwatch_1_1_stop_watch.xml +%feature("docstring") cmf::stopwatch::StopWatch " -/* Integrate */ +A stopwatch to estimated the total time of a process Creating a +StopWatch: >>>stopwatch=StopWatch(start,stop) Start and end are +indicators to describe the progress of a process. Start is the +indicator value at the beginning of the process. As default they are +0.0 and 1.0. Starting the StopWatch again: >>>stopwatch.start() +Getting the elapsed time, the total time and the remaining time of the +process in seconds: >>>elapsed,total,remaining = stopwatch(progress) +Where progress is a process progress indicator matching start and stop +Example: stopwatch=StopWatch(0,10) for i in range(10): time.sleep(1) +print('elapsed = %0.2fs, total= %0.2fs, remaining = %0.2fs' % +stopwatch(i+1)) "; -%feature("docstring") cmf::math::RKFIntegrator::integrate_until "void integrate_until(cmf::math::Time t_max, cmf::math::Time dt=Time(), -bool reset=false) +%feature("docstring") cmf::stopwatch::StopWatch::__init__ "def +__init__(self, start=0.0, stop=1.0) "; -Integrates the vector of state variables until t_max. +%feature("docstring") cmf::stopwatch::StopWatch::__call__ "def +__call__(self, progress) "; -Parameters: ------------ +%feature("docstring") cmf::stopwatch::StopWatch::start "def +start(self) "; -t_max: Time, the solver should run to -dt: Time step (may be omitted) +// File: classcmf_1_1upslope_1_1_e_t_1_1stressed_e_t.xml +%feature("docstring") cmf::upslope::ET::stressedET " -reset: If true, solver is reseted before integration starts "; +An abstract base class for ET Methods with a WaterStressFunction. -%feature("docstring") cmf::math::RKFIntegrator::RKFIntegrator "RKFIntegrator(StateVariableOwner &states, real epsilon=1e-9, -cmf::math::Time dt_min=cmf::math::timespan(1000)) +C++ includes: ET.h "; -Constructs a new RKFIntegrator from a pointer to a vector of state -variables. +%feature("docstring") cmf::upslope::ET::stressedET::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) -The RKF Integrator becomes the owner of states +Returns the concentration of the flux. -Parameters: ------------ +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; -states: Statevariables of the system +%feature("docstring") cmf::upslope::ET::stressedET::ETpot "virtual +real ETpot(cmf::math::Time t) const "; -epsilon: relative error tolerance per time step (default=1e-9) +%feature("docstring") cmf::upslope::ET::stressedET::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr +newTarget) "; -dt_min: minimum time step (default=1s) "; +%feature("docstring") cmf::upslope::ET::stressedET::get_layer "SoilLayer::ptr get_layer() const "; -%feature("docstring") cmf::math::RKFIntegrator::RKFIntegrator "RKFIntegrator(real epsilon=1e-9, cmf::math::Time -dt_min=cmf::math::timespan(1000)) +%feature("docstring") cmf::upslope::ET::stressedET::get_ptr "ptr +get_ptr() const "; -Constructs a new RKFIntegrator. +%feature("docstring") cmf::upslope::ET::stressedET::get_target "flux_node::ptr get_target(const flux_node &inquirer) -Parameters: ------------ +Returns the other end of a connection than the asking end. "; -epsilon: relative error tolerance per time step (default=1e-9) +%feature("docstring") cmf::upslope::ET::stressedET::get_target "flux_node::ptr get_target(int index) const -dt_min: minimum time step (default=1s) "; +With index 0, the left node is returned, with index 1 the right node +of the connection. "; -%feature("docstring") cmf::math::RKFIntegrator::add_single_state "virtual void add_single_state(cmf::math::StateVariable::ptr state) +%feature("docstring") cmf::upslope::ET::stressedET::get_tracer_filter +"real get_tracer_filter() -Adds a single state variable to the integrator. "; +A value ranging from 0 to 1 to filter tracers out of the water flux. -%feature("docstring") cmf::math::RKFIntegrator::add_states "void -add_states(cmf::math::StateVariableOwner &stateOwner) +1.0 is no filter and 0.0 means no solute is crossing this connection +"; -Adds states from an StateVariableOwner. "; +%feature("docstring") cmf::upslope::ET::stressedET::get_tracer_filter +"real get_tracer_filter(solute S) -%feature("docstring") cmf::math::RKFIntegrator::add_values_to_states -"void add_values_to_states(const num_array &operands) +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; -Adds the values in operands to the current states. "; +%feature("docstring") cmf::upslope::ET::stressedET::kill_me "bool +kill_me() -%feature("docstring") cmf::math::RKFIntegrator::copy "virtual -Integrator* copy() const +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; -Polymorphic copy constructor. "; +%feature("docstring") cmf::upslope::ET::stressedET::left_node "flux_node::ptr left_node() const -%feature("docstring") cmf::math::RKFIntegrator::copy_dxdt "void -copy_dxdt(Time time, num_array &destination, real factor=1) const +Returns the left node of this connection. "; -Copies the derivatives at time step \"time\" to a numeric vector using -use_OpenMP. +%feature("docstring") cmf::upslope::ET::stressedET::q "real q(const +flux_node &inquirer, cmf::math::Time t) -Parameters: ------------ +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; -time: Time at which the derivatives should be calculated +%feature("docstring") cmf::upslope::ET::stressedET::refresh "void +refresh(cmf::math::Time t) -destination: Vector to be overwritten by the results +Performes a new calculation of the flux. "; -factor: A factor that is multiplied to the derivate (e.g. unit -conversion or integration length) "; +%feature("docstring") cmf::upslope::ET::stressedET::right_node "flux_node::ptr right_node() const -%feature("docstring") cmf::math::RKFIntegrator::copy_dxdt "void -copy_dxdt(Time time, real *destination, real factor=1) const +returns the right node of this connection "; -Copies the derivatives at time step \"time\" to an preallocated c -array. +%feature("docstring") +cmf::upslope::ET::stressedET::set_stressfunction "void +set_stressfunction(const RootUptakeStessFunction &stressfunction) -Parameters: ------------ +Sets the stress function to limit water uptake. "; -time: Time at which the derivatives should be calculated +%feature("docstring") cmf::upslope::ET::stressedET::set_tracer_filter +"void set_tracer_filter(real value) -destination: Allocated c array +A value ranging from 0 to 1 to filter tracers out of the water flux. -factor: A factor that is multiplied to the derivate (e.g. unit -conversion or integration length) "; +1.0 is no filter and 0.0 means no solute is crossing this connection +"; -%feature("docstring") cmf::math::RKFIntegrator::copy_states "void -copy_states(num_array &destination) const +%feature("docstring") cmf::upslope::ET::stressedET::set_tracer_filter +"void set_tracer_filter(solute S, real value) "; -Copies the states to a numeric vector using use_OpenMP. "; +%feature("docstring") cmf::upslope::ET::stressedET::short_string "virtual std::string short_string() const "; -%feature("docstring") cmf::math::RKFIntegrator::copy_states "void -copy_states(real *destination) const "; +%feature("docstring") cmf::upslope::ET::stressedET::to_string "std::string to_string() const "; -%feature("docstring") cmf::math::RKFIntegrator::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; -%feature("docstring") cmf::math::RKFIntegrator::get_state "real -get_state(ptrdiff_t position) const +// File: classcmf__core_1_1stressed_e_t.xml +%feature("docstring") cmf_core::stressedET " -Returns the statevariable at position Simplifies the assessment of -state variables. "; +An abstract base class for ET Methods with a WaterStressFunction. C++ +includes: ET.h "; -%feature("docstring") cmf::math::RKFIntegrator::get_states "cmf::math::num_array get_states() const "; +%feature("docstring") cmf_core::stressedET::__init__ "def +__init__(self, args, kwargs) "; -%feature("docstring") cmf::math::RKFIntegrator::get_states "StateVariableList get_states() +%feature("docstring") cmf_core::stressedET::__contains__ "def +__contains__(self, cmp) "; -gets the state variables of the integrator "; +%feature("docstring") cmf_core::stressedET::__eq__ "def __eq__(self, +args, kwargs) -%feature("docstring") cmf::math::RKFIntegrator::integrate "int -integrate(cmf::math::Time MaxTime, cmf::math::Time TimeStep) +__eq__(flux_connection self, flux_connection other) -> bool "; -Integrates the vector of state variables. +%feature("docstring") cmf_core::stressedET::__getitem__ "def +__getitem__(self, index) "; -Parameters: ------------ +%feature("docstring") cmf_core::stressedET::__iter__ "def +__iter__(self) "; -MaxTime: To stop the model (if running in a model framework) at time -steps of value exchange e.g. full hours, the next value exchange time -can be given +%feature("docstring") cmf_core::stressedET::__repr__ "def +__repr__(self) "; -TimeStep: Takes the proposed timestep, and changes it into the -effictivly used timestep according to the local stiffness of the -problem and MaxTime "; +%feature("docstring") cmf_core::stressedET::conc "def conc(self, +args, kwargs) -%feature("docstring") cmf::math::RKFIntegrator::set_state "void -set_state(ptrdiff_t position, real newState) +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -Simplifies the assessment of state variables. "; +%feature("docstring") cmf_core::stressedET::ETpot "def ETpot(self, +args, kwargs) -%feature("docstring") cmf::math::RKFIntegrator::set_states "void -set_states(const num_array &newStates) +ETpot(stressedET self, Time t) -> real virtual real +ETpot(cmf::math::Time t) const "; -Copies the new states to the actual states. "; +%feature("docstring") cmf_core::stressedET::exchange_target "def +exchange_target(self, args, kwargs) -%feature("docstring") cmf::math::RKFIntegrator::set_states "void -set_states(real *newStates) "; +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") cmf::math::RKFIntegrator::size "size_t size() -const +%feature("docstring") cmf_core::stressedET::get_layer "def +get_layer(self, args, kwargs) -returns the number of state variables "; +get_layer(stressedET self) -> cmf::upslope::SoilLayer::ptr +SoilLayer::ptr get_layer() const "; +%feature("docstring") cmf_core::stressedET::get_target "def +get_target(self, args) -// File: classcmf_1_1upslope_1_1_e_t_1_1_root_uptake_stess_function.xml -%feature("docstring") cmf::upslope::ET::RootUptakeStessFunction " +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -An abstract class to calculate the actual transpiration from potential -transpiration. +%feature("docstring") cmf_core::stressedET::get_tracer_filter "def +get_tracer_filter(self, args) -Implementations of WaterStressFunction are used by ET connections -derived from cmf::upslope::ET::stressedET +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -C++ includes: waterstress.h "; +%feature("docstring") cmf_core::stressedET::kill_me "def +kill_me(self, args, kwargs) -%feature("docstring") -cmf::upslope::ET::RootUptakeStessFunction::~RootUptakeStessFunction "virtual ~RootUptakeStessFunction() "; +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -%feature("docstring") cmf::upslope::ET::RootUptakeStessFunction::copy -"virtual cmf::upslope::ET::RootUptakeStessFunction* copy() const =0 +%feature("docstring") cmf_core::stressedET::left_node "def +left_node(self, args, kwargs) -Creates a new copy of this wetness. "; +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -%feature("docstring") cmf::upslope::ET::RootUptakeStessFunction::Tact -"virtual real Tact(const stressedET *connection, real Tpot) const =0 +%feature("docstring") cmf_core::stressedET::q "def q(self, args, +kwargs) -Calculates the water stress for a layer. +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; -Parameters: ------------ +%feature("docstring") cmf_core::stressedET::refresh "def +refresh(self, args, kwargs) -connection: The stressedET connection this stress function belongs to +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; -Tpot: Potential Transpiration in mm/day (for the full profile) +%feature("docstring") cmf_core::stressedET::right_node "def +right_node(self, args, kwargs) -Actual flux from layer in m3/day "; +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; -%feature("docstring") -cmf::upslope::ET::RootUptakeStessFunction::to_string "virtual -std::string to_string() const =0 "; +%feature("docstring") cmf_core::stressedET::set_stressfunction "def +set_stressfunction(self, args, kwargs) +set_stressfunction(stressedET self, RootUptakeStessFunction +stressfunction) void set_stressfunction(const RootUptakeStessFunction +&stressfunction) Sets the stress function to limit water uptake. "; -// File: classcmf_1_1upslope_1_1connections_1_1_rutter_interception.xml -%feature("docstring") cmf::upslope::connections::RutterInterception " +%feature("docstring") cmf_core::stressedET::set_tracer_filter "def +set_tracer_filter(self, args) -Interception storage overflow according to the Rutter and Morton -(1977) model. +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; -Calculates the interception overflow as a storage depending fraction -of incoming rainfall The Rutter model of interception reads as follows -after Meuser, A., 1990. Effects of afforestation on run-off -characteristics. Agric. For. Meteorol. 50: 125-138.: +%feature("docstring") cmf_core::stressedET::short_string "def +short_string(self, args, kwargs) +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -.. math:: +%feature("docstring") cmf_core::stressedET::to_string "def +to_string(self, args, kwargs) - \\\\frac{dI_C(t)}{dt}=P(t)(1-p_F-p_S)-P(t)(1-p_F- - p_S)\\\\frac{I_C(t)}{I_CMAX}-f_I(E-e)(t) +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -With :math:`I_C` the current -canopy storage and :math:`P(t)` the current rainfall. -The second term of the equation denotes the flux from the canopy to -the ground. The implemented formula for canopy storage overflow reads -then as: +// File: classcmf_1_1upslope_1_1subcatchment.xml +%feature("docstring") cmf::upslope::subcatchment " -.. math:: +A class to structure cells in a project using their main outlets. - q_{CO}(t) = - P_{net}(t)\\\\frac{V_{act}[mm]}{V_{max}[mm]} +C++ includes: algorithm.h "; -With: -:math:`q_{CO}(t)[\\\\frac{m^3}{day}]`: The flux from canopy to the ground +%feature("docstring") cmf::upslope::subcatchment::subcatchment "subcatchment(cmf::upslope::Cell &pourpoint, double +area_threshold=1e308) -:math:`P_{net}(t)[\\\\frac{m^3}{day}]`: The flux from the rain to the canopy +Creates a subcatchment from a pourpoint cell. -:math:`V_{act}[mm]=1000 [mm/m] \\\\frac{V_{canopy}[m^3]}{A_{cell} [m^2]}` -The stored water of the canopy in mm +Parameters: +----------- -:math:`V_{max}[mm]=c_{LAI}[mm]\\\\cdot LAI` The capacity of the canopy in -mm, defined by the factor CanopyCapacityPerLAI [mm/LAI], and the leaf -area index LAI. (see: cmf::upslope::vegetation::Vegetation) +pourpoint: The pourpoint (outlet of the subcatchment) -C++ includes: surfacefluxes.h "; +area_threshold: Minimum contributing area size to form a +subcatchment. When area_threshold > area(cells), all upslope cells of +pourpoint are used. "; -%feature("docstring") -cmf::upslope::connections::RutterInterception::RutterInterception "RutterInterception(cmf::water::WaterStorage::ptr Canopy, -cmf::water::flux_node::ptr target, cmf::upslope::Cell &cell) "; -%feature("docstring") -cmf::upslope::connections::RutterInterception::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +// File: classcmf__core_1_1subcatchment.xml +%feature("docstring") cmf_core::subcatchment " -Returns the concentration of the flux. +A class to structure cells in a project using their main outlets. C++ +includes: algorithm.h "; -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +%feature("docstring") cmf_core::subcatchment::__init__ "def +__init__(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::RutterInterception::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +__init__(cmf::upslope::subcatchment self, Cell pourpoint, double +area_threshold=1e308) -> subcatchment subcatchment(cmf::upslope::Cell +&pourpoint, double area_threshold=1e308) Creates a subcatchment from +a pourpoint cell. Parameters: ----------- pourpoint: The pourpoint +(outlet of the subcatchment) area_threshold: Minimum contributing +area size to form a subcatchment. When area_threshold > area(cells), +all upslope cells of pourpoint are used. "; -%feature("docstring") -cmf::upslope::connections::RutterInterception::get_ptr "ptr get_ptr() -const "; -%feature("docstring") -cmf::upslope::connections::RutterInterception::get_target "flux_node::ptr get_target(const flux_node &inquirer) +// File: classcmf__core_1_1_suction_stress.xml +%feature("docstring") cmf_core::SuctionStress " -Returns the other end of a connection than the asking end. "; +The classical suction depending transpiration Stress curve after +Feddes. The ability of roots to take water from the soil up is +limited by the suction pressure (matrix potential) of the soil. The +stress is defined using a trapezoid function, with P0 being the +pressure, where water uptake is prohibited by saturation. Between P0 +and P1 the saturation stress gets lower. Between P1 and P2, no stress +occurs ( ET=ETpot) and with a pressure below P2, water uptake is +limited by drought. P3 indicates the highest suction (lowest pressure) +to which plants can extract water (wilting point). Default values: +:math:`P_0 = \\\\\\\\infty, P_1=\\\\\\\\infty, P_2=-5m, P_3=-160m`, +resulting in no saturation stress and draught stress starting at -5m +and a wilting point of -160m. If one would like to include saturation +stress, typical values for P0 and P1 are 0.0m and 0.1m. By changing P2 +and P3, you can account for different drought sensibility for +different plant types. C++ includes: waterstress.h "; -%feature("docstring") -cmf::upslope::connections::RutterInterception::get_target "flux_node::ptr get_target(int index) const +%feature("docstring") cmf_core::SuctionStress::__init__ "def +__init__(self, args) -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +__init__(cmf::upslope::ET::SuctionStress self, real P0=1e308, real +P1=1e307, real P2=-5, real P3=-160) -> SuctionStress +__init__(cmf::upslope::ET::SuctionStress self, SuctionStress other) -> +SuctionStress SuctionStress(const SuctionStress &other) "; -%feature("docstring") -cmf::upslope::connections::RutterInterception::get_tracer_filter "real get_tracer_filter() +%feature("docstring") cmf_core::SuctionStress::copy "def copy(self, +args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. +copy(SuctionStress self) -> SuctionStress +cmf::upslope::ET::SuctionStress* copy() const Creates a new copy of +this wetness. "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::SuctionStress::Tact "def Tact(self, +args, kwargs) -%feature("docstring") -cmf::upslope::connections::RutterInterception::get_tracer_filter "real get_tracer_filter(solute S) +Tact(RootUptakeStessFunction self, stressedET connection, real Tpot) +-> real virtual real Tact(const stressedET *connection, real Tpot) +const =0 Calculates the water stress for a layer. Parameters: +----------- connection: The stressedET connection this stress +function belongs to Tpot: Potential Transpiration in mm/day (for the +full profile) Actual flux from layer in m3/day "; -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +%feature("docstring") cmf_core::SuctionStress::to_string "def +to_string(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::RutterInterception::kill_me "bool -kill_me() +to_string(RootUptakeStessFunction self) -> std::string virtual +std::string to_string() const =0 "; -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; -%feature("docstring") -cmf::upslope::connections::RutterInterception::left_node "flux_node::ptr left_node() const +// File: classcmf_1_1upslope_1_1_e_t_1_1_suction_stress.xml +%feature("docstring") cmf::upslope::ET::SuctionStress " -Returns the left node of this connection. "; +The classical suction depending transpiration Stress curve after +Feddes. -%feature("docstring") -cmf::upslope::connections::RutterInterception::q "real q(const -flux_node &inquirer, cmf::math::Time t) +The ability of roots to take water from the soil up is limited by the +suction pressure (matrix potential) of the soil. The stress is defined +using a trapezoid function, with P0 being the pressure, where water +uptake is prohibited by saturation. Between P0 and P1 the saturation +stress gets lower. Between P1 and P2, no stress occurs ( ET=ETpot) and +with a pressure below P2, water uptake is limited by drought. P3 +indicates the highest suction (lowest pressure) to which plants can +extract water (wilting point). -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +Default values: :math:`P_0 = \\\\infty, P_1=\\\\infty, P_2=-5m, P_3=-160m`, +resulting in no saturation stress and draught stress starting at -5m +and a wilting point of -160m. -%feature("docstring") -cmf::upslope::connections::RutterInterception::refresh "void -refresh(cmf::math::Time t) +If one would like to include saturation stress, typical values for P0 +and P1 are 0.0m and 0.1m. By changing P2 and P3, you can account for +different drought sensibility for different plant types. -Performes a new calculation of the flux. "; +C++ includes: waterstress.h "; -%feature("docstring") -cmf::upslope::connections::RutterInterception::right_node "flux_node::ptr right_node() const +%feature("docstring") cmf::upslope::ET::SuctionStress::SuctionStress +"SuctionStress(real P0=1e308, real P1=1e307, real P2=-5, real +P3=-160) -returns the right node of this connection "; +Creates a new suction stress function. "; -%feature("docstring") -cmf::upslope::connections::RutterInterception::set_tracer_filter "void set_tracer_filter(real value) +%feature("docstring") cmf::upslope::ET::SuctionStress::SuctionStress +"SuctionStress(const SuctionStress &other) "; -A value ranging from 0 to 1 to filter tracers out of the water flux. +%feature("docstring") cmf::upslope::ET::SuctionStress::~SuctionStress +"virtual ~SuctionStress() "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf::upslope::ET::SuctionStress::copy "cmf::upslope::ET::SuctionStress* copy() const -%feature("docstring") -cmf::upslope::connections::RutterInterception::set_tracer_filter "void set_tracer_filter(solute S, real value) "; +Creates a new copy of this wetness. "; -%feature("docstring") -cmf::upslope::connections::RutterInterception::short_string "virtual -std::string short_string() const "; +%feature("docstring") cmf::upslope::ET::SuctionStress::Tact "real +Tact(const stressedET *connection, real Tpot) const -%feature("docstring") -cmf::upslope::connections::RutterInterception::to_string "virtual -std::string to_string() const "; +Calculates the water stress for a layer. +Parameters: +----------- -// File: classcmf_1_1geos__shapereader_1_1_shapefile.xml -%feature("docstring") cmf::geos_shapereader::Shapefile " +connection: The stressedET connection this stress function belongs to -The shapefile class, create it from a .shp file The shapefile class -implements most of the sequence protocol Usage: -shp=Shapefile('theshapes.shp') # Load the shape file -print(shp[0].shape.area) # Print area of shape -print(shp[0].Name) # Prints the name of the shape, -assuming theshapes.dbf has a field 'Name' "; +Tpot: Potential Transpiration in mm/day (for the full profile) -%feature("docstring") cmf::geos_shapereader::Shapefile::__init__ "def __init__(self, filename, coordinatedigits=12) +Actual flux from layer in m3/day "; -Loads a shapefile from a filename "; +%feature("docstring") cmf::upslope::ET::SuctionStress::to_string "std::string to_string() const "; -%feature("docstring") cmf::geos_shapereader::Shapefile::__getitem__ "def __getitem__(self, index) "; -%feature("docstring") cmf::geos_shapereader::Shapefile::__iter__ "def __iter__(self) "; +// File: classcmf_1_1upslope_1_1_surface_water.xml +%feature("docstring") cmf::upslope::SurfaceWater " -%feature("docstring") cmf::geos_shapereader::Shapefile::__len__ "def -__len__(self) "; +A child class of OpenWaterStorage to model surface water on a cell. -%feature("docstring") cmf::geos_shapereader::Shapefile::readheader "def readheader(self, f) +Specially created to connect a SurfaceWater with other nodes, is the +flux connection cmf::upslope::connections::KinematicSurfaceRunoff -reads the header of a shape file (see ESRI Shapefile Whitepaper -http://www.esri.com/library/whitepapers/pdfs/shapefile.pdf) "; +C++ includes: surfacewater.h "; -%feature("docstring") cmf::geos_shapereader::Shapefile::readrecord "def readrecord(self, f, coordinatedigits) +/* Overrides of flux_node */ -Reads a record from the shapefile see: -http://www.esri.com/library/whitepapers/pdfs/shapefile.pdf "; +%feature("docstring") cmf::upslope::SurfaceWater::RecalcFluxes "virtual bool RecalcFluxes(cmf::math::Time t) -%feature("docstring") cmf::geos_shapereader::Shapefile::shapes "def -shapes(self) +Pure flux_nodes do not influence fluxes, therefore no recalculation of +fluxes is required by flux_node. -Returns a list of shapes "; +WaterStorage overrides this, since state changes require an update of +the fluxes "; +%feature("docstring") cmf::upslope::SurfaceWater::is_empty "virtual +double is_empty() const -// File: classcmf_1_1draw_1_1shapemap_1_1_shape_map.xml -%feature("docstring") cmf::draw::shapemap::ShapeMap " +Returns true if the node has no water. "; -self.fc_function: A callable taking a feature and returning a color -(fillcolor) self.lw_function: A callable taking a feature and -returning a scalar (line width) "; +%feature("docstring") cmf::upslope::SurfaceWater::to_string "virtual +std::string to_string() const "; -%feature("docstring") cmf::draw::shapemap::ShapeMap::__init__ "def -__init__(self, features, kwargs) "; +%feature("docstring") +cmf::upslope::SurfaceWater::add_connected_states "virtual void +add_connected_states(cmf::math::StateVariable::list &states) "; -%feature("docstring") cmf::draw::shapemap::ShapeMap::refresh "def -refresh(self) "; +%feature("docstring") cmf::upslope::SurfaceWater::conc "real +conc(cmf::math::Time t, const cmf::water::solute &solute) const +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; -// File: classcmf_1_1upslope_1_1_e_t_1_1_shuttleworth_wallace.xml -%feature("docstring") cmf::upslope::ET::ShuttleworthWallace " +%feature("docstring") cmf::upslope::SurfaceWater::conc "real +conc(const cmf::water::solute &_Solute) const -Calculates the sum of soil evaporation and transpiration according to -Shuttleworth & Wallace 1985, as implemented in BROOK 90 (Federer 1990) +Returns the concentration of the given solute. "; -The difference to BROOK90 is, that the actual transpiration is not -calculated by plant resitance and potential gradient between plant and -soil, but by an piecewise linear function of the pF value :math:`pF = \\\\log_{10}\\\\left(-\\\\Psi [hPa]\\\\right)`: +%feature("docstring") cmf::upslope::SurfaceWater::conc "void +conc(const cmf::water::solute &_Solute, real NewConcetration) -.. math:: +Sets a new concentration. "; - - \\\\frac{T_{act}}{T_{pot}} = \\\\begin{cases}1 & pF \\\\le 3.35 - \\\\\\\\ \\\\frac{pF - 4.2}{3.35 - 4.2} & pF \\\\in [3.35 .. 4.2] - \\\\\\\\ 0 & pF \\\\ge 4.2\\\\end{cases} +%feature("docstring") cmf::upslope::SurfaceWater::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) -Calculation procedure, as in BROOK 90: +Returns the connection between this and target. "; -Evapotranspiration from the canopy: :math:`\\\\lambda ET_{canopy} = \\\\frac{r_{ac} \\\\Delta\\\\ R_{n,canopy} + c_p\\\\rho D_0}{\\\\Delta \\\\gamma r_{ac} + \\\\gamma r_{sc}}` +%feature("docstring") cmf::upslope::SurfaceWater::dxdt "virtual real +dxdt(const cmf::math::Time &time) "; -Evaporation from the ground: :math:`\\\\lambda E_{ground} = \\\\frac{r_{as} \\\\Delta\\\\ R_{n,ground} + c_p\\\\rho D_0}{\\\\Delta \\\\gamma r_{as} + \\\\gamma r_{ss}}` +%feature("docstring") cmf::upslope::SurfaceWater::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; -In case of a complete surface water covered ground, the surface -resistance :math:`r_{ss}` becomes 0. (GIR) +%feature("docstring") cmf::upslope::SurfaceWater::flux_to "real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) -with :math:`\\\\Delta = \\\\frac{de_s}{dT} = 4098\\\\ 0.6108 \\\\exp\\\\left(\\\\frac{17.27 T}{T+237.3}\\\\right)(T+237.3)^{-2}`, -the slope of the sat. vap. press. T function +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; -:math:`R_{n,ground} = R_n \\\\exp(-C_R LAI)`, the net radiation flux to -the ground +%feature("docstring") cmf::upslope::SurfaceWater::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) -:math:`R_{n,canopy} = R_n - R_{n,ground}`, the net radiation flux to the -canopy +Returns the sum of all flux vectors. "; -:math:`\\\\lambda,c_p\\\\rho,\\\\gamma` latent heat of vaporization, heat -capacity of air, psychrometer constant +%feature("docstring") cmf::upslope::SurfaceWater::get_abs_errtol "real get_abs_errtol(real rel_errtol) const "; -:math:`D_0` vapor pressure deficit at effective source height, see -function D0 +%feature("docstring") cmf::upslope::SurfaceWater::get_cell "Cell& +get_cell() const -:math:`r_{ac}, r_{sc}, r_{as}, r_{ss}` Resistances for the vapor pressure -(see below) +Get the cell of the surface. "; -C++ includes: ShuttleworthWallace.h "; +%feature("docstring") cmf::upslope::SurfaceWater::get_connections "cmf::water::connection_list get_connections() const "; -%feature("docstring") -cmf::upslope::ET::ShuttleworthWallace::ShuttleworthWallace "ShuttleworthWallace(cmf::upslope::Cell &cell, bool allow_dew=true) +%feature("docstring") cmf::upslope::SurfaceWater::get_coverage "double get_coverage() const -Calculates the transpiration and the soil evaporation from dry -surfaces. "; +Get surface coverage as a function of the actual volume. "; -%feature("docstring") -cmf::upslope::ET::ShuttleworthWallace::~ShuttleworthWallace "~ShuttleworthWallace() "; +%feature("docstring") cmf::upslope::SurfaceWater::get_depth "real +get_depth() const -%feature("docstring") -cmf::upslope::ET::ShuttleworthWallace::evap_from_canopy "double -evap_from_canopy(cmf::water::WaterStorage::ptr canopy, cmf::math::Time -t) "; +Returns the water table depth. "; -%feature("docstring") -cmf::upslope::ET::ShuttleworthWallace::evap_from_layer "double -evap_from_layer(cmf::upslope::SoilLayer::ptr sl, cmf::math::Time t) "; +%feature("docstring") cmf::upslope::SurfaceWater::get_height_function +"virtual const cmf::river::Prism& get_height_function() const -%feature("docstring") -cmf::upslope::ET::ShuttleworthWallace::evap_from_snow "double -evap_from_snow(cmf::water::WaterStorage::ptr snow, cmf::math::Time t) +Gets the height function (a cmf::river::Prism) for further reference. "; -%feature("docstring") -cmf::upslope::ET::ShuttleworthWallace::evap_from_surfacewater "double -evap_from_surfacewater(cmf::river::OpenWaterStorage::ptr ows, -cmf::math::Time t) "; - -%feature("docstring") -cmf::upslope::ET::ShuttleworthWallace::get_aerodynamic_resistance "virtual void get_aerodynamic_resistance(double &r_ag, double &r_ac, -cmf::math::Time t) const +%feature("docstring") cmf::upslope::SurfaceWater::get_nManning "real +get_nManning() const -aerodynamic resistance from ground to atmosphere (r_ag) and from -canopy to atmosphere (r_ac) "; +get Manning roughness (n) of the surface -%feature("docstring") cmf::upslope::ET::ShuttleworthWallace::refresh -"void refresh(cmf::math::Time t) +From Python use this as a property: "; -Calculates all the values. "; +%feature("docstring") cmf::upslope::SurfaceWater::get_potential "virtual real get_potential() const -%feature("docstring") cmf::upslope::ET::ShuttleworthWallace::refresh -"void refresh() "; +Returns the water potential of the node in m waterhead. -%feature("docstring") -cmf::upslope::ET::ShuttleworthWallace::transp_from_layer "double -transp_from_layer(cmf::upslope::SoilLayer::ptr sl, cmf::math::Time t) +The base class water storage always returns the height of the location "; +%feature("docstring") cmf::upslope::SurfaceWater::get_project "cmf::project& get_project() const -// File: classcmf_1_1math_1_1root__finding_1_1sign__error.xml -%feature("docstring") cmf::math::root_finding::sign_error ""; +Returns the project, this node is part of. "; -%feature("docstring") cmf::math::root_finding::sign_error::sign_error -"sign_error(std::string msg) "; +%feature("docstring") cmf::upslope::SurfaceWater::get_puddledepth "real get_puddledepth() const +Get water depth at which runoff starts. -// File: classcmf_1_1upslope_1_1connections_1_1_simple_infiltration.xml -%feature("docstring") cmf::upslope::connections::SimpleInfiltration " +From Python use this as a property: "; -Connects the surfacewater and the most upper layer using a simplified -infiltration model suitable for conceptional models. +%feature("docstring") cmf::upslope::SurfaceWater::get_state "real +get_state() const "; +%feature("docstring") +cmf::upslope::SurfaceWater::get_state_variable_content "char +get_state_variable_content() const +A character indicating the integrated variable (either 'V' for Volume +or 'h' for head) "; -.. math:: +%feature("docstring") cmf::upslope::SurfaceWater::get_states "cmf::math::StateVariableList get_states() - q_{inf} = \\\\left(1-e_{sat}\\\\left(W, W_0\\\\right)\\\\right) - q_{inf,pot} +Add the state variables, owned by an object derived from +StateVariableOwner, to the given vector. "; -where: :math:`q_{inf}` Effective infiltration from -surface to first layer (soil) +%feature("docstring") cmf::upslope::SurfaceWater::get_volume "virtual real get_volume() const -:math:`e_{sat}(W, W_0)` Saturation excess, ranging from 0 (nowhere saturated -soil layer) to 1 (fully saturated). :math:`W` is the average wetness -calculated from the soil layer, :math:`W_0` is a parameter denoting the -wetness, where 50% of the layer is saturated using a sigmoidal -function: :math:`e_{sat}(W_{soil}, W_0) = \\\\left(1+e^{-(W-W_0)0.2(1-W_0)}\\\\right)^{-1}` +Returns the volume of water in this storage in m3 "; -:math:`q_{inf,pot}` is the potential infiltration, given by the incoming -fluxes limited by the saturated conductivity: :math:`q_{inf,pot} = \\\\min(q_{in}, K_{sat} A)` :math:`q_{in}` Sum of incoming fluxes to the -surfacewater in :math:`m^3/day` +%feature("docstring") cmf::upslope::SurfaceWater::is_connected "virtual bool is_connected(const cmf::math::StateVariable &other) const -:math:`K_{sat}` Saturated conductivity in :math:`m/day` +Returns True if this waterstorage is effected by another state. "; -:math:`A` Cell area in :math:`m^2` +%feature("docstring") cmf::upslope::SurfaceWater::is_storage "virtual bool is_storage() const -C++ includes: infiltration.h "; +Returns true, since this is a storage. "; -%feature("docstring") -cmf::upslope::connections::SimpleInfiltration::SimpleInfiltration "SimpleInfiltration(cmf::upslope::SoilLayer::ptr soilwater, -cmf::water::flux_node::ptr surfacewater, real W0=0.9) +%feature("docstring") cmf::upslope::SurfaceWater::remove_connection "bool remove_connection(cmf::water::flux_node::ptr To) -Creates the connection between surfacewater and first soil layer. +Remove the connection. "; -Parameters: ------------ +%feature("docstring") cmf::upslope::SurfaceWater::set_depth "void +set_depth(real new_depth) "; -soilwater: the infiltration target +%feature("docstring") cmf::upslope::SurfaceWater::set_height_function +"virtual void set_height_function(const +cmf::river::IVolumeHeightFunction &val) -surfacewater: the infiltration source +Prevents the change of the height function. A SurfaceWater storage has +always a Prism height function. "; -W0: the 50% saturation value "; +%feature("docstring") cmf::upslope::SurfaceWater::set_nManning "void +set_nManning(real n) -%feature("docstring") -cmf::upslope::connections::SimpleInfiltration::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +set Manning roughness (n) of the surface -Returns the concentration of the flux. +From Python use this as a property: "; -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +%feature("docstring") cmf::upslope::SurfaceWater::set_potential "virtual void set_potential(real newpotential) -%feature("docstring") -cmf::upslope::connections::SimpleInfiltration::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +Sets the potential of this flux node. "; -%feature("docstring") -cmf::upslope::connections::SimpleInfiltration::get_ptr "ptr get_ptr() -const "; +%feature("docstring") cmf::upslope::SurfaceWater::set_puddledepth "void set_puddledepth(real puddledepth) -%feature("docstring") -cmf::upslope::connections::SimpleInfiltration::get_target "flux_node::ptr get_target(const flux_node &inquirer) +Set water depth at which runoff starts. -Returns the other end of a connection than the asking end. "; +From Python use this as a property: "; + +%feature("docstring") cmf::upslope::SurfaceWater::set_state "void +set_state(real newState) "; %feature("docstring") -cmf::upslope::connections::SimpleInfiltration::get_target "flux_node::ptr get_target(int index) const +cmf::upslope::SurfaceWater::set_state_variable_content "void +set_state_variable_content(char content) -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +A character indicating the integrated variable (either 'V' for Volume +or 'h' for head) "; -%feature("docstring") -cmf::upslope::connections::SimpleInfiltration::get_tracer_filter "real get_tracer_filter() +%feature("docstring") cmf::upslope::SurfaceWater::set_volume "virtual void set_volume(real newwatercontent) -A value ranging from 0 to 1 to filter tracers out of the water flux. +Sets the volume of water in this storage in m3 "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf::upslope::SurfaceWater::Solute "SoluteStorage& Solute(const cmf::water::solute _Solute) -%feature("docstring") -cmf::upslope::connections::SimpleInfiltration::get_tracer_filter "real get_tracer_filter(solute S) +Returns the water quality of the water storage. "; -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +%feature("docstring") cmf::upslope::SurfaceWater::Solute "const +SoluteStorage& Solute(const cmf::water::solute _Solute) const "; -%feature("docstring") -cmf::upslope::connections::SimpleInfiltration::kill_me "bool -kill_me() +%feature("docstring") cmf::upslope::SurfaceWater::waterbalance "real +waterbalance(cmf::math::Time t, const flux_connection *Without=0) +const -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +Returns the sum of all fluxes (positive and negative) at time t. -%feature("docstring") -cmf::upslope::connections::SimpleInfiltration::left_node "flux_node::ptr left_node() const +Single fluxes can be excluded from the calculation -Returns the left node of this connection. "; +Parameters: +----------- -%feature("docstring") -cmf::upslope::connections::SimpleInfiltration::q "real q(const -flux_node &inquirer, cmf::math::Time t) +t: Time of the query -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +Without: A flux_connection that is excluded from the waterbalance +(e.g. to prevent closed circuits) "; -%feature("docstring") -cmf::upslope::connections::SimpleInfiltration::refresh "void -refresh(cmf::math::Time t) +%feature("docstring") cmf::upslope::SurfaceWater::wet_area "real +wet_area() const -Performes a new calculation of the flux. "; +Returns the exposed surface area in m2. "; -%feature("docstring") -cmf::upslope::connections::SimpleInfiltration::right_node "flux_node::ptr right_node() const -returns the right node of this connection "; +// File: classcmf__core_1_1_surface_water.xml +%feature("docstring") cmf_core::SurfaceWater " -%feature("docstring") -cmf::upslope::connections::SimpleInfiltration::set_tracer_filter "void set_tracer_filter(real value) +A child class of OpenWaterStorage to model surface water on a cell. +Specially created to connect a SurfaceWater with other nodes, is the +flux connection cmf::upslope::connections::KinematicSurfaceRunoff C++ +includes: surfacewater.h "; -A value ranging from 0 to 1 to filter tracers out of the water flux. +%feature("docstring") cmf_core::SurfaceWater::__init__ "def +__init__(self, args, kwargs) "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::SurfaceWater::__call__ "def +__call__(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::SimpleInfiltration::set_tracer_filter "void set_tracer_filter(solute S, real value) "; +__call__(flux_node self, Time t) -> real "; -%feature("docstring") -cmf::upslope::connections::SimpleInfiltration::short_string "virtual -std::string short_string() const "; +%feature("docstring") cmf_core::SurfaceWater::__eq__ "def +__eq__(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::SimpleInfiltration::to_string "virtual -std::string to_string() const "; +__eq__(flux_node self, flux_node other) -> bool "; +%feature("docstring") cmf_core::SurfaceWater::__getitem__ "def +__getitem__(self, args, kwargs) -// File: classcmf_1_1maps_1_1_simple_quad_tree.xml -%feature("docstring") cmf::maps::SimpleQuadTree ""; +__getitem__(WaterStorage self, solute X) -> SoluteStorage "; -%feature("docstring") cmf::maps::SimpleQuadTree::__init__ "def -__init__(self, dx=20, dy=20) "; +%feature("docstring") cmf_core::SurfaceWater::__repr__ "def +__repr__(self) "; -%feature("docstring") cmf::maps::SimpleQuadTree::add_object "def -add_object(self, object, bounds) "; +%feature("docstring") cmf_core::SurfaceWater::cast "def cast(args, +kwargs) -%feature("docstring") cmf::maps::SimpleQuadTree::get_objects "def -get_objects(self, bounds) "; +cast(cmf::water::flux_node::ptr node) -> +cmf::upslope::SurfaceWater::ptr "; +%feature("docstring") cmf_core::SurfaceWater::conc "def conc(self, +args, kwargs) -// File: classcmf_1_1upslope_1_1connections_1_1_simple_tindex_snow_melt.xml -%feature("docstring") cmf::upslope::connections::SimpleTindexSnowMelt -" +conc(flux_node self, Time t, solute Solute) -> real virtual real +conc(cmf::math::Time t, const cmf::water::solute &Solute) const +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; -Calculates snow melt using a simple degree day method. +%feature("docstring") cmf_core::SurfaceWater::conc "def conc(self, +args) +conc(WaterStorage self, solute _Solute) -> real conc(WaterStorage +self, Time t, solute _Solute) -> real conc(WaterStorage self, solute +_Solute, real NewConcetration) void conc(const cmf::water::solute +&_Solute, real NewConcetration) Sets a new concentration. "; +%feature("docstring") cmf_core::SurfaceWater::connected_nodes "def +connected_nodes(self) "; -.. math:: +%feature("docstring") cmf_core::SurfaceWater::connection_to "def +connection_to(self, args, kwargs) - q_{melt} [mm/day] = (T-T_{thres}) * r +connection_to(flux_node self, flux_node target) -> flux_connection +cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) Returns the connection between this and target. "; -Usage: +%feature("docstring") cmf_core::SurfaceWater::create "def +create(args, kwargs) -C++ includes: surfacefluxes.h "; +create(project _project, real initial_state=0.0, real scale=1.0) -> +std::shared_ptr< cmf::water::WaterStorage > "; -%feature("docstring") -cmf::upslope::connections::SimpleTindexSnowMelt::SimpleTindexSnowMelt -"SimpleTindexSnowMelt(cmf::water::WaterStorage::ptr snow, -cmf::water::flux_node::ptr surface_water, cmf::upslope::Cell &cell, -real rate=7.0) +%feature("docstring") cmf_core::SurfaceWater::create "def +create(args) -Creates a new snow melt connection. +create(project _project, real Area) -> +cmf::river::OpenWaterStorage::ptr create(project _project, +IVolumeHeightFunction base_geo) -> cmf::river::OpenWaterStorage::ptr +"; -Parameters: ------------ +%feature("docstring") cmf_core::SurfaceWater::dxdt "def dxdt(self, +args, kwargs) -snow: Snow storage, usually cel.snow +dxdt(StateVariable self, Time time) -> real virtual real dxdt(const +cmf::math::Time &time)=0 Returns the derivate of the state variable +at time time. "; -surface_water: target of the melted water (usually cell.surfacewater) +%feature("docstring") cmf_core::SurfaceWater::flux3d_to "def +flux3d_to(self, args, kwargs) -cell: The cell, needed to get weather and area +flux3d_to(flux_node self, flux_node target, Time t) -> point +cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; -rate: The rate of snow melt, given in mm/(degC day), default = 7.0 "; +%feature("docstring") cmf_core::SurfaceWater::flux_to "def +flux_to(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::SimpleTindexSnowMelt::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +flux_to(flux_node self, flux_node target, Time t) -> real real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; -Returns the concentration of the flux. +%feature("docstring") cmf_core::SurfaceWater::fluxes "def +fluxes(self, t) "; -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +%feature("docstring") cmf_core::SurfaceWater::from_node "def +from_node(args, kwargs) -%feature("docstring") -cmf::upslope::connections::SimpleTindexSnowMelt::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr -newTarget) "; +from_node(cmf::water::flux_node::ptr node) -> std::shared_ptr< +cmf::water::WaterStorage > "; -%feature("docstring") -cmf::upslope::connections::SimpleTindexSnowMelt::get_ptr "ptr -get_ptr() const "; +%feature("docstring") cmf_core::SurfaceWater::get_3d_flux "def +get_3d_flux(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::SimpleTindexSnowMelt::get_target "flux_node::ptr get_target(const flux_node &inquirer) +get_3d_flux(flux_node self, Time t) -> point cmf::geometry::point +get_3d_flux(cmf::math::Time t) Returns the sum of all flux vectors. +"; -Returns the other end of a connection than the asking end. "; +%feature("docstring") cmf_core::SurfaceWater::get_abs_errtol "def +get_abs_errtol(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::SimpleTindexSnowMelt::get_target "flux_node::ptr get_target(int index) const +get_abs_errtol(StateVariable self, real rel_errtol) -> real virtual +real get_abs_errtol(real rel_errtol) const "; -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +%feature("docstring") cmf_core::SurfaceWater::get_cell "def +get_cell(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::SimpleTindexSnowMelt::get_tracer_filter "real get_tracer_filter() +get_cell(SurfaceWater self) -> Cell Cell& get_cell() const Get the +cell of the surface. "; -A value ranging from 0 to 1 to filter tracers out of the water flux. +%feature("docstring") cmf_core::SurfaceWater::get_coverage "def +get_coverage(self, args, kwargs) -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +get_coverage(SurfaceWater self) -> double double get_coverage() const +Get surface coverage as a function of the actual volume. "; -%feature("docstring") -cmf::upslope::connections::SimpleTindexSnowMelt::get_tracer_filter "real get_tracer_filter(solute S) +%feature("docstring") cmf_core::SurfaceWater::get_height_function "def get_height_function(self, args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +get_height_function(SurfaceWater self) -> Prism virtual const +cmf::river::Prism& get_height_function() const Gets the height +function (a cmf::river::Prism) for further reference. "; -%feature("docstring") -cmf::upslope::connections::SimpleTindexSnowMelt::kill_me "bool -kill_me() +%feature("docstring") cmf_core::SurfaceWater::get_states "def +get_states(self, args, kwargs) -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +get_states(StateVariableOwner self) -> StateVariableList virtual +StateVariableList get_states()=0 Add the state variables, owned by an +object derived from StateVariableOwner, to the given vector. "; -%feature("docstring") -cmf::upslope::connections::SimpleTindexSnowMelt::left_node "flux_node::ptr left_node() const +%feature("docstring") cmf_core::SurfaceWater::is_connected "def +is_connected(self, args, kwargs) -Returns the left node of this connection. "; +is_connected(StateVariable self, StateVariable other) -> bool virtual +bool is_connected(const cmf::math::StateVariable &other) const "; -%feature("docstring") -cmf::upslope::connections::SimpleTindexSnowMelt::q "real q(const -flux_node &inquirer, cmf::math::Time t) +%feature("docstring") cmf_core::SurfaceWater::is_empty "def +is_empty(self, args, kwargs) -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +is_empty(flux_node self) -> double virtual double is_empty() const +Returns true if the node has no water. "; -%feature("docstring") -cmf::upslope::connections::SimpleTindexSnowMelt::refresh "void -refresh(cmf::math::Time t) +%feature("docstring") cmf_core::SurfaceWater::is_storage "def +is_storage(self, args, kwargs) -Performes a new calculation of the flux. "; +is_storage(flux_node self) -> bool virtual bool is_storage() const +true, if this is a waterstorage "; -%feature("docstring") -cmf::upslope::connections::SimpleTindexSnowMelt::right_node "flux_node::ptr right_node() const +%feature("docstring") cmf_core::SurfaceWater::RecalcFluxes "def +RecalcFluxes(self, args, kwargs) -returns the right node of this connection "; +RecalcFluxes(flux_node self, Time t) -> bool virtual bool +RecalcFluxes(cmf::math::Time t) Pure flux_nodes do not influence +fluxes, therefore no recalculation of fluxes is required by flux_node. +WaterStorage overrides this, since state changes require an update of +the fluxes "; -%feature("docstring") -cmf::upslope::connections::SimpleTindexSnowMelt::set_tracer_filter "void set_tracer_filter(real value) +%feature("docstring") cmf_core::SurfaceWater::remove_connection "def +remove_connection(self, args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. +remove_connection(flux_node self, cmf::water::flux_node::ptr To) -> +bool bool remove_connection(cmf::water::flux_node::ptr To) Remove +the connection. "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::SurfaceWater::set_height_function "def set_height_function(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::SimpleTindexSnowMelt::set_tracer_filter "void set_tracer_filter(solute S, real value) "; +set_height_function(OpenWaterStorage self, IVolumeHeightFunction val) +virtual void set_height_function(const IVolumeHeightFunction &val) "; -%feature("docstring") -cmf::upslope::connections::SimpleTindexSnowMelt::short_string "virtual std::string short_string() const "; +%feature("docstring") cmf_core::SurfaceWater::Solute "def +Solute(self, args) -%feature("docstring") -cmf::upslope::connections::SimpleTindexSnowMelt::to_string "virtual -std::string to_string() const "; +Solute(WaterStorage self, solute _Solute) -> SoluteStorage +Solute(WaterStorage self, solute _Solute) -> SoluteStorage const +SoluteStorage& Solute(const cmf::water::solute _Solute) const "; +%feature("docstring") cmf_core::SurfaceWater::to_string "def +to_string(self, args, kwargs) -// File: classcmf_1_1upslope_1_1connections_1_1_simpl_richards.xml -%feature("docstring") cmf::upslope::connections::SimplRichards " +to_string(StateVariable self) -> std::string virtual std::string +to_string() const =0 "; -Calculates flow according to a simplified Richards equation. +%feature("docstring") cmf_core::SurfaceWater::to_string "def +to_string(self, args, kwargs) +to_string(flux_node self) -> std::string virtual std::string +to_string() const "; +%feature("docstring") cmf_core::SurfaceWater::waterbalance "def +waterbalance(self, args, kwargs) -.. math:: +waterbalance(flux_node self, Time t, flux_connection Without=None) -> +real real waterbalance(cmf::math::Time t, const flux_connection +*Without=0) const Returns the sum of all fluxes (positive and +negative) at time t. Single fluxes can be excluded from the +calculation Parameters: ----------- t: Time of the query Without: +A flux_connection that is excluded from the waterbalance (e.g. to +prevent closed circuits) "; - q_{Richards} &=& (K(\\\\theta) - K(\\\\theta_r)) - A \\\\\\\\ +%feature("docstring") cmf_core::SurfaceWater::wet_area "def +wet_area(self, args, kwargs) - where :math:`d [m]` is the distance between -the two soil layers +wet_area(OpenWaterStorage self) -> real real wet_area() const Returns +the exposed surface area in m2. "; -:math:`K(\\\\theta)\\\\left[\\\\frac m{day}\\\\right]` is the geometric -mean conductivity (see SoilType::Kunsat) -:math:`A [m^2]` is the crosssectional area of the flux +// File: classcmf__core_1_1_s_w__evap__from__canopy.xml +%feature("docstring") cmf_core::SW_evap_from_canopy " -C++ includes: Percolation.h "; +Connection for Shuttleworth-Wallace canopy interception evaporation. +C++ includes: ShuttleworthWallace.h "; -%feature("docstring") -cmf::upslope::connections::SimplRichards::SimplRichards "SimplRichards(cmf::upslope::SoilLayer::ptr left, -cmf::water::flux_node::ptr right) "; +%feature("docstring") cmf_core::SW_evap_from_canopy::__init__ "def +__init__(self, args, kwargs) -%feature("docstring") cmf::upslope::connections::SimplRichards::conc -"real conc(cmf::math::Time t, const cmf::water::solute &_Solute) +__init__(cmf::upslope::ET::SW_evap_from_canopy self, +cmf::water::WaterStorage::ptr source, cmf::water::flux_node::ptr +ET_target, cmf::upslope::ET::ShuttleworthWallace::ptr owner) -> +SW_evap_from_canopy SW_evap_from_canopy(cmf::water::WaterStorage::ptr +source, cmf::water::flux_node::ptr ET_target, ShuttleworthWallace::ptr +owner) "; -Returns the concentration of the flux. +%feature("docstring") cmf_core::SW_evap_from_canopy::__contains__ "def __contains__(self, cmp) "; -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +%feature("docstring") cmf_core::SW_evap_from_canopy::__eq__ "def +__eq__(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::SimplRichards::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +__eq__(flux_connection self, flux_connection other) -> bool "; -%feature("docstring") -cmf::upslope::connections::SimplRichards::get_ptr "ptr get_ptr() -const "; +%feature("docstring") cmf_core::SW_evap_from_canopy::__getitem__ "def __getitem__(self, index) "; -%feature("docstring") -cmf::upslope::connections::SimplRichards::get_target "flux_node::ptr -get_target(const flux_node &inquirer) +%feature("docstring") cmf_core::SW_evap_from_canopy::__iter__ "def +__iter__(self) "; -Returns the other end of a connection than the asking end. "; +%feature("docstring") cmf_core::SW_evap_from_canopy::__repr__ "def +__repr__(self) "; -%feature("docstring") -cmf::upslope::connections::SimplRichards::get_target "flux_node::ptr -get_target(int index) const +%feature("docstring") cmf_core::SW_evap_from_canopy::conc "def +conc(self, args, kwargs) -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -%feature("docstring") -cmf::upslope::connections::SimplRichards::get_tracer_filter "real -get_tracer_filter() +%feature("docstring") cmf_core::SW_evap_from_canopy::exchange_target +"def exchange_target(self, args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::SW_evap_from_canopy::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; %feature("docstring") -cmf::upslope::connections::SimplRichards::get_tracer_filter "real -get_tracer_filter(solute S) +cmf_core::SW_evap_from_canopy::get_tracer_filter "def +get_tracer_filter(self, args) -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -%feature("docstring") -cmf::upslope::connections::SimplRichards::kill_me "bool kill_me() +%feature("docstring") cmf_core::SW_evap_from_canopy::kill_me "def +kill_me(self, args, kwargs) -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -%feature("docstring") -cmf::upslope::connections::SimplRichards::left_node "flux_node::ptr -left_node() const +%feature("docstring") cmf_core::SW_evap_from_canopy::left_node "def +left_node(self, args, kwargs) -Returns the left node of this connection. "; +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -%feature("docstring") cmf::upslope::connections::SimplRichards::q "real q(const flux_node &inquirer, cmf::math::Time t) +%feature("docstring") cmf_core::SW_evap_from_canopy::q "def q(self, +args, kwargs) -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; -%feature("docstring") -cmf::upslope::connections::SimplRichards::refresh "void -refresh(cmf::math::Time t) +%feature("docstring") cmf_core::SW_evap_from_canopy::refresh "def +refresh(self, args, kwargs) +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) Performes a new calculation of the flux. "; -%feature("docstring") -cmf::upslope::connections::SimplRichards::right_node "flux_node::ptr -right_node() const +%feature("docstring") cmf_core::SW_evap_from_canopy::right_node "def +right_node(self, args, kwargs) -returns the right node of this connection "; +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; %feature("docstring") -cmf::upslope::connections::SimplRichards::set_tracer_filter "void -set_tracer_filter(real value) +cmf_core::SW_evap_from_canopy::set_tracer_filter "def +set_tracer_filter(self, args) -A value ranging from 0 to 1 to filter tracers out of the water flux. +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::SW_evap_from_canopy::short_string "def short_string(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::SimplRichards::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -%feature("docstring") -cmf::upslope::connections::SimplRichards::short_string "virtual -std::string short_string() const "; +%feature("docstring") cmf_core::SW_evap_from_canopy::to_string "def +to_string(self, args, kwargs) -%feature("docstring") -cmf::upslope::connections::SimplRichards::to_string "virtual -std::string to_string() const "; +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -// File: classcmf_1_1upslope_1_1connections_1_1_snowfall.xml -%feature("docstring") cmf::upslope::connections::Snowfall " +// File: classcmf_1_1upslope_1_1_e_t_1_1_s_w__evap__from__canopy.xml +%feature("docstring") cmf::upslope::ET::SW_evap_from_canopy " -A connection routing snowfall (precipitation below freezing Temp) to -the snow pack. +Connection for Shuttleworth-Wallace canopy interception evaporation. -C++ includes: AtmosphericFluxes.h "; +C++ includes: ShuttleworthWallace.h "; -%feature("docstring") cmf::upslope::connections::Snowfall::Snowfall "Snowfall(cmf::water::flux_node::ptr target, cmf::upslope::Cell &cell) +%feature("docstring") +cmf::upslope::ET::SW_evap_from_canopy::SW_evap_from_canopy "SW_evap_from_canopy(cmf::water::WaterStorage::ptr source, +cmf::water::flux_node::ptr ET_target, ShuttleworthWallace::ptr owner) "; -%feature("docstring") cmf::upslope::connections::Snowfall::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) +%feature("docstring") cmf::upslope::ET::SW_evap_from_canopy::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns the concentration of the flux. @@ -13565,24 +31810,27 @@ If not overridden, it returns the concentration of the source of the flux (direction depending) "; %feature("docstring") -cmf::upslope::connections::Snowfall::exchange_target "void +cmf::upslope::ET::SW_evap_from_canopy::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") cmf::upslope::connections::Snowfall::get_ptr "ptr get_ptr() const "; +%feature("docstring") cmf::upslope::ET::SW_evap_from_canopy::get_ptr +"ptr get_ptr() const "; -%feature("docstring") cmf::upslope::connections::Snowfall::get_target -"flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") +cmf::upslope::ET::SW_evap_from_canopy::get_target "flux_node::ptr +get_target(const flux_node &inquirer) Returns the other end of a connection than the asking end. "; -%feature("docstring") cmf::upslope::connections::Snowfall::get_target -"flux_node::ptr get_target(int index) const +%feature("docstring") +cmf::upslope::ET::SW_evap_from_canopy::get_target "flux_node::ptr +get_target(int index) const With index 0, the left node is returned, with index 1 the right node of the connection. "; %feature("docstring") -cmf::upslope::connections::Snowfall::get_tracer_filter "real +cmf::upslope::ET::SW_evap_from_canopy::get_tracer_filter "real get_tracer_filter() A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -13591,39 +31839,43 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::connections::Snowfall::get_tracer_filter "real +cmf::upslope::ET::SW_evap_from_canopy::get_tracer_filter "real get_tracer_filter(solute S) A value ranging from 0 to 1 to filter tracers out of the water flux. "; -%feature("docstring") cmf::upslope::connections::Snowfall::kill_me "bool kill_me() +%feature("docstring") cmf::upslope::ET::SW_evap_from_canopy::kill_me +"bool kill_me() Deregisters this connection from its nodes. Returns true if only one reference is left. "; -%feature("docstring") cmf::upslope::connections::Snowfall::left_node -"flux_node::ptr left_node() const +%feature("docstring") +cmf::upslope::ET::SW_evap_from_canopy::left_node "flux_node::ptr +left_node() const Returns the left node of this connection. "; -%feature("docstring") cmf::upslope::connections::Snowfall::q "real +%feature("docstring") cmf::upslope::ET::SW_evap_from_canopy::q "real q(const flux_node &inquirer, cmf::math::Time t) Returns the current flux through a connection. Negative signs mean out of the inquirer, positive are inflows to the inquirer. "; -%feature("docstring") cmf::upslope::connections::Snowfall::refresh "void refresh(cmf::math::Time t) +%feature("docstring") cmf::upslope::ET::SW_evap_from_canopy::refresh +"void refresh(cmf::math::Time t) Performes a new calculation of the flux. "; -%feature("docstring") cmf::upslope::connections::Snowfall::right_node -"flux_node::ptr right_node() const +%feature("docstring") +cmf::upslope::ET::SW_evap_from_canopy::right_node "flux_node::ptr +right_node() const returns the right node of this connection "; %feature("docstring") -cmf::upslope::connections::Snowfall::set_tracer_filter "void +cmf::upslope::ET::SW_evap_from_canopy::set_tracer_filter "void set_tracer_filter(real value) A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -13632,687 +31884,812 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::connections::Snowfall::set_tracer_filter "void +cmf::upslope::ET::SW_evap_from_canopy::set_tracer_filter "void set_tracer_filter(solute S, real value) "; %feature("docstring") -cmf::upslope::connections::Snowfall::short_string "virtual +cmf::upslope::ET::SW_evap_from_canopy::short_string "virtual std::string short_string() const "; -%feature("docstring") cmf::upslope::connections::Snowfall::to_string -"virtual std::string to_string() const "; - - -// File: classcmf_1_1upslope_1_1_soil_layer.xml -%feature("docstring") cmf::upslope::SoilLayer " - -A representation of a SoilLayer. - -C++ includes: SoilLayer.h "; - -/* Overrides of flux_node */ - -%feature("docstring") cmf::upslope::SoilLayer::RecalcFluxes "virtual -bool RecalcFluxes(cmf::math::Time t) - -Pure flux_nodes do not influence fluxes, therefore no recalculation of -fluxes is required by flux_node. - -WaterStorage overrides this, since state changes require an update of -the fluxes "; - -%feature("docstring") cmf::upslope::SoilLayer::is_empty "virtual -double is_empty() const - -Returns true if the node has no water. "; - -%feature("docstring") cmf::upslope::SoilLayer::to_string "virtual -std::string to_string() const "; - -%feature("docstring") cmf::upslope::SoilLayer::conc "real conc(const -cmf::water::solute &_Solute) const - -Returns the concentration of the given solute. "; - -%feature("docstring") cmf::upslope::SoilLayer::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) const - -Returns the current WaterQuality (concentration of all solutes) "; - -%feature("docstring") cmf::upslope::SoilLayer::conc "void conc(const -cmf::water::solute &_Solute, real NewConcetration) - -Sets a new concentration. "; - -%feature("docstring") cmf::upslope::SoilLayer::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node -&target) - -Returns the connection between this and target. "; - -%feature("docstring") cmf::upslope::SoilLayer::dxdt "virtual real -dxdt(const cmf::math::Time &time) - -Returns the derivate of the state variable at time time. "; +%feature("docstring") +cmf::upslope::ET::SW_evap_from_canopy::to_string "virtual std::string +to_string() const "; -%feature("docstring") cmf::upslope::SoilLayer::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, -cmf::math::Time t) "; -%feature("docstring") cmf::upslope::SoilLayer::flux_to "real -flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +// File: classcmf__core_1_1_s_w__evap__from__layer.xml +%feature("docstring") cmf_core::SW_evap_from_layer " -Returns the actual flux between this and target (positive sign means -\"from this into target\") "; +Connection for Shuttleworth-Wallace ground evaporation. C++ includes: +ShuttleworthWallace.h "; -%feature("docstring") cmf::upslope::SoilLayer::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) +%feature("docstring") cmf_core::SW_evap_from_layer::__init__ "def +__init__(self, args, kwargs) -Returns the sum of all flux vectors. "; +__init__(cmf::upslope::ET::SW_evap_from_layer self, +cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr +ET_target, cmf::upslope::ET::ShuttleworthWallace::ptr owner) -> +SW_evap_from_layer SW_evap_from_layer(cmf::upslope::SoilLayer::ptr +source, cmf::water::flux_node::ptr ET_target, ShuttleworthWallace::ptr +owner) "; -%feature("docstring") cmf::upslope::SoilLayer::get_abs_errtol "real -get_abs_errtol(real rel_errtol) const "; +%feature("docstring") cmf_core::SW_evap_from_layer::__contains__ "def __contains__(self, cmp) "; -%feature("docstring") cmf::upslope::SoilLayer::get_capacity "virtual -real get_capacity() const +%feature("docstring") cmf_core::SW_evap_from_layer::__eq__ "def +__eq__(self, args, kwargs) -Returns the capacity of the water storage in m3. "; +__eq__(flux_connection self, flux_connection other) -> bool "; -%feature("docstring") cmf::upslope::SoilLayer::get_connections "cmf::water::connection_list get_connections() const "; +%feature("docstring") cmf_core::SW_evap_from_layer::__getitem__ "def +__getitem__(self, index) "; -%feature("docstring") cmf::upslope::SoilLayer::get_flow_crosssection -"real get_flow_crosssection(const cmf::upslope::SoilLayer &target, -bool HorizontalLayers=false) const +%feature("docstring") cmf_core::SW_evap_from_layer::__iter__ "def +__iter__(self) "; -Calculates the shared crosssectional area of this and another soil -water storage. +%feature("docstring") cmf_core::SW_evap_from_layer::__repr__ "def +__repr__(self) "; -If both layers belong to the same cell, the area of the cell is -returned, if they belong to different cells the area of the vertical -shared boundary is returned get_area in m2 +%feature("docstring") cmf_core::SW_evap_from_layer::conc "def +conc(self, args, kwargs) -Parameters: ------------ +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -target: The other soil water storage +%feature("docstring") cmf_core::SW_evap_from_layer::exchange_target "def exchange_target(self, args, kwargs) -HorizontalLayers: If true, the layers are assumed to be parallel to -the gravitational potential, otherwise they are assumed to be parallel -to the ground topography "; +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") -cmf::upslope::SoilLayer::get_gravitational_potential "real -get_gravitational_potential() const +%feature("docstring") cmf_core::SW_evap_from_layer::get_target "def +get_target(self, args) -Gravitational get_potential in m, reference height is sea level. +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -If the layer is saturated, it returns the saturated depth above sea -level, otherwise it returns the upperboundary of the layer +%feature("docstring") cmf_core::SW_evap_from_layer::get_tracer_filter +"def get_tracer_filter(self, args) -.. math:: +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; - - \\\\Psi_G=h +%feature("docstring") cmf_core::SW_evap_from_layer::kill_me "def +kill_me(self, args, kwargs) -"; +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -%feature("docstring") cmf::upslope::SoilLayer::get_ice_fraction "real get_ice_fraction() const +%feature("docstring") cmf_core::SW_evap_from_layer::left_node "def +left_node(self, args, kwargs) -real (Ice_fraction) "; +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -%feature("docstring") cmf::upslope::SoilLayer::get_K "real get_K() -const +%feature("docstring") cmf_core::SW_evap_from_layer::q "def q(self, +args, kwargs) -Returns the actual isotropic conductivity using the function from soil -:math:`\\\\frac{m}{day}`. "; +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; -%feature("docstring") cmf::upslope::SoilLayer::get_K "virtual real -get_K(cmf::geometry::point direction) const +%feature("docstring") cmf_core::SW_evap_from_layer::refresh "def +refresh(self, args, kwargs) -Returns the actual anisotropic conductivity along a direction :math:`K = (k_f \\\\cdot d) K`. "; +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; -%feature("docstring") cmf::upslope::SoilLayer::get_Ksat "real -get_Ksat() const "; +%feature("docstring") cmf_core::SW_evap_from_layer::right_node "def +right_node(self, args, kwargs) -%feature("docstring") cmf::upslope::SoilLayer::get_lower "ptr -get_lower() const "; +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; -%feature("docstring") cmf::upslope::SoilLayer::get_lower_boundary "virtual real get_lower_boundary() const +%feature("docstring") cmf_core::SW_evap_from_layer::set_tracer_filter +"def set_tracer_filter(self, args) -Returns the lower boundary of the water storage below ground in m. "; +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; -%feature("docstring") cmf::upslope::SoilLayer::get_matrix_potential "virtual real get_matrix_potential() const +%feature("docstring") cmf_core::SW_evap_from_layer::short_string "def short_string(self, args, kwargs) -Calls RetentionCurve::Matrixpotential. "; +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -%feature("docstring") cmf::upslope::SoilLayer::get_porosity "real -get_porosity() const +%feature("docstring") cmf_core::SW_evap_from_layer::to_string "def +to_string(self, args, kwargs) -Returns the mean porosity in the layer. "; +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -%feature("docstring") cmf::upslope::SoilLayer::get_potential "virtual real get_potential() const -Returns the total potential in m +// File: classcmf_1_1upslope_1_1_e_t_1_1_s_w__evap__from__layer.xml +%feature("docstring") cmf::upslope::ET::SW_evap_from_layer " -.. math:: +Connection for Shuttleworth-Wallace ground evaporation. - \\\\Psi = \\\\Psi_M + \\\\Psi_G - +C++ includes: ShuttleworthWallace.h "; -. "; +%feature("docstring") +cmf::upslope::ET::SW_evap_from_layer::SW_evap_from_layer "SW_evap_from_layer(cmf::upslope::SoilLayer::ptr source, +cmf::water::flux_node::ptr ET_target, ShuttleworthWallace::ptr owner) +"; -%feature("docstring") cmf::upslope::SoilLayer::get_project "cmf::project& get_project() const +%feature("docstring") cmf::upslope::ET::SW_evap_from_layer::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) -Returns the project, this node is part of. "; +Returns the concentration of the flux. -%feature("docstring") cmf::upslope::SoilLayer::get_rootfraction "real get_rootfraction() const +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; -Returns the root fraction of the layer. If it is not explicitly set, -it uses the parameters of the vegetation object of the cell. "; +%feature("docstring") +cmf::upslope::ET::SW_evap_from_layer::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") cmf::upslope::SoilLayer::get_saturated_depth "virtual real get_saturated_depth() const +%feature("docstring") cmf::upslope::ET::SW_evap_from_layer::get_ptr "ptr get_ptr() const "; -Returns the depth for saturation +%feature("docstring") +cmf::upslope::ET::SW_evap_from_layer::get_target "flux_node::ptr +get_target(const flux_node &inquirer) -.. math:: +Returns the other end of a connection than the asking end. "; - z_{sat,this} = - \\\\left\\\\{z_{cell}-\\\\Psi_{tot} \\\\mbox{ if } W<1 \\\\\\\\ - z_{sat,upper layer} \\\\right. +%feature("docstring") +cmf::upslope::ET::SW_evap_from_layer::get_target "flux_node::ptr +get_target(int index) const -. "; +With index 0, the left node is returned, with index 1 the right node +of the connection. "; -%feature("docstring") cmf::upslope::SoilLayer::get_soil "virtual -cmf::upslope::RetentionCurve& get_soil() const +%feature("docstring") +cmf::upslope::ET::SW_evap_from_layer::get_tracer_filter "real +get_tracer_filter() -Returns the soil properties of the water storage. "; +A value ranging from 0 to 1 to filter tracers out of the water flux. -%feature("docstring") cmf::upslope::SoilLayer::get_state "real -get_state() const "; +1.0 is no filter and 0.0 means no solute is crossing this connection +"; %feature("docstring") -cmf::upslope::SoilLayer::get_state_variable_content "char -get_state_variable_content() const +cmf::upslope::ET::SW_evap_from_layer::get_tracer_filter "real +get_tracer_filter(solute S) -A character indicating the integrated variable (either 'V' for Volume -or 'h' for head) "; +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; -%feature("docstring") cmf::upslope::SoilLayer::get_states "cmf::math::StateVariableList get_states() +%feature("docstring") cmf::upslope::ET::SW_evap_from_layer::kill_me "bool kill_me() -Add the state variables, owned by an object derived from -StateVariableOwner, to the given vector. "; +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; -%feature("docstring") cmf::upslope::SoilLayer::get_theta "virtual -real get_theta() const +%feature("docstring") cmf::upslope::ET::SW_evap_from_layer::left_node +"flux_node::ptr left_node() const -Returns the actual volumetric water content of the water storage. "; +Returns the left node of this connection. "; -%feature("docstring") cmf::upslope::SoilLayer::get_thickness "real -get_thickness() const "; +%feature("docstring") cmf::upslope::ET::SW_evap_from_layer::q "real +q(const flux_node &inquirer, cmf::math::Time t) -%feature("docstring") cmf::upslope::SoilLayer::get_upper "ptr -get_upper() const "; +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; -%feature("docstring") cmf::upslope::SoilLayer::get_upper_boundary "virtual real get_upper_boundary() const +%feature("docstring") cmf::upslope::ET::SW_evap_from_layer::refresh "void refresh(cmf::math::Time t) -Returns the upper boundary of the water storage below ground in m. "; +Performes a new calculation of the flux. "; -%feature("docstring") cmf::upslope::SoilLayer::get_volume "virtual -real get_volume() const +%feature("docstring") +cmf::upslope::ET::SW_evap_from_layer::right_node "flux_node::ptr +right_node() const -Returns the volume of water in this storage in m3 "; +returns the right node of this connection "; -%feature("docstring") cmf::upslope::SoilLayer::get_wetness "virtual -real get_wetness() const +%feature("docstring") +cmf::upslope::ET::SW_evap_from_layer::set_tracer_filter "void +set_tracer_filter(real value) -Returns the wetness of the soil :math:`\\\\frac{V_{H_2O}}{V_{pores}}`. "; +A value ranging from 0 to 1 to filter tracers out of the water flux. -%feature("docstring") cmf::upslope::SoilLayer::is_storage "virtual -bool is_storage() const +1.0 is no filter and 0.0 means no solute is crossing this connection +"; -Returns true, since this is a storage. "; +%feature("docstring") +cmf::upslope::ET::SW_evap_from_layer::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; -%feature("docstring") cmf::upslope::SoilLayer::remove_connection "bool remove_connection(cmf::water::flux_node::ptr To) +%feature("docstring") +cmf::upslope::ET::SW_evap_from_layer::short_string "virtual +std::string short_string() const "; -Remove the connection. "; +%feature("docstring") cmf::upslope::ET::SW_evap_from_layer::to_string +"virtual std::string to_string() const "; -%feature("docstring") cmf::upslope::SoilLayer::set_ice_fraction "void set_ice_fraction(real val) -Parameters: ------------ +// File: classcmf__core_1_1_s_w__evap__from__snow.xml +%feature("docstring") cmf_core::SW_evap_from_snow " -val: Ice_fraction (real) "; +Connection for Shuttleworth-Wallace canopy interception evaporation. +C++ includes: ShuttleworthWallace.h "; -%feature("docstring") cmf::upslope::SoilLayer::set_potential "virtual void set_potential(real waterhead) +%feature("docstring") cmf_core::SW_evap_from_snow::__init__ "def +__init__(self, args, kwargs) -Sets the potential of this soil water storage. "; +__init__(cmf::upslope::ET::SW_evap_from_snow self, +cmf::water::WaterStorage::ptr source, cmf::water::flux_node::ptr +ET_target, cmf::upslope::ET::ShuttleworthWallace::ptr owner) -> +SW_evap_from_snow SW_evap_from_snow(cmf::water::WaterStorage::ptr +source, cmf::water::flux_node::ptr ET_target, ShuttleworthWallace::ptr +owner) "; -%feature("docstring") cmf::upslope::SoilLayer::set_rootfraction "void set_rootfraction(real rootfraction) +%feature("docstring") cmf_core::SW_evap_from_snow::__contains__ "def +__contains__(self, cmp) "; -Sets the root fraction in this layer explicitly. "; +%feature("docstring") cmf_core::SW_evap_from_snow::__eq__ "def +__eq__(self, args, kwargs) -%feature("docstring") cmf::upslope::SoilLayer::set_soil "virtual -void set_soil(const cmf::upslope::RetentionCurve &r_curve) "; +__eq__(flux_connection self, flux_connection other) -> bool "; -%feature("docstring") cmf::upslope::SoilLayer::set_state "void -set_state(real newState) "; +%feature("docstring") cmf_core::SW_evap_from_snow::__getitem__ "def +__getitem__(self, index) "; -%feature("docstring") -cmf::upslope::SoilLayer::set_state_variable_content "void -set_state_variable_content(char content) +%feature("docstring") cmf_core::SW_evap_from_snow::__iter__ "def +__iter__(self) "; -A character indicating the integrated variable (either 'V' for Volume -or 'h' for head) "; +%feature("docstring") cmf_core::SW_evap_from_snow::__repr__ "def +__repr__(self) "; -%feature("docstring") cmf::upslope::SoilLayer::set_theta "virtual -void set_theta(real Value) "; +%feature("docstring") cmf_core::SW_evap_from_snow::conc "def +conc(self, args, kwargs) -%feature("docstring") cmf::upslope::SoilLayer::set_volume "virtual -void set_volume(real newwatercontent) +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -Sets the volume of water in this storage in m3 "; +%feature("docstring") cmf_core::SW_evap_from_snow::exchange_target "def exchange_target(self, args, kwargs) -%feature("docstring") cmf::upslope::SoilLayer::set_wetness "virtual -void set_wetness(real wetness) "; +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") cmf::upslope::SoilLayer::Solute "SoluteStorage& Solute(const cmf::water::solute _Solute) +%feature("docstring") cmf_core::SW_evap_from_snow::get_target "def +get_target(self, args) -Returns the water quality of the water storage. "; +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -%feature("docstring") cmf::upslope::SoilLayer::Solute "const -SoluteStorage& Solute(const cmf::water::solute _Solute) const "; +%feature("docstring") cmf_core::SW_evap_from_snow::get_tracer_filter +"def get_tracer_filter(self, args) -%feature("docstring") cmf::upslope::SoilLayer::waterbalance "real -waterbalance(cmf::math::Time t, const flux_connection *Without=0) -const +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -Returns the sum of all fluxes (positive and negative) at time t. +%feature("docstring") cmf_core::SW_evap_from_snow::kill_me "def +kill_me(self, args, kwargs) -Single fluxes can be excluded from the calculation +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -Parameters: ------------ +%feature("docstring") cmf_core::SW_evap_from_snow::left_node "def +left_node(self, args, kwargs) -t: Time of the query +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -Without: A flux_connection that is excluded from the waterbalance -(e.g. to prevent closed circuits) "; +%feature("docstring") cmf_core::SW_evap_from_snow::q "def q(self, +args, kwargs) +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; -// File: structcmf_1_1water_1_1solute.xml -%feature("docstring") cmf::water::solute " +%feature("docstring") cmf_core::SW_evap_from_snow::refresh "def +refresh(self, args, kwargs) -A structure to identify a solute. +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; -C++ includes: Solute.h "; +%feature("docstring") cmf_core::SW_evap_from_snow::right_node "def +right_node(self, args, kwargs) -%feature("docstring") cmf::water::solute::solute "solute(const -solute ©) "; +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; +%feature("docstring") cmf_core::SW_evap_from_snow::set_tracer_filter +"def set_tracer_filter(self, args) -// File: classcmf_1_1water_1_1solute__vector.xml -%feature("docstring") cmf::water::solute_vector " +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; -Manages the solutes of the model. +%feature("docstring") cmf_core::SW_evap_from_snow::short_string "def +short_string(self, args, kwargs) -C++ includes: Solute.h "; +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -%feature("docstring") cmf::water::solute_vector::solute_vector "solute_vector(std::string str) +%feature("docstring") cmf_core::SW_evap_from_snow::to_string "def +to_string(self, args, kwargs) -Creates a solute vector from solute names, separated by whitespace. -E.g. solutes= solute_vector(\"dO18 dH2\") "; +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -%feature("docstring") cmf::water::solute_vector::begin "const_iterator begin() const "; -%feature("docstring") cmf::water::solute_vector::end "const_iterator -end() const "; +// File: classcmf_1_1upslope_1_1_e_t_1_1_s_w__evap__from__snow.xml +%feature("docstring") cmf::upslope::ET::SW_evap_from_snow " -%feature("docstring") cmf::water::solute_vector::get_solute "cmf::water::solute* get_solute(int position) "; +Connection for Shuttleworth-Wallace canopy interception evaporation. -%feature("docstring") cmf::water::solute_vector::size "size_t size() -const "; +C++ includes: ShuttleworthWallace.h "; +%feature("docstring") +cmf::upslope::ET::SW_evap_from_snow::SW_evap_from_snow "SW_evap_from_snow(cmf::water::WaterStorage::ptr source, +cmf::water::flux_node::ptr ET_target, ShuttleworthWallace::ptr owner) +"; -// File: classcmf_1_1water_1_1_solute_storage.xml -%feature("docstring") cmf::water::SoluteStorage " +%feature("docstring") cmf::upslope::ET::SW_evap_from_snow::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) -A class for the storage of any tracer. +Returns the concentration of the flux. -The state is the amount (mol, kg etc. see cmf::water) of the tracer in -the storage. +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; -The derivative function is given by: +%feature("docstring") +cmf::upslope::ET::SW_evap_from_snow::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -.. math:: +%feature("docstring") cmf::upslope::ET::SW_evap_from_snow::get_ptr "ptr get_ptr() const "; - - \\\\frac{dX}{dt}&=&\\\\sum_{f=1}^{F}\\\\left( q_f [X]_f\\\\right) + - X_{in} - r^-X \\\\left[\\\\frac{mol}{day}\\\\right]\\\\\\\\ F&=& - \\\\mbox{Number of fluxes in water storage} \\\\\\\\ q_f&=& - \\\\mbox{Water flux in } \\\\frac{m^3}{day} \\\\\\\\ - \\\\left[X\\\\right]_f &=& \\\\mbox{Concentration of solute X in flux - }q_f \\\\mbox{ in } \\\\frac{mol}{m^3} \\\\\\\\ X_{in} &=& - \\\\mbox{Absolute source or sink term} \\\\frac{mol}{day} \\\\\\\\ r^- - &=& \\\\mbox{Decay rate} \\\\frac 1{day} \\\\\\\\ V &=& - \\\\mbox{Volume of water in water storage }\\\\left[m^3\\\\right] - +%feature("docstring") cmf::upslope::ET::SW_evap_from_snow::get_target +"flux_node::ptr get_target(const flux_node &inquirer) +Returns the other end of a connection than the asking end. "; +%feature("docstring") cmf::upslope::ET::SW_evap_from_snow::get_target +"flux_node::ptr get_target(int index) const -C++ includes: SoluteStorage.h "; +With index 0, the left node is returned, with index 1 the right node +of the connection. "; -%feature("docstring") cmf::water::SoluteStorage::dxdt "virtual real -dxdt(const cmf::math::Time &time) +%feature("docstring") +cmf::upslope::ET::SW_evap_from_snow::get_tracer_filter "real +get_tracer_filter() -Returns the derivate of the state variable at time time. "; +A value ranging from 0 to 1 to filter tracers out of the water flux. -%feature("docstring") cmf::water::SoluteStorage::get_abs_errtol "virtual real get_abs_errtol(real rel_errtol) const "; +1.0 is no filter and 0.0 means no solute is crossing this connection +"; -%feature("docstring") cmf::water::SoluteStorage::get_conc "real -get_conc() const +%feature("docstring") +cmf::upslope::ET::SW_evap_from_snow::get_tracer_filter "real +get_tracer_filter(solute S) -Returns the concentration of the solute. "; +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; -%feature("docstring") cmf::water::SoluteStorage::get_state "real -get_state() const +%feature("docstring") cmf::upslope::ET::SW_evap_from_snow::kill_me "bool kill_me() -Returns the current state of the variable. "; +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; -%feature("docstring") cmf::water::SoluteStorage::set_adsorption "void set_adsorption(const Adsorption &newadsorption, real m=-1) "; +%feature("docstring") cmf::upslope::ET::SW_evap_from_snow::left_node +"flux_node::ptr left_node() const -%feature("docstring") cmf::water::SoluteStorage::set_conc "void -set_conc(real NewConcentration) +Returns the left node of this connection. "; -set a new concentration of dissolved tracers. +%feature("docstring") cmf::upslope::ET::SW_evap_from_snow::q "real +q(const flux_node &inquirer, cmf::math::Time t) -In case of adsorption functions, the isotherm is used "; +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; -%feature("docstring") cmf::water::SoluteStorage::set_state "void -set_state(real newState) +%feature("docstring") cmf::upslope::ET::SW_evap_from_snow::refresh "void refresh(cmf::math::Time t) -Gives access to the state variable. "; +Performes a new calculation of the flux. "; -%feature("docstring") cmf::water::SoluteStorage::to_string "virtual -std::string to_string() const "; +%feature("docstring") cmf::upslope::ET::SW_evap_from_snow::right_node +"flux_node::ptr right_node() const +returns the right node of this connection "; -// File: classcmf_1_1water_1_1_solute_timeseries.xml -%feature("docstring") cmf::water::SoluteTimeseries " +%feature("docstring") +cmf::upslope::ET::SW_evap_from_snow::set_tracer_filter "void +set_tracer_filter(real value) -A map of concentration time series for solutes. +A value ranging from 0 to 1 to filter tracers out of the water flux. -C++ includes: Solute.h "; +1.0 is no filter and 0.0 means no solute is crossing this connection +"; -%feature("docstring") cmf::water::SoluteTimeseries::SoluteTimeseries -"SoluteTimeseries() "; +%feature("docstring") +cmf::upslope::ET::SW_evap_from_snow::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; -%feature("docstring") cmf::water::SoluteTimeseries::SoluteTimeseries -"SoluteTimeseries(const solute_vector &solutes, cmf::math::Time -begin, cmf::math::Time step) "; +%feature("docstring") +cmf::upslope::ET::SW_evap_from_snow::short_string "virtual +std::string short_string() const "; -%feature("docstring") cmf::water::SoluteTimeseries::SoluteTimeseries -"SoluteTimeseries(const cmf::water::SoluteTimeseries &sts) "; +%feature("docstring") cmf::upslope::ET::SW_evap_from_snow::to_string +"virtual std::string to_string() const "; -%feature("docstring") cmf::water::SoluteTimeseries::begin "iterator -begin() "; -%feature("docstring") cmf::water::SoluteTimeseries::begin "const_iterator begin() const "; +// File: classcmf_1_1upslope_1_1_e_t_1_1_s_w__evap__from__surfacewater.xml +%feature("docstring") cmf::upslope::ET::SW_evap_from_surfacewater " -%feature("docstring") cmf::water::SoluteTimeseries::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) const "; +Connection for Shuttleworth-Wallace canopy interception evaporation. -%feature("docstring") cmf::water::SoluteTimeseries::end "iterator -end() "; +C++ includes: ShuttleworthWallace.h "; -%feature("docstring") cmf::water::SoluteTimeseries::end "const_iterator end() const "; +%feature("docstring") +cmf::upslope::ET::SW_evap_from_surfacewater::SW_evap_from_surfacewater +"SW_evap_from_surfacewater(cmf::river::OpenWaterStorage::ptr source, +cmf::water::flux_node::ptr ET_target, ShuttleworthWallace::ptr owner) +"; -%feature("docstring") cmf::water::SoluteTimeseries::size "size_t -size() const +%feature("docstring") +cmf::upslope::ET::SW_evap_from_surfacewater::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) -Returns the number of solutes in the solution. "; +Returns the concentration of the flux. +If not overridden, it returns the concentration of the source of the +flux (direction depending) "; -// File: classcmf_1_1math_1_1_solute_water_integrator.xml -%feature("docstring") cmf::math::SoluteWaterIntegrator " +%feature("docstring") +cmf::upslope::ET::SW_evap_from_surfacewater::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -A SoluteWaterIntegrator implements the cmf::math::Integrator -interface, but consists of two independent ODE-solvers. +%feature("docstring") +cmf::upslope::ET::SW_evap_from_surfacewater::get_ptr "ptr get_ptr() +const "; -Added statevariables are sorted by waterstorages and solute storages -and assigned to the correct solver. +%feature("docstring") +cmf::upslope::ET::SW_evap_from_surfacewater::get_target "flux_node::ptr get_target(const flux_node &inquirer) -C++ includes: WaterSoluteIntegrator.h "; +Returns the other end of a connection than the asking end. "; -/* Accuracy parameters */ +%feature("docstring") +cmf::upslope::ET::SW_evap_from_surfacewater::get_target "flux_node::ptr get_target(int index) const -/* model time */ +With index 0, the left node is returned, with index 1 the right node +of the connection. "; -%feature("docstring") cmf::math::SoluteWaterIntegrator::get_t "cmf::math::Time get_t() const +%feature("docstring") +cmf::upslope::ET::SW_evap_from_surfacewater::get_tracer_filter "real +get_tracer_filter() -Returns the current model time. "; +A value ranging from 0 to 1 to filter tracers out of the water flux. -%feature("docstring") cmf::math::SoluteWaterIntegrator::set_t "void -set_t(cmf::math::Time val) +1.0 is no filter and 0.0 means no solute is crossing this connection +"; -Sets the current model time. "; +%feature("docstring") +cmf::upslope::ET::SW_evap_from_surfacewater::get_tracer_filter "real +get_tracer_filter(solute S) -%feature("docstring") cmf::math::SoluteWaterIntegrator::get_dt "cmf::math::Time get_dt() const +A value ranging from 0 to 1 to filter tracers out of the water flux. +"; -Returns the last time step. "; +%feature("docstring") +cmf::upslope::ET::SW_evap_from_surfacewater::kill_me "bool kill_me() -/* Integrate */ +Deregisters this connection from its nodes. Returns true if only one +reference is left. "; %feature("docstring") -cmf::math::SoluteWaterIntegrator::integrate_until "void -integrate_until(cmf::math::Time t_max, cmf::math::Time dt=Time(), bool -reset=false) +cmf::upslope::ET::SW_evap_from_surfacewater::left_node "flux_node::ptr left_node() const -Integrates the vector of state variables until t_max. +Returns the left node of this connection. "; -Parameters: ------------ +%feature("docstring") cmf::upslope::ET::SW_evap_from_surfacewater::q +"real q(const flux_node &inquirer, cmf::math::Time t) -t_max: Time, the solver should run to +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; -dt: Time step (may be omitted) +%feature("docstring") +cmf::upslope::ET::SW_evap_from_surfacewater::refresh "void +refresh(cmf::math::Time t) -reset: If true, solver is reseted before integration starts "; +Performes a new calculation of the flux. "; %feature("docstring") -cmf::math::SoluteWaterIntegrator::SoluteWaterIntegrator "SoluteWaterIntegrator(const cmf::water::solute_vector &solutes, const -cmf::math::Integrator &water_integrator, const cmf::math::Integrator -&solute_integrator) +cmf::upslope::ET::SW_evap_from_surfacewater::right_node "flux_node::ptr right_node() const -Creates a new SoluteWaterIntegrator. +returns the right node of this connection "; -Parameters: ------------ +%feature("docstring") +cmf::upslope::ET::SW_evap_from_surfacewater::set_tracer_filter "void +set_tracer_filter(real value) -solutes: Solutes of the project +A value ranging from 0 to 1 to filter tracers out of the water flux. -water_integrator: Template for the integrator of WaterStorage state -variables +1.0 is no filter and 0.0 means no solute is crossing this connection +"; -solute_integrator: Template for the integrator of soluteStorage state -variables "; +%feature("docstring") +cmf::upslope::ET::SW_evap_from_surfacewater::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; %feature("docstring") -cmf::math::SoluteWaterIntegrator::SoluteWaterIntegrator "SoluteWaterIntegrator(cmf::water::solute_vector solutes, const -cmf::math::Integrator &water_integrator, const cmf::math::Integrator -&solute_integrator, cmf::math::StateVariableOwner &states) +cmf::upslope::ET::SW_evap_from_surfacewater::short_string "virtual +std::string short_string() const "; -Creates a new SoluteWaterIntegrator. +%feature("docstring") +cmf::upslope::ET::SW_evap_from_surfacewater::to_string "virtual +std::string to_string() const "; -Parameters: ------------ -solutes: Solutes of the project +// File: classcmf__core_1_1_s_w__evap__from__surfacewater.xml +%feature("docstring") cmf_core::SW_evap_from_surfacewater " -water_integrator: Template for the integrator of WaterStorage state -variables +Connection for Shuttleworth-Wallace canopy interception evaporation. +C++ includes: ShuttleworthWallace.h "; -solute_integrator: Template for the integrator of soluteStorage state -variables +%feature("docstring") cmf_core::SW_evap_from_surfacewater::__init__ "def __init__(self, args, kwargs) -states: States to be added to the integrators "; +__init__(cmf::upslope::ET::SW_evap_from_surfacewater self, +cmf::river::OpenWaterStorage::ptr source, cmf::water::flux_node::ptr +ET_target, cmf::upslope::ET::ShuttleworthWallace::ptr owner) -> +SW_evap_from_surfacewater +SW_evap_from_surfacewater(cmf::river::OpenWaterStorage::ptr source, +cmf::water::flux_node::ptr ET_target, ShuttleworthWallace::ptr owner) +"; %feature("docstring") -cmf::math::SoluteWaterIntegrator::~SoluteWaterIntegrator "~SoluteWaterIntegrator() "; +cmf_core::SW_evap_from_surfacewater::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::SW_evap_from_surfacewater::__eq__ "def __eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; %feature("docstring") -cmf::math::SoluteWaterIntegrator::add_single_state "virtual void -add_single_state(cmf::math::StateVariable::ptr state) +cmf_core::SW_evap_from_surfacewater::__getitem__ "def +__getitem__(self, index) "; -Adds a single state variable to the integrator. "; +%feature("docstring") cmf_core::SW_evap_from_surfacewater::__iter__ "def __iter__(self) "; -%feature("docstring") cmf::math::SoluteWaterIntegrator::add_states "void add_states(cmf::math::StateVariableOwner &stateOwner) +%feature("docstring") cmf_core::SW_evap_from_surfacewater::__repr__ "def __repr__(self) "; -Add state variables from a StateVariableOwner. "; +%feature("docstring") cmf_core::SW_evap_from_surfacewater::conc "def +conc(self, args, kwargs) -%feature("docstring") -cmf::math::SoluteWaterIntegrator::add_values_to_states "void -add_values_to_states(const num_array &operands) +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -Adds the values in operands to the current states. "; +%feature("docstring") +cmf_core::SW_evap_from_surfacewater::exchange_target "def +exchange_target(self, args, kwargs) -%feature("docstring") cmf::math::SoluteWaterIntegrator::copy "virtual cmf::math::SoluteWaterIntegrator* copy() const +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -Polymorphic copy constructor. "; +%feature("docstring") cmf_core::SW_evap_from_surfacewater::get_target +"def get_target(self, args) -%feature("docstring") cmf::math::SoluteWaterIntegrator::copy_dxdt "void copy_dxdt(Time time, num_array &destination, real factor=1) const +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -Copies the derivatives at time step \"time\" to a numeric vector using -use_OpenMP. +%feature("docstring") +cmf_core::SW_evap_from_surfacewater::get_tracer_filter "def +get_tracer_filter(self, args) -Parameters: ------------ +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -time: Time at which the derivatives should be calculated +%feature("docstring") cmf_core::SW_evap_from_surfacewater::kill_me "def kill_me(self, args, kwargs) -destination: Vector to be overwritten by the results +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -factor: A factor that is multiplied to the derivate (e.g. unit -conversion or integration length) "; +%feature("docstring") cmf_core::SW_evap_from_surfacewater::left_node +"def left_node(self, args, kwargs) -%feature("docstring") cmf::math::SoluteWaterIntegrator::copy_dxdt "void copy_dxdt(Time time, real *destination, real factor=1) const +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -Copies the derivatives at time step \"time\" to an preallocated c -array. +%feature("docstring") cmf_core::SW_evap_from_surfacewater::q "def +q(self, args, kwargs) -Parameters: ------------ +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; -time: Time at which the derivatives should be calculated +%feature("docstring") cmf_core::SW_evap_from_surfacewater::refresh "def refresh(self, args, kwargs) -destination: Allocated c array +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; -factor: A factor that is multiplied to the derivate (e.g. unit -conversion or integration length) "; +%feature("docstring") cmf_core::SW_evap_from_surfacewater::right_node +"def right_node(self, args, kwargs) -%feature("docstring") cmf::math::SoluteWaterIntegrator::copy_states "void copy_states(num_array &destination) const +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; -Copies the states to a numeric vector using use_OpenMP. "; +%feature("docstring") +cmf_core::SW_evap_from_surfacewater::set_tracer_filter "def +set_tracer_filter(self, args) -%feature("docstring") cmf::math::SoluteWaterIntegrator::copy_states "void copy_states(real *destination) const "; +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; -%feature("docstring") cmf::math::SoluteWaterIntegrator::get_dxdt "cmf::math::num_array get_dxdt(Time time) const "; +%feature("docstring") +cmf_core::SW_evap_from_surfacewater::short_string "def +short_string(self, args, kwargs) -%feature("docstring") cmf::math::SoluteWaterIntegrator::get_state "real get_state(ptrdiff_t position) const +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -Returns the statevariable at position Simplifies the assessment of -state variables. "; +%feature("docstring") cmf_core::SW_evap_from_surfacewater::to_string +"def to_string(self, args, kwargs) -%feature("docstring") cmf::math::SoluteWaterIntegrator::get_states "cmf::math::num_array get_states() const "; +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -%feature("docstring") cmf::math::SoluteWaterIntegrator::get_states "StateVariableList get_states() -gets the state variables of the integrator "; +// File: classcmf__core_1_1_s_w__transpiration.xml +%feature("docstring") cmf_core::SW_transpiration " -%feature("docstring") cmf::math::SoluteWaterIntegrator::integrate "int integrate(cmf::math::Time t_max, cmf::math::Time dt) +Connection for Shuttleworth-Wallace transpiration. C++ includes: +ShuttleworthWallace.h "; -Integrates the vector of state variables. +%feature("docstring") cmf_core::SW_transpiration::__init__ "def +__init__(self, args, kwargs) -Parameters: ------------ +__init__(cmf::upslope::ET::SW_transpiration self, +cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr +ET_target, cmf::upslope::ET::ShuttleworthWallace::ptr owner) -> +SW_transpiration SW_transpiration(cmf::upslope::SoilLayer::ptr +source, cmf::water::flux_node::ptr ET_target, ShuttleworthWallace::ptr +owner) "; -t_max: To stop the model (if running in a model framework) at time -steps of value exchange e.g. full hours, the next value exchange time -can be given +%feature("docstring") cmf_core::SW_transpiration::__contains__ "def +__contains__(self, cmp) "; -dt: Takes the proposed time step, and changes it into the effectively -used time step according to the local stiffness of the problem and -MaxTime "; +%feature("docstring") cmf_core::SW_transpiration::__eq__ "def +__eq__(self, args, kwargs) -%feature("docstring") cmf::math::SoluteWaterIntegrator::reset "virtual void reset() +__eq__(flux_connection self, flux_connection other) -> bool "; -Resets the integrators (only needed for multistep methods) "; +%feature("docstring") cmf_core::SW_transpiration::__getitem__ "def +__getitem__(self, index) "; -%feature("docstring") cmf::math::SoluteWaterIntegrator::set_state "void set_state(ptrdiff_t position, real newState) +%feature("docstring") cmf_core::SW_transpiration::__iter__ "def +__iter__(self) "; -Simplifies the assessment of state variables. "; +%feature("docstring") cmf_core::SW_transpiration::__repr__ "def +__repr__(self) "; -%feature("docstring") cmf::math::SoluteWaterIntegrator::set_states "void set_states(const num_array &newStates) +%feature("docstring") cmf_core::SW_transpiration::conc "def +conc(self, args, kwargs) -Copies the new states to the actual states. "; +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -%feature("docstring") cmf::math::SoluteWaterIntegrator::set_states "void set_states(real *newStates) "; +%feature("docstring") cmf_core::SW_transpiration::exchange_target "def exchange_target(self, args, kwargs) -%feature("docstring") cmf::math::SoluteWaterIntegrator::size "size_t -size() const +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -returns the number of state variables "; +%feature("docstring") cmf_core::SW_transpiration::get_target "def +get_target(self, args) -%feature("docstring") cmf::math::SoluteWaterIntegrator::to_string "std::string to_string() const "; +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; +%feature("docstring") cmf_core::SW_transpiration::get_tracer_filter "def get_tracer_filter(self, args) -// File: struct_spbcg_mem_rec.xml -%feature("docstring") SpbcgMemRec ""; +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; +%feature("docstring") cmf_core::SW_transpiration::kill_me "def +kill_me(self, args, kwargs) -// File: struct_sptfqmr_mem_rec.xml -%feature("docstring") SptfqmrMemRec ""; +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; +%feature("docstring") cmf_core::SW_transpiration::left_node "def +left_node(self, args, kwargs) -// File: classcmf_1_1water_1_1statecontrol__connection.xml -%feature("docstring") cmf::water::statecontrol_connection " +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -Calculates a flux to or from a water storage to hold it's state at a -more or less constant level. +%feature("docstring") cmf_core::SW_transpiration::q "def q(self, +args, kwargs) +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; +%feature("docstring") cmf_core::SW_transpiration::refresh "def +refresh(self, args, kwargs) -.. math:: +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; - q=\\\\frac{h_1 - h_{target}}{t_c [days]} +%feature("docstring") cmf_core::SW_transpiration::right_node "def +right_node(self, args, kwargs) -where: :math:`q` the -resulting flux in m3/day +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; -:math:`h_1` the reference state +%feature("docstring") cmf_core::SW_transpiration::set_tracer_filter "def set_tracer_filter(self, args) -:math:`h_{target}` the state of the target (right) node +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; -:math:`t_c` the time to reach the target state +%feature("docstring") cmf_core::SW_transpiration::short_string "def +short_string(self, args, kwargs) -C++ includes: simple_connections.h "; +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -%feature("docstring") -cmf::water::statecontrol_connection::statecontrol_connection "statecontrol_connection(cmf::water::WaterStorage::ptr -controlled_storage, cmf::water::flux_node::ptr other_end, real -target_state, cmf::math::Time reaction_time) +%feature("docstring") cmf_core::SW_transpiration::to_string "def +to_string(self, args, kwargs) -Creates a flux connection to control the state of a storage. +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -Parameters: ------------ -controlled_storage: Water storage, to be controlled +// File: classcmf_1_1upslope_1_1_e_t_1_1_s_w__transpiration.xml +%feature("docstring") cmf::upslope::ET::SW_transpiration " -other_end: source of missing water or target of excessive water +Connection for Shuttleworth-Wallace transpiration. -target_state: State the controlled storage should hold ( -:math:`h_{target}`) +C++ includes: ShuttleworthWallace.h "; -reaction_time: Time to reach state ( :math:`t_c`) "; +%feature("docstring") +cmf::upslope::ET::SW_transpiration::SW_transpiration "SW_transpiration(cmf::upslope::SoilLayer::ptr source, +cmf::water::flux_node::ptr ET_target, ShuttleworthWallace::ptr owner) +"; -%feature("docstring") cmf::water::statecontrol_connection::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) +%feature("docstring") cmf::upslope::ET::SW_transpiration::conc "real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns the concentration of the flux. @@ -14320,24 +32697,24 @@ If not overridden, it returns the concentration of the source of the flux (direction depending) "; %feature("docstring") -cmf::water::statecontrol_connection::exchange_target "void +cmf::upslope::ET::SW_transpiration::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") cmf::water::statecontrol_connection::get_ptr "ptr get_ptr() const "; +%feature("docstring") cmf::upslope::ET::SW_transpiration::get_ptr "ptr get_ptr() const "; -%feature("docstring") cmf::water::statecontrol_connection::get_target +%feature("docstring") cmf::upslope::ET::SW_transpiration::get_target "flux_node::ptr get_target(const flux_node &inquirer) Returns the other end of a connection than the asking end. "; -%feature("docstring") cmf::water::statecontrol_connection::get_target +%feature("docstring") cmf::upslope::ET::SW_transpiration::get_target "flux_node::ptr get_target(int index) const With index 0, the left node is returned, with index 1 the right node of the connection. "; %feature("docstring") -cmf::water::statecontrol_connection::get_tracer_filter "real +cmf::upslope::ET::SW_transpiration::get_tracer_filter "real get_tracer_filter() A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -14346,39 +32723,38 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::water::statecontrol_connection::get_tracer_filter "real +cmf::upslope::ET::SW_transpiration::get_tracer_filter "real get_tracer_filter(solute S) A value ranging from 0 to 1 to filter tracers out of the water flux. "; -%feature("docstring") cmf::water::statecontrol_connection::kill_me "bool kill_me() +%feature("docstring") cmf::upslope::ET::SW_transpiration::kill_me "bool kill_me() Deregisters this connection from its nodes. Returns true if only one reference is left. "; -%feature("docstring") cmf::water::statecontrol_connection::left_node -"flux_node::ptr left_node() const +%feature("docstring") cmf::upslope::ET::SW_transpiration::left_node "flux_node::ptr left_node() const Returns the left node of this connection. "; -%feature("docstring") cmf::water::statecontrol_connection::q "real +%feature("docstring") cmf::upslope::ET::SW_transpiration::q "real q(const flux_node &inquirer, cmf::math::Time t) Returns the current flux through a connection. Negative signs mean out of the inquirer, positive are inflows to the inquirer. "; -%feature("docstring") cmf::water::statecontrol_connection::refresh "void refresh(cmf::math::Time t) +%feature("docstring") cmf::upslope::ET::SW_transpiration::refresh "void refresh(cmf::math::Time t) Performes a new calculation of the flux. "; -%feature("docstring") cmf::water::statecontrol_connection::right_node +%feature("docstring") cmf::upslope::ET::SW_transpiration::right_node "flux_node::ptr right_node() const returns the right node of this connection "; %feature("docstring") -cmf::water::statecontrol_connection::set_tracer_filter "void +cmf::upslope::ET::SW_transpiration::set_tracer_filter "void set_tracer_filter(real value) A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -14387,131 +32763,167 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::water::statecontrol_connection::set_tracer_filter "void +cmf::upslope::ET::SW_transpiration::set_tracer_filter "void set_tracer_filter(solute S, real value) "; %feature("docstring") -cmf::water::statecontrol_connection::short_string "virtual -std::string short_string() const "; +cmf::upslope::ET::SW_transpiration::short_string "virtual std::string +short_string() const "; -%feature("docstring") cmf::water::statecontrol_connection::to_string -"virtual std::string to_string() const "; +%feature("docstring") cmf::upslope::ET::SW_transpiration::to_string "virtual std::string to_string() const "; -// File: classcmf_1_1math_1_1_state_variable.xml -%feature("docstring") cmf::math::StateVariable " +// File: classcmf__core_1_1_s_w_a_t_percolation.xml +%feature("docstring") cmf_core::SWATPercolation " -Abstract class state variable. +A tipping bucket percolation approach similar to the approach in SWAT. +.. math:: q_{perc} &=& +V_{H_2O,drain}\\\\\\\\left(1-e^{-\\\\\\\\frac +1{-TT_{perc}}}\\\\\\\\right) \\\\\\\\\\\\\\\\ TT_{perc} &=& +\\\\\\\\frac{V_{pores,drain} - V_{field cap.}}{K_{sat}} +\\\\\\\\\\\\\\\\ V_{x,drain} &=& V_{x,drain} - V_{field cap.} C++ +includes: Percolation.h "; + +%feature("docstring") cmf_core::SWATPercolation::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::connections::SWATPercolation self, +cmf::upslope::SoilLayer::ptr upperLayer, cmf::upslope::SoilLayer::ptr +lowerLayer) -> SWATPercolation +SWATPercolation(cmf::upslope::SoilLayer::ptr upperLayer, +cmf::upslope::SoilLayer::ptr lowerLayer) "; -Simple exponential system class header implementing a state variable: +%feature("docstring") cmf_core::SWATPercolation::__contains__ "def +__contains__(self, cmp) "; -C++ includes: statevariable.h "; +%feature("docstring") cmf_core::SWATPercolation::__eq__ "def +__eq__(self, args, kwargs) -%feature("docstring") cmf::math::StateVariable::StateVariable "StateVariable(real InitialState=0, real scale=1) +__eq__(flux_connection self, flux_connection other) -> bool "; -ctor "; +%feature("docstring") cmf_core::SWATPercolation::__getitem__ "def +__getitem__(self, index) "; -%feature("docstring") cmf::math::StateVariable::~StateVariable "virtual ~StateVariable() "; +%feature("docstring") cmf_core::SWATPercolation::__iter__ "def +__iter__(self) "; -%feature("docstring") cmf::math::StateVariable::dxdt "virtual real -dxdt(const cmf::math::Time &time)=0 +%feature("docstring") cmf_core::SWATPercolation::__repr__ "def +__repr__(self) "; -Returns the derivate of the state variable at time time. "; +%feature("docstring") cmf_core::SWATPercolation::conc "def +conc(self, args, kwargs) -%feature("docstring") cmf::math::StateVariable::get_abs_errtol "virtual real get_abs_errtol(real rel_errtol) const "; +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -%feature("docstring") cmf::math::StateVariable::get_state "real -get_state() const +%feature("docstring") cmf_core::SWATPercolation::exchange_target "def exchange_target(self, args, kwargs) -Returns the current state of the variable. "; +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") cmf::math::StateVariable::set_state "void -set_state(real newState) +%feature("docstring") cmf_core::SWATPercolation::get_target "def +get_target(self, args) -Gives access to the state variable. "; +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -%feature("docstring") cmf::math::StateVariable::to_string "virtual -std::string to_string() const =0 "; +%feature("docstring") cmf_core::SWATPercolation::get_tracer_filter "def get_tracer_filter(self, args) +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -// File: classcmf_1_1math_1_1_state_variable_list.xml -%feature("docstring") cmf::math::StateVariableList ""; +%feature("docstring") cmf_core::SWATPercolation::kill_me "def +kill_me(self, args, kwargs) -%feature("docstring") -cmf::math::StateVariableList::~StateVariableList "virtual -~StateVariableList() "; +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -%feature("docstring") cmf::math::StateVariableList::append "void -append(StateVariable::ptr sv) "; +%feature("docstring") cmf_core::SWATPercolation::left_node "def +left_node(self, args, kwargs) -%feature("docstring") cmf::math::StateVariableList::begin "state_vector::iterator begin() "; +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -%feature("docstring") cmf::math::StateVariableList::begin "state_vector::const_iterator begin() const "; +%feature("docstring") cmf_core::SWATPercolation::q "def q(self, +args, kwargs) -%feature("docstring") cmf::math::StateVariableList::end "state_vector::iterator end() "; +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; -%feature("docstring") cmf::math::StateVariableList::end "state_vector::const_iterator end() const "; +%feature("docstring") cmf_core::SWATPercolation::refresh "def +refresh(self, args, kwargs) -%feature("docstring") cmf::math::StateVariableList::extend "void -extend(StateVariableOwner &svo) "; +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; -%feature("docstring") cmf::math::StateVariableList::get_states "StateVariableList get_states() "; +%feature("docstring") cmf_core::SWATPercolation::right_node "def +right_node(self, args, kwargs) -%feature("docstring") cmf::math::StateVariableList::size "size_t -size() const "; +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; +%feature("docstring") cmf_core::SWATPercolation::set_tracer_filter "def set_tracer_filter(self, args) -// File: classcmf_1_1math_1_1_state_variable_owner.xml -%feature("docstring") cmf::math::StateVariableOwner " +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; -An abstract class, that owns one or more state variables, that can add -them to a vector of state variables in a certain order. +%feature("docstring") cmf_core::SWATPercolation::short_string "def +short_string(self, args, kwargs) -C++ includes: statevariable.h "; +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -%feature("docstring") -cmf::math::StateVariableOwner::~StateVariableOwner "virtual -~StateVariableOwner() "; +%feature("docstring") cmf_core::SWATPercolation::to_string "def +to_string(self, args, kwargs) -%feature("docstring") cmf::math::StateVariableOwner::get_states "virtual StateVariableList get_states()=0 +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -Add the state variables, owned by an object derived from -StateVariableOwner, to the given vector. "; +%feature("docstring") cmf_core::SWATPercolation::use_for_cell "def +use_for_cell(args, kwargs) +use_for_cell(Cell cell, bool no_override=True) "; -// File: classcmf_1_1stopwatch_1_1_stop_watch.xml -%feature("docstring") cmf::stopwatch::StopWatch " -A stopwatch to estimated the total time of a process Creating a -StopWatch: >>>stopwatch=StopWatch(start,stop) Start and end are -indicators to describe the progress of a process. Start is the -indicator value at the beginning of the process. As default they are -0.0 and 1.0. Starting the StopWatch again: >>>stopwatch.start() -Getting the elapsed time, the total time and the remaining time of the -process in seconds: >>>elapsed,total,remaining = stopwatch(progress) -Where progress is a process progress indicator matching start and stop -Example: stopwatch=StopWatch(0,10) for i in range(10): time.sleep(1) -print('elapsed = %0.2fs, total= %0.2fs, remaining = %0.2fs' % -stopwatch(i+1)) "; +// File: classcmf_1_1upslope_1_1connections_1_1_s_w_a_t_percolation.xml +%feature("docstring") cmf::upslope::connections::SWATPercolation " -%feature("docstring") cmf::stopwatch::StopWatch::__init__ "def -__init__(self, start=0.0, stop=1.0) "; +A tipping bucket percolation approach similar to the approach in SWAT. -%feature("docstring") cmf::stopwatch::StopWatch::__call__ "def -__call__(self, progress) "; -%feature("docstring") cmf::stopwatch::StopWatch::start "def -start(self) "; +.. math:: -// File: classcmf_1_1upslope_1_1_e_t_1_1stressed_e_t.xml -%feature("docstring") cmf::upslope::ET::stressedET " + q_{perc} &=& + V_{H_2O,drain}\\\\left(1-e^{-\\\\frac 1{-TT_{perc}}}\\\\right) + \\\\\\\\ TT_{perc} &=& \\\\frac{V_{pores,drain} - V_{field + cap.}}{K_{sat}} \\\\\\\\ V_{x,drain} &=& V_{x,drain} - V_{field cap.} + -An abstract base class for ET Methods with a WaterStressFunction. -C++ includes: ET.h "; -%feature("docstring") cmf::upslope::ET::stressedET::conc "real +C++ includes: Percolation.h "; + +%feature("docstring") +cmf::upslope::connections::SWATPercolation::SWATPercolation "SWATPercolation(cmf::upslope::SoilLayer::ptr upperLayer, +cmf::upslope::SoilLayer::ptr lowerLayer) "; + +%feature("docstring") +cmf::upslope::connections::SWATPercolation::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns the concentration of the flux. @@ -14519,804 +32931,897 @@ Returns the concentration of the flux. If not overridden, it returns the concentration of the source of the flux (direction depending) "; -%feature("docstring") cmf::upslope::ET::stressedET::ETpot "virtual -real ETpot(cmf::math::Time t) const "; - -%feature("docstring") cmf::upslope::ET::stressedET::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr -newTarget) "; - -%feature("docstring") cmf::upslope::ET::stressedET::get_layer "SoilLayer::ptr get_layer() const "; +%feature("docstring") +cmf::upslope::connections::SWATPercolation::exchange_target "void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") cmf::upslope::ET::stressedET::get_ptr "ptr -get_ptr() const "; +%feature("docstring") +cmf::upslope::connections::SWATPercolation::get_ptr "ptr get_ptr() +const "; -%feature("docstring") cmf::upslope::ET::stressedET::get_target "flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") +cmf::upslope::connections::SWATPercolation::get_target "flux_node::ptr get_target(const flux_node &inquirer) Returns the other end of a connection than the asking end. "; -%feature("docstring") cmf::upslope::ET::stressedET::get_target "flux_node::ptr get_target(int index) const +%feature("docstring") +cmf::upslope::connections::SWATPercolation::get_target "flux_node::ptr get_target(int index) const With index 0, the left node is returned, with index 1 the right node of the connection. "; -%feature("docstring") cmf::upslope::ET::stressedET::get_tracer_filter -"real get_tracer_filter() +%feature("docstring") +cmf::upslope::connections::SWATPercolation::get_tracer_filter "real +get_tracer_filter() A value ranging from 0 to 1 to filter tracers out of the water flux. 1.0 is no filter and 0.0 means no solute is crossing this connection "; -%feature("docstring") cmf::upslope::ET::stressedET::get_tracer_filter -"real get_tracer_filter(solute S) +%feature("docstring") +cmf::upslope::connections::SWATPercolation::get_tracer_filter "real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter tracers out of the water flux. "; -%feature("docstring") cmf::upslope::ET::stressedET::kill_me "bool -kill_me() +%feature("docstring") +cmf::upslope::connections::SWATPercolation::kill_me "bool kill_me() Deregisters this connection from its nodes. Returns true if only one reference is left. "; -%feature("docstring") cmf::upslope::ET::stressedET::left_node "flux_node::ptr left_node() const +%feature("docstring") +cmf::upslope::connections::SWATPercolation::left_node "flux_node::ptr +left_node() const Returns the left node of this connection. "; -%feature("docstring") cmf::upslope::ET::stressedET::q "real q(const -flux_node &inquirer, cmf::math::Time t) +%feature("docstring") cmf::upslope::connections::SWATPercolation::q "real q(const flux_node &inquirer, cmf::math::Time t) Returns the current flux through a connection. Negative signs mean out of the inquirer, positive are inflows to the inquirer. "; -%feature("docstring") cmf::upslope::ET::stressedET::refresh "void +%feature("docstring") +cmf::upslope::connections::SWATPercolation::refresh "void refresh(cmf::math::Time t) Performes a new calculation of the flux. "; -%feature("docstring") cmf::upslope::ET::stressedET::right_node "flux_node::ptr right_node() const +%feature("docstring") +cmf::upslope::connections::SWATPercolation::right_node "flux_node::ptr right_node() const returns the right node of this connection "; %feature("docstring") -cmf::upslope::ET::stressedET::set_stressfunction "void -set_stressfunction(const RootUptakeStessFunction &stressfunction) - -Sets the stress function to limit water uptake. "; - -%feature("docstring") cmf::upslope::ET::stressedET::set_tracer_filter -"void set_tracer_filter(real value) +cmf::upslope::connections::SWATPercolation::set_tracer_filter "void +set_tracer_filter(real value) A value ranging from 0 to 1 to filter tracers out of the water flux. 1.0 is no filter and 0.0 means no solute is crossing this connection "; -%feature("docstring") cmf::upslope::ET::stressedET::set_tracer_filter -"void set_tracer_filter(solute S, real value) "; +%feature("docstring") +cmf::upslope::connections::SWATPercolation::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; -%feature("docstring") cmf::upslope::ET::stressedET::short_string "virtual std::string short_string() const "; +%feature("docstring") +cmf::upslope::connections::SWATPercolation::short_string "virtual +std::string short_string() const "; -%feature("docstring") cmf::upslope::ET::stressedET::to_string "std::string to_string() const "; +%feature("docstring") +cmf::upslope::connections::SWATPercolation::to_string "virtual +std::string to_string() const "; -// File: classcmf_1_1upslope_1_1subcatchment.xml -%feature("docstring") cmf::upslope::subcatchment " +// File: classcmf__core_1_1_s_w_a_t_reach_type.xml +%feature("docstring") cmf_core::SWATReachType " -A class to structure cells in a project using their main outlets. +Structure for the description of structural parameters of a reach. +Uses the SWAT IChannel geometry (see SWAT Theoretical Documentation, +Version 2005 (ch. 7:1.1), Neitsch et al. 2005), in this class +referenced as SWATtheoDoc. Differences to the SWAT geometry: The flood +plain is not plain, but has a small slope=0.5%, but has an infinite +width C++ includes: ReachType.h "; -C++ includes: algorithm.h "; +%feature("docstring") cmf_core::SWATReachType::__init__ "def +__init__(self, args) -%feature("docstring") cmf::upslope::subcatchment::subcatchment "subcatchment(cmf::upslope::Cell &pourpoint, double -area_threshold=1e308) +__init__(cmf::river::SWATReachType self, SWATReachType copy) -> +SWATReachType __init__(cmf::river::SWATReachType self, double l) -> +SWATReachType __init__(cmf::river::SWATReachType self, double l, +double BankWidth, double Depth) -> SWATReachType SWATReachType(double +l, double BankWidth, double Depth) Creates a new reach structure from +a give width and depth. Parameters: ----------- l: length of the +channel [m] BankWidth: get_channel_width of the reach from bank to +bank [m] Depth: Depth of the reach [m] "; -Creates a subcatchment from a pourpoint cell. +%feature("docstring") cmf_core::SWATReachType::A "def A(self, args, +kwargs) -Parameters: ------------ +A(IVolumeHeightFunction self, double V) -> double virtual double +A(double V) const =0 Returns the area of the surface for a given +volume. "; -pourpoint: The pourpoint (outlet of the subcatchment) +%feature("docstring") cmf_core::SWATReachType::copy "def copy(self, +args, kwargs) -area_threshold: Minimum contributing area size to form a -subcatchment. When area_threshold > area(cells), all upslope cells of -pourpoint are used. "; +copy(SWATReachType self) -> SWATReachType SWATReachType* copy() const +"; +%feature("docstring") cmf_core::SWATReachType::get_channel_width "def get_channel_width(self, args, kwargs) -// File: classcmf_1_1upslope_1_1_e_t_1_1_suction_stress.xml -%feature("docstring") cmf::upslope::ET::SuctionStress " +get_channel_width(IChannel self, double depth) -> double virtual +double get_channel_width(double depth) const =0 Calculates the flow +width from a given actual depth [m] using the actual IChannel +geometry. "; -The classical suction depending transpiration Stress curve after -Feddes. +%feature("docstring") cmf_core::SWATReachType::get_depth "def +get_depth(self, args, kwargs) -The ability of roots to take water from the soil up is limited by the -suction pressure (matrix potential) of the soil. The stress is defined -using a trapezoid function, with P0 being the pressure, where water -uptake is prohibited by saturation. Between P0 and P1 the saturation -stress gets lower. Between P1 and P2, no stress occurs ( ET=ETpot) and -with a pressure below P2, water uptake is limited by drought. P3 -indicates the highest suction (lowest pressure) to which plants can -extract water (wilting point). +get_depth(IChannel self, double area) -> double virtual double +get_depth(double area) const =0 Calculates the actual depth of the +reach using the IChannel geometry. get_depth of the reach [m] +Parameters: ----------- area: Wetted area of a river cross section +[m2], can be obtained by V/l, where V is the stored volume and l is +the reach length "; -Default values: :math:`P_0 = \\\\infty, P_1=\\\\infty, P_2=-5m, P_3=-160m`, -resulting in no saturation stress and draught stress starting at -5m -and a wilting point of -160m. +%feature("docstring") cmf_core::SWATReachType::get_flux_crossection "def get_flux_crossection(self, args, kwargs) -If one would like to include saturation stress, typical values for P0 -and P1 are 0.0m and 0.1m. By changing P2 and P3, you can account for -different drought sensibility for different plant types. +get_flux_crossection(IChannel self, double depth) -> double virtual +double get_flux_crossection(double depth) const =0 Calculates the +wetted area from a given depth using the IChannel geometry. In most +cases use get_flux_crossection=V/l, where V is the stored volume and l +is the reach length Wetted area of a river cross section [m2] +Parameters: ----------- depth: depth of the reach [m] "; -C++ includes: waterstress.h "; +%feature("docstring") cmf_core::SWATReachType::get_length "def +get_length(self, args, kwargs) -%feature("docstring") cmf::upslope::ET::SuctionStress::SuctionStress -"SuctionStress(real P0=1e308, real P1=1e307, real P2=-5, real -P3=-160) +get_length(IChannel self) -> double virtual double get_length() const +=0 Length of the reach. "; -Creates a new suction stress function. "; +%feature("docstring") cmf_core::SWATReachType::get_nManning "def +get_nManning(self, args, kwargs) -%feature("docstring") cmf::upslope::ET::SuctionStress::SuctionStress -"SuctionStress(const SuctionStress &other) "; +get_nManning(IChannel self) -> double virtual double get_nManning() +const =0 "; -%feature("docstring") cmf::upslope::ET::SuctionStress::~SuctionStress -"virtual ~SuctionStress() "; +%feature("docstring") cmf_core::SWATReachType::get_wetted_perimeter "def get_wetted_perimeter(self, args, kwargs) -%feature("docstring") cmf::upslope::ET::SuctionStress::copy "cmf::upslope::ET::SuctionStress* copy() const +get_wetted_perimeter(IChannel self, double depth) -> double virtual +double get_wetted_perimeter(double depth) const =0 Calculates the +wetted perimeter from a given actual depth [m] using the actual +IChannel geometry. "; -Creates a new copy of this wetness. "; +%feature("docstring") cmf_core::SWATReachType::h "def h(self, args, +kwargs) -%feature("docstring") cmf::upslope::ET::SuctionStress::Tact "real -Tact(const stressedET *connection, real Tpot) const +h(IVolumeHeightFunction self, double V) -> double virtual double +h(double V) const =0 Returns the depth of a given volume. "; -Calculates the water stress for a layer. +%feature("docstring") cmf_core::SWATReachType::q "def q(self, args, +kwargs) -Parameters: ------------ +q(IVolumeHeightFunction self, double h, double slope) -> double +virtual double q(double h, double slope) const "; -connection: The stressedET connection this stress function belongs to +%feature("docstring") cmf_core::SWATReachType::qManning "def +qManning(self, args, kwargs) -Tpot: Potential Transpiration in mm/day (for the full profile) +qManning(IChannel self, double A, double slope) -> double virtual +double qManning(double A, double slope) const Calculates the flow +rate from a given water volume in the reach .. math:: q_{Manning}&=& +A R^{\\\\\\\\frac 2 3} \\\\\\\\sqrt{\\\\\\\\frac {\\\\\\\\Delta_z} +n} \\\\\\\\\\\\\\\\ A &=& \\\\\\\\frac V l \\\\\\\\mbox{, +(Crosssectional area of the wetted crossection, Volume per +length)} \\\\\\\\\\\\\\\\ R &=& \\\\\\\\frac A {P(d)} \\\\\\\\\\\\\\\\ +P(d) &=& \\\\\\\\mbox{ the perimeter of the wetted crosssection, a +function of reach depth} \\\\\\\\\\\\\\\\ d(V) &=& \\\\\\\\mbox{ +the depth of the reach a function of the volume} \\\\\\\\\\\\\\\\ +\\\\\\\\Delta_z &=& \\\\\\\\frac{z_{max} - z_{min}}{l} +\\\\\\\\mbox{ Slope of the reach} . Flow rate [m3/s] Parameters: +----------- A: The area of the cross section [m2] slope: The slope +of the reach [m/m] "; -Actual flux from layer in m3/day "; +%feature("docstring") cmf_core::SWATReachType::set_nManning "def +set_nManning(self, args, kwargs) -%feature("docstring") cmf::upslope::ET::SuctionStress::to_string "std::string to_string() const "; +set_nManning(IChannel self, double val) virtual void +set_nManning(double val)=0 "; +%feature("docstring") cmf_core::SWATReachType::typecode "def +typecode(self, args, kwargs) -// File: classcmf_1_1upslope_1_1_surface_water.xml -%feature("docstring") cmf::upslope::SurfaceWater " +typecode(IChannel self) -> char virtual char typecode() const =0 "; -A child class of OpenWaterStorage to model surface water on a cell. +%feature("docstring") cmf_core::SWATReachType::V "def V(self, args, +kwargs) -Specially created to connect a SurfaceWater with other nodes, is the -flux connection cmf::upslope::connections::KinematicSurfaceRunoff +V(IVolumeHeightFunction self, double h) -> double virtual double +V(double h) const =0 "; -C++ includes: surfacewater.h "; -/* Overrides of flux_node */ +// File: classcmf_1_1river_1_1_s_w_a_t_reach_type.xml +%feature("docstring") cmf::river::SWATReachType " -%feature("docstring") cmf::upslope::SurfaceWater::RecalcFluxes "virtual bool RecalcFluxes(cmf::math::Time t) +Structure for the description of structural parameters of a reach. -Pure flux_nodes do not influence fluxes, therefore no recalculation of -fluxes is required by flux_node. +Uses the SWAT IChannel geometry (see SWAT Theoretical Documentation, +Version 2005 (ch. 7:1.1), Neitsch et al. 2005), in this class +referenced as SWATtheoDoc. Differences to the SWAT geometry: The flood +plain is not plain, but has a small slope=0.5%, but has an infinite +width -WaterStorage overrides this, since state changes require an update of -the fluxes "; +C++ includes: ReachType.h "; -%feature("docstring") cmf::upslope::SurfaceWater::is_empty "virtual -double is_empty() const +%feature("docstring") cmf::river::SWATReachType::SWATReachType "SWATReachType(const SWATReachType ©) "; -Returns true if the node has no water. "; +%feature("docstring") cmf::river::SWATReachType::SWATReachType "SWATReachType(double l) -%feature("docstring") cmf::upslope::SurfaceWater::to_string "virtual -std::string to_string() const "; +Creates a new reach structure with standard values (small natural +river) BottomWidth = 3m, ChannelDepth = 0.5m, BankSlope = 2, nManning += 0.0035, FloodPlainSlope = 200. "; -%feature("docstring") cmf::upslope::SurfaceWater::conc "real -conc(cmf::math::Time t, const cmf::water::solute &solute) const +%feature("docstring") cmf::river::SWATReachType::SWATReachType "SWATReachType(double l, double BankWidth, double Depth) -Returns the water quality of the flux_node, if it is not overridden -this is the mix of the incoming fluxes. "; +Creates a new reach structure from a give width and depth. -%feature("docstring") cmf::upslope::SurfaceWater::conc "real -conc(const cmf::water::solute &_Solute) const +Parameters: +----------- -Returns the concentration of the given solute. "; +l: length of the channel [m] -%feature("docstring") cmf::upslope::SurfaceWater::conc "void -conc(const cmf::water::solute &_Solute, real NewConcetration) +BankWidth: get_channel_width of the reach from bank to bank [m] -Sets a new concentration. "; +Depth: Depth of the reach [m] "; -%feature("docstring") cmf::upslope::SurfaceWater::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node -&target) +%feature("docstring") cmf::river::SWATReachType::~SWATReachType "virtual ~SWATReachType() "; -Returns the connection between this and target. "; +%feature("docstring") cmf::river::SWATReachType::A "virtual double +A(double V) const -%feature("docstring") cmf::upslope::SurfaceWater::dxdt "virtual real -dxdt(const cmf::math::Time &time) +Returns the area of the surface for a given volume. "; -Returns the derivate of the state variable at time time. "; +%feature("docstring") cmf::river::SWATReachType::copy "SWATReachType* copy() const "; -%feature("docstring") cmf::upslope::SurfaceWater::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, -cmf::math::Time t) "; +%feature("docstring") cmf::river::SWATReachType::get_channel_width "virtual double get_channel_width(double depth) const -%feature("docstring") cmf::upslope::SurfaceWater::flux_to "real -flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +Calculates the flow width from a given actual depth [m] using the +actual IChannel geometry -Returns the actual flux between this and target (positive sign means -\"from this into target\") "; +.. math:: -%feature("docstring") cmf::upslope::SurfaceWater::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) + \\\\mbox{If } d\\\\le + d_{IChannel} && \\\\\\\\ w &=& w_{bottom} + 2 \\\\Delta_{bank} d + \\\\\\\\ \\\\mbox{else, } && \\\\mbox{if the river floods the flood + plain} \\\\\\\\ w &=& w_{bank} + 2 \\\\Delta_{Floodplain} + (d-d_{IChannel} \\\\\\\\ -Returns the sum of all flux vectors. "; +. -%feature("docstring") cmf::upslope::SurfaceWater::get_abs_errtol "real get_abs_errtol(real rel_errtol) const "; +See: SWATtheoDoc eq. 7:1.1.3 "; -%feature("docstring") cmf::upslope::SurfaceWater::get_cell "Cell& -get_cell() const +%feature("docstring") cmf::river::SWATReachType::get_depth "virtual +double get_depth(double area) const -Get the cell of the surface. "; +Calculates the actual depth of the reach using the IChannel geometry -%feature("docstring") cmf::upslope::SurfaceWater::get_connections "cmf::water::connection_list get_connections() const "; -%feature("docstring") cmf::upslope::SurfaceWater::get_coverage "double get_coverage() const +.. math:: -Get surface coverage as a function of the actual volume. "; + d &=& \\\\sqrt{\\\\frac{A}{\\\\Delta_{bank}} + + \\\\frac{{w_{bottom}}^2}{4 {\\\\Delta_{bank}}^2}} - + \\\\frac{w_{bottom}}{2 \\\\Delta_{bank}} \\\\\\\\ \\\\mbox{If } + d>d_{IChannel} &&\\\\\\\\ + d&=&d_{IChannel}+\\\\sqrt{\\\\frac{A-A(d_{IChannel})}{\\\\Delta_{flood\\\\ + plain}} + \\\\frac{{w(d_{IChannel})}^2}{4 {\\\\Delta_{flood\\\\ + plain}}^2}} - \\\\frac{w(d_{IChannel})}{2 \\\\Delta_{flood\\\\ plain}} + \\\\\\\\ -%feature("docstring") cmf::upslope::SurfaceWater::get_depth "real -get_depth() const +. -Returns the water table depth. "; +See: SWATtheoDoc eq. 7:1.2.4 -%feature("docstring") cmf::upslope::SurfaceWater::get_height_function -"virtual const cmf::river::Prism& get_height_function() const +get_depth of the reach [m] -Gets the height function (a cmf::river::Prism) for further reference. -"; +Parameters: +----------- -%feature("docstring") cmf::upslope::SurfaceWater::get_nManning "real -get_nManning() const +area: Wetted area of a river cross section [m2], can be obtained by +V/l, where V is the stored volume and l is the reach length "; -get Manning roughness (n) of the surface +%feature("docstring") cmf::river::SWATReachType::get_flux_crossection +"virtual double get_flux_crossection(double depth) const -From Python use this as a property: "; +Calculates the wetted area from a given depth using the IChannel +geometry. -%feature("docstring") cmf::upslope::SurfaceWater::get_potential "virtual real get_potential() const +In most cases use get_flux_crossection=V/l, where V is the stored +volume and l is the reach length -Returns the water potential of the node in m waterhead. +.. math:: -The base class water storage always returns the height of the location -"; + \\\\mbox{If } + d>d_{IChannel} &&\\\\\\\\ A &=& \\\\left(w_{bottom} + \\\\Delta_{bank} + d\\\\right) d \\\\\\\\ \\\\mbox{else, } && \\\\mbox{if the river + floods the flood plain} \\\\\\\\ A &=& A(d_{IChannel}) + + \\\\left(w(d_{IChannel} + \\\\Delta_{flood\\\\ plain} + \\\\left(d-d_{IChannel}\\\\right)\\\\right) (d-d_{IChannel}) \\\\\\\\ + -%feature("docstring") cmf::upslope::SurfaceWater::get_project "cmf::project& get_project() const + See: SWATtheoDoc eq. 7:1.1.4 -Returns the project, this node is part of. "; +Wetted area of a river cross section [m2] -%feature("docstring") cmf::upslope::SurfaceWater::get_puddledepth "real get_puddledepth() const +Parameters: +----------- -Get water depth at which runoff starts. +depth: Depth of the reach [m] "; -From Python use this as a property: "; +%feature("docstring") cmf::river::SWATReachType::get_length "double +get_length() const -%feature("docstring") cmf::upslope::SurfaceWater::get_state "real -get_state() const "; +Length of the reach. "; -%feature("docstring") -cmf::upslope::SurfaceWater::get_state_variable_content "char -get_state_variable_content() const +%feature("docstring") cmf::river::SWATReachType::get_nManning "virtual double get_nManning() const "; -A character indicating the integrated variable (either 'V' for Volume -or 'h' for head) "; +%feature("docstring") cmf::river::SWATReachType::get_wetted_perimeter +"virtual double get_wetted_perimeter(double depth) const -%feature("docstring") cmf::upslope::SurfaceWater::get_states "cmf::math::StateVariableList get_states() +Calculates the wetted perimeter from a given actual depth [m] using +the actual IChannel geometry -Add the state variables, owned by an object derived from -StateVariableOwner, to the given vector. "; +.. math:: -%feature("docstring") cmf::upslope::SurfaceWater::get_volume "virtual real get_volume() const + \\\\mbox{If } + d\\\\le d_{IChannel} && \\\\\\\\ P &=& w_{bottom} + 2 \\\\sqrt{1+ + {\\\\Delta_{bank}}^2} d \\\\\\\\ \\\\mbox{else, } && \\\\mbox{if the + river floods the flood plain} \\\\\\\\ P &=& P(d_{IChannel} + 2 + \\\\sqrt{1+ {\\\\Delta_{flood\\\\ plain}}^2} (d-d_{IChannel}) \\\\\\\\ + + +. + +See: SWATtheoDoc eq. 7:1.1.5 + +Parameters: +----------- -Returns the volume of water in this storage in m3 "; +depth: Actual depth of the reach [m] "; -%feature("docstring") cmf::upslope::SurfaceWater::is_storage "virtual bool is_storage() const +%feature("docstring") cmf::river::SWATReachType::h "virtual double +h(double V) const -Returns true, since this is a storage. "; +Returns the depth of a given volume. "; -%feature("docstring") cmf::upslope::SurfaceWater::remove_connection "bool remove_connection(cmf::water::flux_node::ptr To) +%feature("docstring") cmf::river::SWATReachType::q "virtual double +q(double h, double slope) const "; -Remove the connection. "; +%feature("docstring") cmf::river::SWATReachType::qManning "virtual +double qManning(double A, double slope) const -%feature("docstring") cmf::upslope::SurfaceWater::set_depth "void -set_depth(real new_depth) "; +Calculates the flow rate from a given water volume in the reach -%feature("docstring") cmf::upslope::SurfaceWater::set_height_function -"virtual void set_height_function(const -cmf::river::IVolumeHeightFunction &val) -Prevents the change of the height function. A SurfaceWater storage has -always a Prism height function. "; +.. math:: -%feature("docstring") cmf::upslope::SurfaceWater::set_nManning "void -set_nManning(real n) + q_{Manning}&=& A R^{\\\\frac 2 3} + \\\\sqrt{\\\\frac {\\\\Delta_z} n} \\\\\\\\ A &=& \\\\frac V l + \\\\mbox{, (Crosssectional area of the wetted crossection, Volume per + length)} \\\\\\\\ R &=& \\\\frac A {P(d)} \\\\\\\\ P(d) &=& \\\\mbox{ + the perimeter of the wetted crosssection, a function of reach depth} + \\\\\\\\ d(V) &=& \\\\mbox{ the depth of the reach a function of the + volume} \\\\\\\\ \\\\Delta_z &=& \\\\frac{z_{max} - z_{min}}{l} + \\\\mbox{ Slope of the reach} -set Manning roughness (n) of the surface +. -From Python use this as a property: "; +Flow rate [m3/s] -%feature("docstring") cmf::upslope::SurfaceWater::set_potential "virtual void set_potential(real newpotential) +Parameters: +----------- -Sets the potential of this flux node. "; +A: The area of the cross section [m2] -%feature("docstring") cmf::upslope::SurfaceWater::set_puddledepth "void set_puddledepth(real puddledepth) +slope: The slope of the reach [m/m] "; -Set water depth at which runoff starts. +%feature("docstring") cmf::river::SWATReachType::set_nManning "virtual void set_nManning(double nManning) "; -From Python use this as a property: "; +%feature("docstring") cmf::river::SWATReachType::typecode "char +typecode() const "; -%feature("docstring") cmf::upslope::SurfaceWater::set_state "void -set_state(real newState) "; +%feature("docstring") cmf::river::SWATReachType::V "virtual double +V(double h) const "; -%feature("docstring") -cmf::upslope::SurfaceWater::set_state_variable_content "void -set_state_variable_content(char content) -A character indicating the integrated variable (either 'V' for Volume -or 'h' for head) "; +// File: classcmf__core_1_1_swig_py_iterator.xml +%feature("docstring") cmf_core::SwigPyIterator " -%feature("docstring") cmf::upslope::SurfaceWater::set_volume "virtual void set_volume(real newwatercontent) +Proxy of C++ swig::SwigPyIterator class. "; -Sets the volume of water in this storage in m3 "; +%feature("docstring") cmf_core::SwigPyIterator::__init__ "def +__init__(self, args, kwargs) "; -%feature("docstring") cmf::upslope::SurfaceWater::Solute "SoluteStorage& Solute(const cmf::water::solute _Solute) +%feature("docstring") cmf_core::SwigPyIterator::__add__ "def +__add__(self, args, kwargs) -Returns the water quality of the water storage. "; +__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator "; -%feature("docstring") cmf::upslope::SurfaceWater::Solute "const -SoluteStorage& Solute(const cmf::water::solute _Solute) const "; +%feature("docstring") cmf_core::SwigPyIterator::__eq__ "def +__eq__(self, args, kwargs) -%feature("docstring") cmf::upslope::SurfaceWater::waterbalance "real -waterbalance(cmf::math::Time t, const flux_connection *Without=0) -const +__eq__(SwigPyIterator self, SwigPyIterator x) -> bool "; -Returns the sum of all fluxes (positive and negative) at time t. +%feature("docstring") cmf_core::SwigPyIterator::__iadd__ "def +__iadd__(self, args, kwargs) -Single fluxes can be excluded from the calculation +__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator "; -Parameters: ------------ +%feature("docstring") cmf_core::SwigPyIterator::__isub__ "def +__isub__(self, args, kwargs) -t: Time of the query +__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator "; -Without: A flux_connection that is excluded from the waterbalance -(e.g. to prevent closed circuits) "; +%feature("docstring") cmf_core::SwigPyIterator::__iter__ "def +__iter__(self) "; -%feature("docstring") cmf::upslope::SurfaceWater::wet_area "real -wet_area() const +%feature("docstring") cmf_core::SwigPyIterator::__ne__ "def +__ne__(self, args, kwargs) -Returns the exposed surface area in m2. "; +__ne__(SwigPyIterator self, SwigPyIterator x) -> bool "; +%feature("docstring") cmf_core::SwigPyIterator::__next__ "def +__next__(self, args, kwargs) -// File: classcmf_1_1upslope_1_1_e_t_1_1_s_w__evap__from__canopy.xml -%feature("docstring") cmf::upslope::ET::SW_evap_from_canopy " +__next__(SwigPyIterator self) -> PyObject * "; -Connection for Shuttleworth-Wallace canopy interception evaporation. +%feature("docstring") cmf_core::SwigPyIterator::__sub__ "def +__sub__(self, args) -C++ includes: ShuttleworthWallace.h "; +__sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator +__sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_canopy::SW_evap_from_canopy "SW_evap_from_canopy(cmf::water::WaterStorage::ptr source, -cmf::water::flux_node::ptr ET_target, ShuttleworthWallace::ptr owner) -"; +%feature("docstring") cmf_core::SwigPyIterator::advance "def +advance(self, args, kwargs) -%feature("docstring") cmf::upslope::ET::SW_evap_from_canopy::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) +advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator "; -Returns the concentration of the flux. +%feature("docstring") cmf_core::SwigPyIterator::copy "def copy(self, +args, kwargs) -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +copy(SwigPyIterator self) -> SwigPyIterator "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_canopy::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +%feature("docstring") cmf_core::SwigPyIterator::decr "def decr(self, +args, kwargs) -%feature("docstring") cmf::upslope::ET::SW_evap_from_canopy::get_ptr -"ptr get_ptr() const "; +decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_canopy::get_target "flux_node::ptr -get_target(const flux_node &inquirer) +%feature("docstring") cmf_core::SwigPyIterator::distance "def +distance(self, args, kwargs) -Returns the other end of a connection than the asking end. "; +distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_canopy::get_target "flux_node::ptr -get_target(int index) const +%feature("docstring") cmf_core::SwigPyIterator::equal "def +equal(self, args, kwargs) -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +equal(SwigPyIterator self, SwigPyIterator x) -> bool "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_canopy::get_tracer_filter "real -get_tracer_filter() +%feature("docstring") cmf_core::SwigPyIterator::incr "def incr(self, +args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. +incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::SwigPyIterator::next "def next(self, +args, kwargs) -%feature("docstring") -cmf::upslope::ET::SW_evap_from_canopy::get_tracer_filter "real -get_tracer_filter(solute S) +next(SwigPyIterator self) -> PyObject * "; -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +%feature("docstring") cmf_core::SwigPyIterator::previous "def +previous(self, args, kwargs) -%feature("docstring") cmf::upslope::ET::SW_evap_from_canopy::kill_me -"bool kill_me() +previous(SwigPyIterator self) -> PyObject * "; -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +%feature("docstring") cmf_core::SwigPyIterator::value "def +value(self, args, kwargs) -%feature("docstring") -cmf::upslope::ET::SW_evap_from_canopy::left_node "flux_node::ptr -left_node() const +value(SwigPyIterator self) -> PyObject * "; -Returns the left node of this connection. "; -%feature("docstring") cmf::upslope::ET::SW_evap_from_canopy::q "real -q(const flux_node &inquirer, cmf::math::Time t) +// File: classcmf__core_1_1_system_bridge.xml +%feature("docstring") cmf_core::SystemBridge " -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +A SystemBridge is an advanced feature for tuning of the calculation +time. A SystemBridge can be used to replace an existing connection +between nodes. It is created using the system_bridge function. After +installation, the two nodes can more safely be added to different +integrator systems. One node (called upper) is connected with the +system bridge with the connection formerly connecting the nodes, the +second node (called lower) is connected to the system bridge with as a +Neumann boundary condition. The flux equals the average flux of the +connection upper <-> SystemBridge. Therefore, the downward flux needs +to be integrated over time by the solver the upper node belongs to. +Use as an upper system (system upper node is belonging to) the faster +reacting system. For the connection between upper and SystemBridge, +the SystemBridge reacts as an Dirichlet boundary condition, providing +the potential of the lower node. The following example code creates a +system bridge between the nodes upper and lower. To integrate the flux +over each timestep automatically, the systembridge is added to the +solver of upper, as an integratable C++ includes: system_bridge.h "; -%feature("docstring") cmf::upslope::ET::SW_evap_from_canopy::refresh -"void refresh(cmf::math::Time t) +%feature("docstring") cmf_core::SystemBridge::__init__ "def +__init__(self, args, kwargs) "; -Performes a new calculation of the flux. "; +%feature("docstring") cmf_core::SystemBridge::__call__ "def +__call__(self, args, kwargs) -%feature("docstring") -cmf::upslope::ET::SW_evap_from_canopy::right_node "flux_node::ptr -right_node() const +__call__(flux_node self, Time t) -> real "; -returns the right node of this connection "; +%feature("docstring") cmf_core::SystemBridge::__eq__ "def +__eq__(self, args, kwargs) -%feature("docstring") -cmf::upslope::ET::SW_evap_from_canopy::set_tracer_filter "void -set_tracer_filter(real value) +__eq__(flux_node self, flux_node other) -> bool "; -A value ranging from 0 to 1 to filter tracers out of the water flux. +%feature("docstring") cmf_core::SystemBridge::__repr__ "def +__repr__(self) "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::SystemBridge::conc "def conc(self, +args, kwargs) -%feature("docstring") -cmf::upslope::ET::SW_evap_from_canopy::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; +conc(flux_node self, Time t, solute Solute) -> real virtual real +conc(cmf::math::Time t, const cmf::water::solute &Solute) const +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_canopy::short_string "virtual -std::string short_string() const "; +%feature("docstring") cmf_core::SystemBridge::connected_nodes "def +connected_nodes(self) "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_canopy::to_string "virtual std::string -to_string() const "; +%feature("docstring") cmf_core::SystemBridge::connection_to "def +connection_to(self, args, kwargs) +connection_to(flux_node self, flux_node target) -> flux_connection +cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) Returns the connection between this and target. "; -// File: classcmf_1_1upslope_1_1_e_t_1_1_s_w__evap__from__layer.xml -%feature("docstring") cmf::upslope::ET::SW_evap_from_layer " +%feature("docstring") cmf_core::SystemBridge::down_flux_integrator "def down_flux_integrator(self, args, kwargs) -Connection for Shuttleworth-Wallace ground evaporation. +down_flux_integrator(SystemBridge self) -> +cmf::water::flux_integrator::ptr flux_integrator::ptr +down_flux_integrator() const "; -C++ includes: ShuttleworthWallace.h "; +%feature("docstring") cmf_core::SystemBridge::flux3d_to "def +flux3d_to(self, args, kwargs) -%feature("docstring") -cmf::upslope::ET::SW_evap_from_layer::SW_evap_from_layer "SW_evap_from_layer(cmf::upslope::SoilLayer::ptr source, -cmf::water::flux_node::ptr ET_target, ShuttleworthWallace::ptr owner) -"; +flux3d_to(flux_node self, flux_node target, Time t) -> point +cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; -%feature("docstring") cmf::upslope::ET::SW_evap_from_layer::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) +%feature("docstring") cmf_core::SystemBridge::flux_to "def +flux_to(self, args, kwargs) -Returns the concentration of the flux. +flux_to(flux_node self, flux_node target, Time t) -> real real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +%feature("docstring") cmf_core::SystemBridge::fluxes "def +fluxes(self, t) "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_layer::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +%feature("docstring") cmf_core::SystemBridge::get_3d_flux "def +get_3d_flux(self, args, kwargs) -%feature("docstring") cmf::upslope::ET::SW_evap_from_layer::get_ptr "ptr get_ptr() const "; +get_3d_flux(flux_node self, Time t) -> point cmf::geometry::point +get_3d_flux(cmf::math::Time t) Returns the sum of all flux vectors. +"; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_layer::get_target "flux_node::ptr -get_target(const flux_node &inquirer) +%feature("docstring") cmf_core::SystemBridge::get_down_flux "def +get_down_flux(self, args, kwargs) -Returns the other end of a connection than the asking end. "; +get_down_flux(SystemBridge self) -> double double get_down_flux() +const Returns the currently integrated flux to the lower node. "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_layer::get_target "flux_node::ptr -get_target(int index) const +%feature("docstring") cmf_core::SystemBridge::get_lower_node "def +get_lower_node(self, args, kwargs) -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +get_lower_node(SystemBridge self) -> cmf::water::flux_node::ptr +flux_node::ptr get_lower_node() const Returns the lower node. "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_layer::get_tracer_filter "real -get_tracer_filter() +%feature("docstring") cmf_core::SystemBridge::get_upper_node "def +get_upper_node(self, args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. +get_upper_node(SystemBridge self) -> cmf::water::flux_node::ptr +flux_node::ptr get_upper_node() const Returns the upper node. "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::SystemBridge::is_empty "def +is_empty(self, args, kwargs) -%feature("docstring") -cmf::upslope::ET::SW_evap_from_layer::get_tracer_filter "real -get_tracer_filter(solute S) +is_empty(flux_node self) -> double virtual double is_empty() const +Returns true if the node has no water. "; -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +%feature("docstring") cmf_core::SystemBridge::is_storage "def +is_storage(self, args, kwargs) -%feature("docstring") cmf::upslope::ET::SW_evap_from_layer::kill_me "bool kill_me() +is_storage(flux_node self) -> bool virtual bool is_storage() const +true, if this is a waterstorage "; -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +%feature("docstring") cmf_core::SystemBridge::RecalcFluxes "def +RecalcFluxes(self, args, kwargs) -%feature("docstring") cmf::upslope::ET::SW_evap_from_layer::left_node -"flux_node::ptr left_node() const +RecalcFluxes(flux_node self, Time t) -> bool virtual bool +RecalcFluxes(cmf::math::Time t) Pure flux_nodes do not influence +fluxes, therefore no recalculation of fluxes is required by flux_node. +WaterStorage overrides this, since state changes require an update of +the fluxes "; -Returns the left node of this connection. "; +%feature("docstring") cmf_core::SystemBridge::remove_connection "def +remove_connection(self, args, kwargs) -%feature("docstring") cmf::upslope::ET::SW_evap_from_layer::q "real -q(const flux_node &inquirer, cmf::math::Time t) +remove_connection(flux_node self, cmf::water::flux_node::ptr To) -> +bool bool remove_connection(cmf::water::flux_node::ptr To) Remove +the connection. "; -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +%feature("docstring") cmf_core::SystemBridge::to_string "def +to_string(self, args, kwargs) -%feature("docstring") cmf::upslope::ET::SW_evap_from_layer::refresh "void refresh(cmf::math::Time t) +to_string(flux_node self) -> std::string virtual std::string +to_string() const "; -Performes a new calculation of the flux. "; +%feature("docstring") cmf_core::SystemBridge::waterbalance "def +waterbalance(self, args, kwargs) -%feature("docstring") -cmf::upslope::ET::SW_evap_from_layer::right_node "flux_node::ptr -right_node() const +waterbalance(flux_node self, Time t, flux_connection Without=None) -> +real real waterbalance(cmf::math::Time t, const flux_connection +*Without=0) const Returns the sum of all fluxes (positive and +negative) at time t. Single fluxes can be excluded from the +calculation Parameters: ----------- t: Time of the query Without: +A flux_connection that is excluded from the waterbalance (e.g. to +prevent closed circuits) "; -returns the right node of this connection "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_layer::set_tracer_filter "void -set_tracer_filter(real value) +// File: classcmf_1_1water_1_1_system_bridge.xml +%feature("docstring") cmf::water::SystemBridge " -A value ranging from 0 to 1 to filter tracers out of the water flux. +A SystemBridge is an advanced feature for tuning of the calculation +time. -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +A SystemBridge can be used to replace an existing connection between +nodes. It is created using the system_bridge function. After +installation, the two nodes can more safely be added to different +integrator systems. One node (called upper) is connected with the +system bridge with the connection formerly connecting the nodes, the +second node (called lower) is connected to the system bridge with as a +Neumann boundary condition. The flux equals the average flux of the +connection upper <-> SystemBridge. Therefore, the downward flux needs +to be integrated over time by the solver the upper node belongs to. +Use as an upper system (system upper node is belonging to) the faster +reacting system. For the connection between upper and SystemBridge, +the SystemBridge reacts as an Dirichlet boundary condition, providing +the potential of the lower node. -%feature("docstring") -cmf::upslope::ET::SW_evap_from_layer::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; +The following example code creates a system bridge between the nodes +upper and lower. To integrate the flux over each timestep +automatically, the systembridge is added to the solver of upper, as an +integratable -%feature("docstring") -cmf::upslope::ET::SW_evap_from_layer::short_string "virtual -std::string short_string() const "; +C++ includes: system_bridge.h "; -%feature("docstring") cmf::upslope::ET::SW_evap_from_layer::to_string -"virtual std::string to_string() const "; +%feature("docstring") cmf::water::SystemBridge::conc "virtual real +conc(cmf::math::Time t, const cmf::water::solute &Solute) const +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; -// File: classcmf_1_1upslope_1_1_e_t_1_1_s_w__evap__from__snow.xml -%feature("docstring") cmf::upslope::ET::SW_evap_from_snow " +%feature("docstring") cmf::water::SystemBridge::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) -Connection for Shuttleworth-Wallace canopy interception evaporation. +Returns the connection between this and target. "; -C++ includes: ShuttleworthWallace.h "; +%feature("docstring") cmf::water::SystemBridge::down_flux_integrator +"flux_integrator::ptr down_flux_integrator() const "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_snow::SW_evap_from_snow "SW_evap_from_snow(cmf::water::WaterStorage::ptr source, -cmf::water::flux_node::ptr ET_target, ShuttleworthWallace::ptr owner) -"; +%feature("docstring") cmf::water::SystemBridge::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; -%feature("docstring") cmf::upslope::ET::SW_evap_from_snow::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) +%feature("docstring") cmf::water::SystemBridge::flux_to "real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) -Returns the concentration of the flux. +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +%feature("docstring") cmf::water::SystemBridge::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) -%feature("docstring") -cmf::upslope::ET::SW_evap_from_snow::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +Returns the sum of all flux vectors. "; -%feature("docstring") cmf::upslope::ET::SW_evap_from_snow::get_ptr "ptr get_ptr() const "; +%feature("docstring") cmf::water::SystemBridge::get_connections "cmf::water::connection_list get_connections() const "; -%feature("docstring") cmf::upslope::ET::SW_evap_from_snow::get_target -"flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") cmf::water::SystemBridge::get_down_flux "double get_down_flux() const -Returns the other end of a connection than the asking end. "; +Returns the currently integrated flux to the lower node. "; -%feature("docstring") cmf::upslope::ET::SW_evap_from_snow::get_target -"flux_node::ptr get_target(int index) const +%feature("docstring") cmf::water::SystemBridge::get_lower_node "flux_node::ptr get_lower_node() const -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +Returns the lower node. "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_snow::get_tracer_filter "real -get_tracer_filter() +%feature("docstring") cmf::water::SystemBridge::get_potential "double get_potential() const -A value ranging from 0 to 1 to filter tracers out of the water flux. +Returns the water potential of the node in m waterhead. -1.0 is no filter and 0.0 means no solute is crossing this connection +The base class water storage always returns the height of the location "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_snow::get_tracer_filter "real -get_tracer_filter(solute S) - -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +%feature("docstring") cmf::water::SystemBridge::get_project "cmf::project& get_project() const -%feature("docstring") cmf::upslope::ET::SW_evap_from_snow::kill_me "bool kill_me() +Returns the project, this node is part of. "; -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +%feature("docstring") cmf::water::SystemBridge::get_upper_node "flux_node::ptr get_upper_node() const -%feature("docstring") cmf::upslope::ET::SW_evap_from_snow::left_node -"flux_node::ptr left_node() const +Returns the upper node. "; -Returns the left node of this connection. "; +%feature("docstring") cmf::water::SystemBridge::is_empty "virtual +double is_empty() const -%feature("docstring") cmf::upslope::ET::SW_evap_from_snow::q "real -q(const flux_node &inquirer, cmf::math::Time t) +Returns true if the node has no water. "; -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +%feature("docstring") cmf::water::SystemBridge::is_storage "virtual +bool is_storage() const -%feature("docstring") cmf::upslope::ET::SW_evap_from_snow::refresh "void refresh(cmf::math::Time t) +true, if this is a waterstorage "; -Performes a new calculation of the flux. "; +%feature("docstring") cmf::water::SystemBridge::RecalcFluxes "virtual bool RecalcFluxes(cmf::math::Time t) -%feature("docstring") cmf::upslope::ET::SW_evap_from_snow::right_node -"flux_node::ptr right_node() const +Pure flux_nodes do not influence fluxes, therefore no recalculation of +fluxes is required by flux_node. -returns the right node of this connection "; +WaterStorage overrides this, since state changes require an update of +the fluxes "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_snow::set_tracer_filter "void -set_tracer_filter(real value) +%feature("docstring") cmf::water::SystemBridge::remove_connection "bool remove_connection(cmf::water::flux_node::ptr To) -A value ranging from 0 to 1 to filter tracers out of the water flux. +Remove the connection. "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf::water::SystemBridge::set_potential "virtual void set_potential(real new_potential) -%feature("docstring") -cmf::upslope::ET::SW_evap_from_snow::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; +Sets the potential of this flux node. "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_snow::short_string "virtual -std::string short_string() const "; +%feature("docstring") cmf::water::SystemBridge::to_string "virtual +std::string to_string() const "; -%feature("docstring") cmf::upslope::ET::SW_evap_from_snow::to_string -"virtual std::string to_string() const "; +%feature("docstring") cmf::water::SystemBridge::waterbalance "real +waterbalance(cmf::math::Time t, const flux_connection *Without=0) +const +Returns the sum of all fluxes (positive and negative) at time t. -// File: classcmf_1_1upslope_1_1_e_t_1_1_s_w__evap__from__surfacewater.xml -%feature("docstring") cmf::upslope::ET::SW_evap_from_surfacewater " +Single fluxes can be excluded from the calculation -Connection for Shuttleworth-Wallace canopy interception evaporation. +Parameters: +----------- -C++ includes: ShuttleworthWallace.h "; +t: Time of the query -%feature("docstring") -cmf::upslope::ET::SW_evap_from_surfacewater::SW_evap_from_surfacewater -"SW_evap_from_surfacewater(cmf::river::OpenWaterStorage::ptr source, -cmf::water::flux_node::ptr ET_target, ShuttleworthWallace::ptr owner) -"; +Without: A flux_connection that is excluded from the waterbalance +(e.g. to prevent closed circuits) "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_surfacewater::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) -Returns the concentration of the flux. +// File: classcmf__core_1_1_system_bridge_connection.xml +%feature("docstring") cmf_core::SystemBridgeConnection " -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +Connects a system bridge with its lower node. Is created automatically +when creating a SystemBridge. C++ includes: system_bridge.h "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_surfacewater::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +%feature("docstring") cmf_core::SystemBridgeConnection::__init__ "def __init__(self, args, kwargs) "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_surfacewater::get_ptr "ptr get_ptr() -const "; +%feature("docstring") cmf_core::SystemBridgeConnection::__contains__ +"def __contains__(self, cmp) "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_surfacewater::get_target "flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") cmf_core::SystemBridgeConnection::__eq__ "def +__eq__(self, args, kwargs) -Returns the other end of a connection than the asking end. "; +__eq__(flux_connection self, flux_connection other) -> bool "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_surfacewater::get_target "flux_node::ptr get_target(int index) const +%feature("docstring") cmf_core::SystemBridgeConnection::__getitem__ "def __getitem__(self, index) "; -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +%feature("docstring") cmf_core::SystemBridgeConnection::__iter__ "def __iter__(self) "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_surfacewater::get_tracer_filter "real -get_tracer_filter() +%feature("docstring") cmf_core::SystemBridgeConnection::__repr__ "def __repr__(self) "; -A value ranging from 0 to 1 to filter tracers out of the water flux. +%feature("docstring") cmf_core::SystemBridgeConnection::conc "def +conc(self, args, kwargs) -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; %feature("docstring") -cmf::upslope::ET::SW_evap_from_surfacewater::get_tracer_filter "real -get_tracer_filter(solute S) +cmf_core::SystemBridgeConnection::exchange_target "def +exchange_target(self, args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_surfacewater::kill_me "bool kill_me() +%feature("docstring") cmf_core::SystemBridgeConnection::get_target "def get_target(self, args) -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; %feature("docstring") -cmf::upslope::ET::SW_evap_from_surfacewater::left_node "flux_node::ptr left_node() const +cmf_core::SystemBridgeConnection::get_tracer_filter "def +get_tracer_filter(self, args) -Returns the left node of this connection. "; +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -%feature("docstring") cmf::upslope::ET::SW_evap_from_surfacewater::q -"real q(const flux_node &inquirer, cmf::math::Time t) +%feature("docstring") cmf_core::SystemBridgeConnection::kill_me "def +kill_me(self, args, kwargs) -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_surfacewater::refresh "void -refresh(cmf::math::Time t) +%feature("docstring") cmf_core::SystemBridgeConnection::left_node "def left_node(self, args, kwargs) -Performes a new calculation of the flux. "; +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_surfacewater::right_node "flux_node::ptr right_node() const +%feature("docstring") cmf_core::SystemBridgeConnection::q "def +q(self, args, kwargs) -returns the right node of this connection "; +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_surfacewater::set_tracer_filter "void -set_tracer_filter(real value) +%feature("docstring") cmf_core::SystemBridgeConnection::refresh "def +refresh(self, args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::SystemBridgeConnection::right_node "def right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; %feature("docstring") -cmf::upslope::ET::SW_evap_from_surfacewater::set_tracer_filter "void +cmf_core::SystemBridgeConnection::set_tracer_filter "def +set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void set_tracer_filter(solute S, real value) "; -%feature("docstring") -cmf::upslope::ET::SW_evap_from_surfacewater::short_string "virtual -std::string short_string() const "; +%feature("docstring") cmf_core::SystemBridgeConnection::short_string +"def short_string(self, args, kwargs) -%feature("docstring") -cmf::upslope::ET::SW_evap_from_surfacewater::to_string "virtual -std::string to_string() const "; +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; +%feature("docstring") cmf_core::SystemBridgeConnection::to_string "def to_string(self, args, kwargs) -// File: classcmf_1_1upslope_1_1_e_t_1_1_s_w__transpiration.xml -%feature("docstring") cmf::upslope::ET::SW_transpiration " +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -Connection for Shuttleworth-Wallace transpiration. -C++ includes: ShuttleworthWallace.h "; +// File: classcmf_1_1water_1_1_system_bridge_connection.xml +%feature("docstring") cmf::water::SystemBridgeConnection " -%feature("docstring") -cmf::upslope::ET::SW_transpiration::SW_transpiration "SW_transpiration(cmf::upslope::SoilLayer::ptr source, -cmf::water::flux_node::ptr ET_target, ShuttleworthWallace::ptr owner) -"; +Connects a system bridge with its lower node. Is created automatically +when creating a SystemBridge. -%feature("docstring") cmf::upslope::ET::SW_transpiration::conc "real +C++ includes: system_bridge.h "; + +%feature("docstring") cmf::water::SystemBridgeConnection::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns the concentration of the flux. @@ -15325,24 +33830,24 @@ If not overridden, it returns the concentration of the source of the flux (direction depending) "; %feature("docstring") -cmf::upslope::ET::SW_transpiration::exchange_target "void +cmf::water::SystemBridgeConnection::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -%feature("docstring") cmf::upslope::ET::SW_transpiration::get_ptr "ptr get_ptr() const "; +%feature("docstring") cmf::water::SystemBridgeConnection::get_ptr "ptr get_ptr() const "; -%feature("docstring") cmf::upslope::ET::SW_transpiration::get_target +%feature("docstring") cmf::water::SystemBridgeConnection::get_target "flux_node::ptr get_target(const flux_node &inquirer) Returns the other end of a connection than the asking end. "; -%feature("docstring") cmf::upslope::ET::SW_transpiration::get_target +%feature("docstring") cmf::water::SystemBridgeConnection::get_target "flux_node::ptr get_target(int index) const With index 0, the left node is returned, with index 1 the right node of the connection. "; %feature("docstring") -cmf::upslope::ET::SW_transpiration::get_tracer_filter "real +cmf::water::SystemBridgeConnection::get_tracer_filter "real get_tracer_filter() A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -15351,38 +33856,38 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::ET::SW_transpiration::get_tracer_filter "real +cmf::water::SystemBridgeConnection::get_tracer_filter "real get_tracer_filter(solute S) A value ranging from 0 to 1 to filter tracers out of the water flux. "; -%feature("docstring") cmf::upslope::ET::SW_transpiration::kill_me "bool kill_me() +%feature("docstring") cmf::water::SystemBridgeConnection::kill_me "bool kill_me() Deregisters this connection from its nodes. Returns true if only one reference is left. "; -%feature("docstring") cmf::upslope::ET::SW_transpiration::left_node "flux_node::ptr left_node() const +%feature("docstring") cmf::water::SystemBridgeConnection::left_node "flux_node::ptr left_node() const Returns the left node of this connection. "; -%feature("docstring") cmf::upslope::ET::SW_transpiration::q "real +%feature("docstring") cmf::water::SystemBridgeConnection::q "real q(const flux_node &inquirer, cmf::math::Time t) Returns the current flux through a connection. Negative signs mean out of the inquirer, positive are inflows to the inquirer. "; -%feature("docstring") cmf::upslope::ET::SW_transpiration::refresh "void refresh(cmf::math::Time t) +%feature("docstring") cmf::water::SystemBridgeConnection::refresh "void refresh(cmf::math::Time t) Performes a new calculation of the flux. "; -%feature("docstring") cmf::upslope::ET::SW_transpiration::right_node +%feature("docstring") cmf::water::SystemBridgeConnection::right_node "flux_node::ptr right_node() const returns the right node of this connection "; %feature("docstring") -cmf::upslope::ET::SW_transpiration::set_tracer_filter "void +cmf::water::SystemBridgeConnection::set_tracer_filter "void set_tracer_filter(real value) A value ranging from 0 to 1 to filter tracers out of the water flux. @@ -15391,41 +33896,57 @@ A value ranging from 0 to 1 to filter tracers out of the water flux. "; %feature("docstring") -cmf::upslope::ET::SW_transpiration::set_tracer_filter "void +cmf::water::SystemBridgeConnection::set_tracer_filter "void set_tracer_filter(solute S, real value) "; -%feature("docstring") -cmf::upslope::ET::SW_transpiration::short_string "virtual std::string -short_string() const "; +%feature("docstring") +cmf::water::SystemBridgeConnection::short_string "virtual std::string +short_string() const "; + +%feature("docstring") cmf::water::SystemBridgeConnection::to_string "virtual std::string to_string() const "; + + +// File: classcmf_1_1water_1_1_technical_flux.xml +%feature("docstring") cmf::water::TechnicalFlux " + +Produces a constant but changeable flux from a source to a target, if +enough water is present in the source. + -%feature("docstring") cmf::upslope::ET::SW_transpiration::to_string "virtual std::string to_string() const "; +.. math:: -// File: classcmf_1_1upslope_1_1connections_1_1_s_w_a_t_percolation.xml -%feature("docstring") cmf::upslope::connections::SWATPercolation " + q=\\\\begin{cases}0 & V_{source}\\\\le V_{min}\\\\\\\\ q_0 + \\\\frac{V_{source} - V_{min}}{t_{decr} q_{0} - V_{min}} & V_{source} + \\\\le t_{decr} q_{0}\\\\\\\\ q_{0} & \\\\end{cases} -A tipping bucket percolation approach similar to the approach in SWAT. +This is similar to a neumann boundary, however this is not a boundary +condition, but water is taken from the source (left) water storage and +limited by that water storage. +C++ includes: simple_connections.h "; +%feature("docstring") cmf::water::TechnicalFlux::TechnicalFlux "TechnicalFlux(cmf::water::WaterStorage::ptr source, +cmf::water::flux_node::ptr target, real maximum_flux, real +minimal_state=0, cmf::math::Time flux_decrease_time=cmf::math::h) -.. math:: +Produces a constant but changeable flux from a source to a target, if +enough water is present in the source. - q_{perc} &=& - V_{H_2O,drain}\\\\left(1-e^{-\\\\frac 1{-TT_{perc}}}\\\\right) - \\\\\\\\ TT_{perc} &=& \\\\frac{V_{pores,drain} - V_{field - cap.}}{K_{sat}} \\\\\\\\ V_{x,drain} &=& V_{x,drain} - V_{field cap.} - +Parameters: +----------- +source: The source of the water +target: The target of the water -C++ includes: Percolation.h "; +maximum_flux: The requested flux :math:`q_{0}` -%feature("docstring") -cmf::upslope::connections::SWATPercolation::SWATPercolation "SWATPercolation(cmf::upslope::SoilLayer::ptr upperLayer, -cmf::upslope::SoilLayer::ptr lowerLayer) "; +minimal_state: Minimal volume of stored water in source -%feature("docstring") -cmf::upslope::connections::SWATPercolation::conc "real +flux_decrease_time: ( cmf::math::Time) "; + +%feature("docstring") cmf::water::TechnicalFlux::conc "real conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns the concentration of the flux. @@ -15433,763 +33954,937 @@ Returns the concentration of the flux. If not overridden, it returns the concentration of the source of the flux (direction depending) "; -%feature("docstring") -cmf::upslope::connections::SWATPercolation::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +%feature("docstring") cmf::water::TechnicalFlux::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr +newTarget) "; -%feature("docstring") -cmf::upslope::connections::SWATPercolation::get_ptr "ptr get_ptr() -const "; +%feature("docstring") cmf::water::TechnicalFlux::get_ptr "ptr +get_ptr() const "; -%feature("docstring") -cmf::upslope::connections::SWATPercolation::get_target "flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") cmf::water::TechnicalFlux::get_target "flux_node::ptr get_target(const flux_node &inquirer) Returns the other end of a connection than the asking end. "; -%feature("docstring") -cmf::upslope::connections::SWATPercolation::get_target "flux_node::ptr get_target(int index) const +%feature("docstring") cmf::water::TechnicalFlux::get_target "flux_node::ptr get_target(int index) const With index 0, the left node is returned, with index 1 the right node of the connection. "; -%feature("docstring") -cmf::upslope::connections::SWATPercolation::get_tracer_filter "real -get_tracer_filter() +%feature("docstring") cmf::water::TechnicalFlux::get_tracer_filter "real get_tracer_filter() A value ranging from 0 to 1 to filter tracers out of the water flux. 1.0 is no filter and 0.0 means no solute is crossing this connection "; -%feature("docstring") -cmf::upslope::connections::SWATPercolation::get_tracer_filter "real -get_tracer_filter(solute S) +%feature("docstring") cmf::water::TechnicalFlux::get_tracer_filter "real get_tracer_filter(solute S) A value ranging from 0 to 1 to filter tracers out of the water flux. "; -%feature("docstring") -cmf::upslope::connections::SWATPercolation::kill_me "bool kill_me() +%feature("docstring") cmf::water::TechnicalFlux::kill_me "bool +kill_me() Deregisters this connection from its nodes. Returns true if only one reference is left. "; -%feature("docstring") -cmf::upslope::connections::SWATPercolation::left_node "flux_node::ptr -left_node() const +%feature("docstring") cmf::water::TechnicalFlux::left_node "flux_node::ptr left_node() const Returns the left node of this connection. "; -%feature("docstring") cmf::upslope::connections::SWATPercolation::q "real q(const flux_node &inquirer, cmf::math::Time t) +%feature("docstring") cmf::water::TechnicalFlux::q "real q(const +flux_node &inquirer, cmf::math::Time t) Returns the current flux through a connection. Negative signs mean out of the inquirer, positive are inflows to the inquirer. "; -%feature("docstring") -cmf::upslope::connections::SWATPercolation::refresh "void +%feature("docstring") cmf::water::TechnicalFlux::refresh "void refresh(cmf::math::Time t) Performes a new calculation of the flux. "; -%feature("docstring") -cmf::upslope::connections::SWATPercolation::right_node "flux_node::ptr right_node() const +%feature("docstring") cmf::water::TechnicalFlux::right_node "flux_node::ptr right_node() const returns the right node of this connection "; -%feature("docstring") -cmf::upslope::connections::SWATPercolation::set_tracer_filter "void -set_tracer_filter(real value) +%feature("docstring") cmf::water::TechnicalFlux::set_tracer_filter "void set_tracer_filter(real value) A value ranging from 0 to 1 to filter tracers out of the water flux. 1.0 is no filter and 0.0 means no solute is crossing this connection "; -%feature("docstring") -cmf::upslope::connections::SWATPercolation::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; +%feature("docstring") cmf::water::TechnicalFlux::set_tracer_filter "void set_tracer_filter(solute S, real value) "; -%feature("docstring") -cmf::upslope::connections::SWATPercolation::short_string "virtual -std::string short_string() const "; +%feature("docstring") cmf::water::TechnicalFlux::short_string "virtual std::string short_string() const "; -%feature("docstring") -cmf::upslope::connections::SWATPercolation::to_string "virtual +%feature("docstring") cmf::water::TechnicalFlux::to_string "virtual std::string to_string() const "; -// File: classcmf_1_1river_1_1_s_w_a_t_reach_type.xml -%feature("docstring") cmf::river::SWATReachType " +// File: classcmf__core_1_1_technical_flux.xml +%feature("docstring") cmf_core::TechnicalFlux " -Structure for the description of structural parameters of a reach. +Produces a constant but changeable flux from a source to a target, if +enough water is present in the source. .. math:: +q=\\\\\\\\begin{cases}0 & V_{source}\\\\\\\\le V_{min}\\\\\\\\\\\\\\\\ +q_0 \\\\\\\\frac{V_{source} - V_{min}}{t_{decr} q_{0} - V_{min}} & +V_{source} \\\\\\\\le t_{decr} q_{0}\\\\\\\\\\\\\\\\ q_{0} & +\\\\\\\\end{cases} This is similar to a neumann boundary, however +this is not a boundary condition, but water is taken from the source +(left) water storage and limited by that water storage. C++ includes: +simple_connections.h "; + +%feature("docstring") cmf_core::TechnicalFlux::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::water::TechnicalFlux self, cmf::water::WaterStorage::ptr +source, cmf::water::flux_node::ptr target, real maximum_flux, real +minimal_state=0, Time flux_decrease_time) -> TechnicalFlux +TechnicalFlux(cmf::water::WaterStorage::ptr source, +cmf::water::flux_node::ptr target, real maximum_flux, real +minimal_state=0, cmf::math::Time flux_decrease_time=cmf::math::h) +Produces a constant but changeable flux from a source to a target, if +enough water is present in the source. Parameters: ----------- +source: The source of the water target: The target of the water +maximum_flux: The requested flux :math:`q_{0}` minimal_state: +Minimal volume of stored water in source flux_decrease_time: ( +cmf::math::Time) "; -Uses the SWAT IChannel geometry (see SWAT Theoretical Documentation, -Version 2005 (ch. 7:1.1), Neitsch et al. 2005), in this class -referenced as SWATtheoDoc. Differences to the SWAT geometry: The flood -plain is not plain, but has a small slope=0.5%, but has an infinite -width +%feature("docstring") cmf_core::TechnicalFlux::__contains__ "def +__contains__(self, cmp) "; -C++ includes: ReachType.h "; +%feature("docstring") cmf_core::TechnicalFlux::__eq__ "def +__eq__(self, args, kwargs) -%feature("docstring") cmf::river::SWATReachType::SWATReachType "SWATReachType(const SWATReachType ©) "; +__eq__(flux_connection self, flux_connection other) -> bool "; -%feature("docstring") cmf::river::SWATReachType::SWATReachType "SWATReachType(double l) +%feature("docstring") cmf_core::TechnicalFlux::__getitem__ "def +__getitem__(self, index) "; -Creates a new reach structure with standard values (small natural -river) BottomWidth = 3m, ChannelDepth = 0.5m, BankSlope = 2, nManning -= 0.0035, FloodPlainSlope = 200. "; +%feature("docstring") cmf_core::TechnicalFlux::__iter__ "def +__iter__(self) "; -%feature("docstring") cmf::river::SWATReachType::SWATReachType "SWATReachType(double l, double BankWidth, double Depth) +%feature("docstring") cmf_core::TechnicalFlux::__repr__ "def +__repr__(self) "; -Creates a new reach structure from a give width and depth. +%feature("docstring") cmf_core::TechnicalFlux::conc "def conc(self, +args, kwargs) -Parameters: ------------ +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; -l: length of the channel [m] +%feature("docstring") cmf_core::TechnicalFlux::exchange_target "def +exchange_target(self, args, kwargs) -BankWidth: get_channel_width of the reach from bank to bank [m] +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; -Depth: Depth of the reach [m] "; +%feature("docstring") cmf_core::TechnicalFlux::get_target "def +get_target(self, args) -%feature("docstring") cmf::river::SWATReachType::~SWATReachType "virtual ~SWATReachType() "; +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; -%feature("docstring") cmf::river::SWATReachType::A "virtual double -A(double V) const +%feature("docstring") cmf_core::TechnicalFlux::get_tracer_filter "def get_tracer_filter(self, args) -Returns the area of the surface for a given volume. "; +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; -%feature("docstring") cmf::river::SWATReachType::copy "SWATReachType* copy() const "; +%feature("docstring") cmf_core::TechnicalFlux::kill_me "def +kill_me(self, args, kwargs) -%feature("docstring") cmf::river::SWATReachType::get_channel_width "virtual double get_channel_width(double depth) const +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; -Calculates the flow width from a given actual depth [m] using the -actual IChannel geometry +%feature("docstring") cmf_core::TechnicalFlux::left_node "def +left_node(self, args, kwargs) -.. math:: +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; - \\\\mbox{If } d\\\\le - d_{IChannel} && \\\\\\\\ w &=& w_{bottom} + 2 \\\\Delta_{bank} d - \\\\\\\\ \\\\mbox{else, } && \\\\mbox{if the river floods the flood - plain} \\\\\\\\ w &=& w_{bank} + 2 \\\\Delta_{Floodplain} - (d-d_{IChannel} \\\\\\\\ +%feature("docstring") cmf_core::TechnicalFlux::q "def q(self, args, +kwargs) -. +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; -See: SWATtheoDoc eq. 7:1.1.3 "; +%feature("docstring") cmf_core::TechnicalFlux::refresh "def +refresh(self, args, kwargs) -%feature("docstring") cmf::river::SWATReachType::get_depth "virtual -double get_depth(double area) const +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; -Calculates the actual depth of the reach using the IChannel geometry +%feature("docstring") cmf_core::TechnicalFlux::right_node "def +right_node(self, args, kwargs) +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; -.. math:: +%feature("docstring") cmf_core::TechnicalFlux::set_tracer_filter "def set_tracer_filter(self, args) - d &=& \\\\sqrt{\\\\frac{A}{\\\\Delta_{bank}} + - \\\\frac{{w_{bottom}}^2}{4 {\\\\Delta_{bank}}^2}} - - \\\\frac{w_{bottom}}{2 \\\\Delta_{bank}} \\\\\\\\ \\\\mbox{If } - d>d_{IChannel} &&\\\\\\\\ - d&=&d_{IChannel}+\\\\sqrt{\\\\frac{A-A(d_{IChannel})}{\\\\Delta_{flood\\\\ - plain}} + \\\\frac{{w(d_{IChannel})}^2}{4 {\\\\Delta_{flood\\\\ - plain}}^2}} - \\\\frac{w(d_{IChannel})}{2 \\\\Delta_{flood\\\\ plain}} - \\\\\\\\ +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; -. +%feature("docstring") cmf_core::TechnicalFlux::short_string "def +short_string(self, args, kwargs) -See: SWATtheoDoc eq. 7:1.2.4 +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; -get_depth of the reach [m] +%feature("docstring") cmf_core::TechnicalFlux::to_string "def +to_string(self, args, kwargs) -Parameters: ------------ +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; -area: Wetted area of a river cross section [m2], can be obtained by -V/l, where V is the stored volume and l is the reach length "; -%feature("docstring") cmf::river::SWATReachType::get_flux_crossection -"virtual double get_flux_crossection(double depth) const +// File: classcmf_1_1math_1_1_time.xml +%feature("docstring") cmf::math::Time " -Calculates the wetted area from a given depth using the IChannel -geometry. +A time class, used to pass around current modelling times. -In most cases use get_flux_crossection=V/l, where V is the stored -volume and l is the reach length +Timespans and dates in cmf are used with a special object, called +Time. An extra class has the advantage, that the user does not have to +remember, which unit of time he or she uses or what time unit is +accepted by a specific function of the model. Arithmetic and boolean +operators are supported by Time. Internally the time classes stores +the time as integer milliseconds, therefore rounding issues will only +appear at very small time ranges. Absolute time (like dates) are +represented as milliseconds gone by from Dec, 31st 1899. Microsoft +Excel dates are represented as days from that time, using floating +point numbers, therefore it is very simple to convert Excel time +representations to cmf time. -.. math:: +Another object is Date, which is doesn't provide the operators, but +has a nice printed version and some special date functions, like day +of year (DOY) and provides access to the current hour of day and so +on, which only applyto dates and not to time spans. You can convert +Time to Date an vice versa. The printing is not culture aware and uses +the European representation. If you use the Python standard library +datetime, conversion between Python time and cmf time is possible - \\\\mbox{If } - d>d_{IChannel} &&\\\\\\\\ A &=& \\\\left(w_{bottom} + \\\\Delta_{bank} - d\\\\right) d \\\\\\\\ \\\\mbox{else, } && \\\\mbox{if the river - floods the flood plain} \\\\\\\\ A &=& A(d_{IChannel}) + - \\\\left(w(d_{IChannel} + \\\\Delta_{flood\\\\ plain} - \\\\left(d-d_{IChannel}\\\\right)\\\\right) (d-d_{IChannel}) \\\\\\\\ - +Creating absolute time values (dates) Creating time spans - See: SWATtheoDoc eq. 7:1.1.4 +In principle, there are three ways to create time spans. One is to use +one of the static functions, another is to multiply an existing time +span (like one of the build in constants) or to substrate two absolute +times. -Wetted area of a river cross section [m2] +Available constants : 4.1 seconds + +: 2.3 hours (138 min) + +: 2.3 hours (138 min) + +: 60 hours (2.5 days) + +: 7 days + +: 365/12 days (30.4167 days) + +: 365 days + +Available operators: + +time + time = time, time - time = time + +time * float = time ,time / float = time + +time/time=float + +>, <, ==, != + +Conversions + +Converting to python datetime + +Converting to numbers + +t.AsMilliseconds() + +t.AsSeconds() + +t.AsMinutes() + +t.AsHours() + +t.AsDays() + +t.AsYears() + +Creating time ranges + +C++ includes: time.h "; + +/* Constructors */ + +%feature("docstring") cmf::math::Time::Time "Time(int day, int +month, int year, int hour=0, int minute=0, int second=0, int ms=0) -Parameters: ------------ +Construction from date and stores the time as Excel-Time (0 = +31.12.1899 0:00:00) "; -depth: Depth of the reach [m] "; +%feature("docstring") cmf::math::Time::Time "Time(Date date) -%feature("docstring") cmf::river::SWATReachType::get_length "double -get_length() const +Conversion constructor. "; -Length of the reach. "; +%feature("docstring") cmf::math::Time::Time "Time(const Time &t) -%feature("docstring") cmf::river::SWATReachType::get_nManning "virtual double get_nManning() const "; +Copy constructor. "; -%feature("docstring") cmf::river::SWATReachType::get_wetted_perimeter -"virtual double get_wetted_perimeter(double depth) const +%feature("docstring") cmf::math::Time::Time "Time() -Calculates the wetted perimeter from a given actual depth [m] using -the actual IChannel geometry +Standard constructor. "; -.. math:: +%feature("docstring") cmf::math::Time::Time "Time(long long +milliseconds) "; - \\\\mbox{If } - d\\\\le d_{IChannel} && \\\\\\\\ P &=& w_{bottom} + 2 \\\\sqrt{1+ - {\\\\Delta_{bank}}^2} d \\\\\\\\ \\\\mbox{else, } && \\\\mbox{if the - river floods the flood plain} \\\\\\\\ P &=& P(d_{IChannel} + 2 - \\\\sqrt{1+ {\\\\Delta_{flood\\\\ plain}}^2} (d-d_{IChannel}) \\\\\\\\ - +/* Time unit conversion */ -. +%feature("docstring") cmf::math::Time::AsDays "double AsDays() const -See: SWATtheoDoc eq. 7:1.1.5 +Time in days. "; -Parameters: ------------ +%feature("docstring") cmf::math::Time::AsHours "double AsHours() +const -depth: Actual depth of the reach [m] "; +Time in hours. "; -%feature("docstring") cmf::river::SWATReachType::h "virtual double -h(double V) const +%feature("docstring") cmf::math::Time::AsMinutes "double AsMinutes() +const -Returns the depth of a given volume. "; +Time in minutes. "; -%feature("docstring") cmf::river::SWATReachType::q "virtual double -q(double h, double slope) const "; +%feature("docstring") cmf::math::Time::AsSeconds "double AsSeconds() +const -%feature("docstring") cmf::river::SWATReachType::qManning "virtual -double qManning(double A, double slope) const +Time in seconds. "; -Calculates the flow rate from a given water volume in the reach +%feature("docstring") cmf::math::Time::AsMilliseconds "long long +AsMilliseconds() const +Time in milliseconds. "; -.. math:: +%feature("docstring") cmf::math::Time::AsDate "Date AsDate() const +"; - q_{Manning}&=& A R^{\\\\frac 2 3} - \\\\sqrt{\\\\frac {\\\\Delta_z} n} \\\\\\\\ A &=& \\\\frac V l - \\\\mbox{, (Crosssectional area of the wetted crossection, Volume per - length)} \\\\\\\\ R &=& \\\\frac A {P(d)} \\\\\\\\ P(d) &=& \\\\mbox{ - the perimeter of the wetted crosssection, a function of reach depth} - \\\\\\\\ d(V) &=& \\\\mbox{ the depth of the reach a function of the - volume} \\\\\\\\ \\\\Delta_z &=& \\\\frac{z_{max} - z_{min}}{l} - \\\\mbox{ Slope of the reach} +%feature("docstring") cmf::math::Time::to_string "std::string +to_string(char seperator=':') "; -. +%feature("docstring") cmf::math::Time::is_not_0 "bool is_not_0() +const "; -Flow rate [m3/s] +%feature("docstring") cmf::math::Time::DOY "double DOY() const "; -Parameters: ------------ +/* Arithmetic operators */ -A: The area of the cross section [m2] +%feature("docstring") cmf::math::Time::times_in "long long +times_in(const Time &t1) const -slope: The slope of the reach [m/m] "; +Returns the number of times this is included in t1. "; -%feature("docstring") cmf::river::SWATReachType::set_nManning "virtual void set_nManning(double nManning) "; +/* Boolean Operators */ -%feature("docstring") cmf::river::SWATReachType::typecode "char -typecode() const "; -%feature("docstring") cmf::river::SWATReachType::V "virtual double -V(double h) const "; +// File: classcmf__core_1_1_time.xml +%feature("docstring") cmf_core::Time " +A time class, used to pass around current modelling times. Timespans +and dates in cmf are used with a special object, called Time. An extra +class has the advantage, that the user does not have to remember, +which unit of time he or she uses or what time unit is accepted by a +specific function of the model. Arithmetic and boolean operators are +supported by Time. Internally the time classes stores the time as +integer milliseconds, therefore rounding issues will only appear at +very small time ranges. Absolute time (like dates) are represented as +milliseconds gone by from Dec, 31st 1899. Microsoft Excel dates are +represented as days from that time, using floating point numbers, +therefore it is very simple to convert Excel time representations to +cmf time. Another object is Date, which is doesn't provide the +operators, but has a nice printed version and some special date +functions, like day of year (DOY) and provides access to the current +hour of day and so on, which only applyto dates and not to time spans. +You can convert Time to Date an vice versa. The printing is not +culture aware and uses the European representation. If you use the +Python standard library datetime, conversion between Python time and +cmf time is possible Creating absolute time values (dates) Creating +time spans In principle, there are three ways to create time spans. +One is to use one of the static functions, another is to multiply an +existing time span (like one of the build in constants) or to +substrate two absolute times. Available constants : 4.1 seconds : +2.3 hours (138 min) : 2.3 hours (138 min) : 60 hours (2.5 days) : 7 +days : 365/12 days (30.4167 days) : 365 days Available operators: +time + time = time, time - time = time time * float = time ,time / +float = time time/time=float >, <, ==, != Conversions Converting +to python datetime Converting to numbers t.AsMilliseconds() +t.AsSeconds() t.AsMinutes() t.AsHours() t.AsDays() t.AsYears() +Creating time ranges C++ includes: time.h "; -// File: classcmf_1_1water_1_1_system_bridge.xml -%feature("docstring") cmf::water::SystemBridge " +%feature("docstring") cmf_core::Time::__init__ "def __init__(self, +args) -A SystemBridge is an advanced feature for tuning of the calculation -time. +__init__(cmf::math::Time self, int day, int month, int year, int +hour=0, int minute=0, int second=0, int ms=0) -> Time +__init__(cmf::math::Time self, Date date) -> Time +__init__(cmf::math::Time self, Time t) -> Time +__init__(cmf::math::Time self) -> Time __init__(cmf::math::Time self, +long long milliseconds) -> Time Time(long long milliseconds) "; -A SystemBridge can be used to replace an existing connection between -nodes. It is created using the system_bridge function. After -installation, the two nodes can more safely be added to different -integrator systems. One node (called upper) is connected with the -system bridge with the connection formerly connecting the nodes, the -second node (called lower) is connected to the system bridge with as a -Neumann boundary condition. The flux equals the average flux of the -connection upper <-> SystemBridge. Therefore, the downward flux needs -to be integrated over time by the solver the upper node belongs to. -Use as an upper system (system upper node is belonging to) the faster -reacting system. For the connection between upper and SystemBridge, -the SystemBridge reacts as an Dirichlet boundary condition, providing -the potential of the lower node. +%feature("docstring") cmf_core::Time::__add__ "def __add__(self, +args, kwargs) -The following example code creates a system bridge between the nodes -upper and lower. To integrate the flux over each timestep -automatically, the systembridge is added to the solver of upper, as an -integratable +__add__(Time self, Time t1) -> Time "; -C++ includes: system_bridge.h "; +%feature("docstring") cmf_core::Time::__eq__ "def __eq__(self, args, +kwargs) -%feature("docstring") cmf::water::SystemBridge::conc "virtual real -conc(cmf::math::Time t, const cmf::water::solute &Solute) const +__eq__(Time self, Time t1) -> bool "; -Returns the water quality of the flux_node, if it is not overridden -this is the mix of the incoming fluxes. "; +%feature("docstring") cmf_core::Time::__format__ "def +__format__(self, fmt) "; -%feature("docstring") cmf::water::SystemBridge::connection_to "cmf::water::flux_connection* connection_to(const cmf::water::flux_node -&target) +%feature("docstring") cmf_core::Time::__ge__ "def __ge__(self, args, +kwargs) -Returns the connection between this and target. "; +__ge__(Time self, Time t1) -> bool "; -%feature("docstring") cmf::water::SystemBridge::down_flux_integrator -"flux_integrator::ptr down_flux_integrator() const "; +%feature("docstring") cmf_core::Time::__getstate__ "def +__getstate__(self) "; -%feature("docstring") cmf::water::SystemBridge::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, -cmf::math::Time t) "; +%feature("docstring") cmf_core::Time::__gt__ "def __gt__(self, args, +kwargs) -%feature("docstring") cmf::water::SystemBridge::flux_to "real -flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +__gt__(Time self, Time t1) -> bool "; -Returns the actual flux between this and target (positive sign means -\"from this into target\") "; +%feature("docstring") cmf_core::Time::__iadd__ "def __iadd__(self, +args, kwargs) -%feature("docstring") cmf::water::SystemBridge::get_3d_flux "cmf::geometry::point get_3d_flux(cmf::math::Time t) +__iadd__(Time self, Time t1) -> Time "; -Returns the sum of all flux vectors. "; +%feature("docstring") cmf_core::Time::__imod__ "def __imod__(self, +args, kwargs) -%feature("docstring") cmf::water::SystemBridge::get_connections "cmf::water::connection_list get_connections() const "; +__imod__(Time self, Time t1) -> Time "; -%feature("docstring") cmf::water::SystemBridge::get_down_flux "double get_down_flux() const +%feature("docstring") cmf_core::Time::__imul__ "def __imul__(self, +args) -Returns the currently integrated flux to the lower node. "; +__imul__(Time self, double x) -> Time __imul__(Time self, long long x) +-> Time __imul__(Time self, int x) -> Time "; -%feature("docstring") cmf::water::SystemBridge::get_lower_node "flux_node::ptr get_lower_node() const +%feature("docstring") cmf_core::Time::__isub__ "def __isub__(self, +args, kwargs) -Returns the lower node. "; +__isub__(Time self, Time t1) -> Time "; -%feature("docstring") cmf::water::SystemBridge::get_potential "double get_potential() const +%feature("docstring") cmf_core::Time::__itruediv__ "def +__itruediv__(self, args) "; -Returns the water potential of the node in m waterhead. +%feature("docstring") cmf_core::Time::__le__ "def __le__(self, args, +kwargs) -The base class water storage always returns the height of the location -"; +__le__(Time self, Time t1) -> bool "; -%feature("docstring") cmf::water::SystemBridge::get_project "cmf::project& get_project() const +%feature("docstring") cmf_core::Time::__lt__ "def __lt__(self, args, +kwargs) -Returns the project, this node is part of. "; +__lt__(Time self, Time t1) -> bool "; -%feature("docstring") cmf::water::SystemBridge::get_upper_node "flux_node::ptr get_upper_node() const +%feature("docstring") cmf_core::Time::__mod__ "def __mod__(self, +args, kwargs) -Returns the upper node. "; +__mod__(Time self, Time t1) -> Time "; -%feature("docstring") cmf::water::SystemBridge::is_empty "virtual -double is_empty() const +%feature("docstring") cmf_core::Time::__mul__ "def __mul__(self, +args) -Returns true if the node has no water. "; +__mul__(Time self, double x) -> Time __mul__(Time self, long long x) +-> Time __mul__(Time self, int x) -> Time "; -%feature("docstring") cmf::water::SystemBridge::is_storage "virtual -bool is_storage() const +%feature("docstring") cmf_core::Time::__ne__ "def __ne__(self, args, +kwargs) -true, if this is a waterstorage "; +__ne__(Time self, Time t1) -> bool "; -%feature("docstring") cmf::water::SystemBridge::RecalcFluxes "virtual bool RecalcFluxes(cmf::math::Time t) +%feature("docstring") cmf_core::Time::__nonzero__ "def +__nonzero__(self) "; -Pure flux_nodes do not influence fluxes, therefore no recalculation of -fluxes is required by flux_node. +%feature("docstring") cmf_core::Time::__radd__ "def __radd__(self, +other) "; -WaterStorage overrides this, since state changes require an update of -the fluxes "; +%feature("docstring") cmf_core::Time::__repr__ "def __repr__(self) +"; -%feature("docstring") cmf::water::SystemBridge::remove_connection "bool remove_connection(cmf::water::flux_node::ptr To) +%feature("docstring") cmf_core::Time::__rmul__ "def __rmul__(self, +other) "; -Remove the connection. "; +%feature("docstring") cmf_core::Time::__setstate__ "def +__setstate__(self, data) "; -%feature("docstring") cmf::water::SystemBridge::set_potential "virtual void set_potential(real new_potential) +%feature("docstring") cmf_core::Time::__sub__ "def __sub__(self, +args, kwargs) -Sets the potential of this flux node. "; +__sub__(Time self, Time t1) -> Time "; -%feature("docstring") cmf::water::SystemBridge::to_string "virtual -std::string to_string() const "; +%feature("docstring") cmf_core::Time::__truediv__ "def +__truediv__(self, args) "; -%feature("docstring") cmf::water::SystemBridge::waterbalance "real -waterbalance(cmf::math::Time t, const flux_connection *Without=0) -const +%feature("docstring") cmf_core::Time::as_datetime "def +as_datetime(self) "; -Returns the sum of all fluxes (positive and negative) at time t. +%feature("docstring") cmf_core::Time::as_timedelta "def +as_timedelta(self) "; -Single fluxes can be excluded from the calculation +%feature("docstring") cmf_core::Time::AsDate "def AsDate(self, args, +kwargs) -Parameters: ------------ +AsDate(Time self) -> Date Date AsDate() const "; -t: Time of the query +%feature("docstring") cmf_core::Time::AsDays "def AsDays(self, args, +kwargs) -Without: A flux_connection that is excluded from the waterbalance -(e.g. to prevent closed circuits) "; +AsDays(Time self) -> double double AsDays() const Time in days. "; +%feature("docstring") cmf_core::Time::AsHours "def AsHours(self, +args, kwargs) -// File: classcmf_1_1water_1_1_system_bridge_connection.xml -%feature("docstring") cmf::water::SystemBridgeConnection " +AsHours(Time self) -> double double AsHours() const Time in hours. +"; -Connects a system bridge with its lower node. Is created automatically -when creating a SystemBridge. +%feature("docstring") cmf_core::Time::AsMilliseconds "def +AsMilliseconds(self, args, kwargs) -C++ includes: system_bridge.h "; +AsMilliseconds(Time self) -> long long long long AsMilliseconds() +const Time in milliseconds. "; -%feature("docstring") cmf::water::SystemBridgeConnection::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +%feature("docstring") cmf_core::Time::AsMinutes "def AsMinutes(self, +args, kwargs) -Returns the concentration of the flux. +AsMinutes(Time self) -> double double AsMinutes() const Time in +minutes. "; -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +%feature("docstring") cmf_core::Time::AsPython "def AsPython(self) -%feature("docstring") -cmf::water::SystemBridgeConnection::exchange_target "void -exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; +Deprecated function name, use as_datetime as equivalent "; -%feature("docstring") cmf::water::SystemBridgeConnection::get_ptr "ptr get_ptr() const "; +%feature("docstring") cmf_core::Time::AsSeconds "def AsSeconds(self, +args, kwargs) -%feature("docstring") cmf::water::SystemBridgeConnection::get_target -"flux_node::ptr get_target(const flux_node &inquirer) +AsSeconds(Time self) -> double double AsSeconds() const Time in +seconds. "; -Returns the other end of a connection than the asking end. "; +%feature("docstring") cmf_core::Time::DOY "def DOY(self, args, +kwargs) -%feature("docstring") cmf::water::SystemBridgeConnection::get_target -"flux_node::ptr get_target(int index) const +DOY(Time self) -> double double DOY() const "; -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +%feature("docstring") cmf_core::Time::is_not_0 "def is_not_0(self, +args, kwargs) -%feature("docstring") -cmf::water::SystemBridgeConnection::get_tracer_filter "real -get_tracer_filter() +is_not_0(Time self) -> bool bool is_not_0() const "; -A value ranging from 0 to 1 to filter tracers out of the water flux. +%feature("docstring") cmf_core::Time::times_in "def times_in(self, +args, kwargs) -1.0 is no filter and 0.0 means no solute is crossing this connection +times_in(Time self, Time t1) -> long long long long times_in(const +Time &t1) const Returns the number of times this is included in t1. "; -%feature("docstring") -cmf::water::SystemBridgeConnection::get_tracer_filter "real -get_tracer_filter(solute S) +%feature("docstring") cmf_core::Time::to_string "def to_string(self, +args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +to_string(Time self, char seperator) -> std::string std::string +to_string(char seperator=':') "; -%feature("docstring") cmf::water::SystemBridgeConnection::kill_me "bool kill_me() -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +// File: classcmf__core_1_1timeseries.xml +%feature("docstring") cmf_core::timeseries " -%feature("docstring") cmf::water::SystemBridgeConnection::left_node "flux_node::ptr left_node() const +A timeseries is a list of values, equally distributed over time. To +create one, one have to provide as start date and a step size. The end +time is calculated from the number of values. Values queried for times +before the start time are returned as the first item, values after the +end time equal the last item. A timeseries with only one item reacts +like a scalar value. Creating a time series With this technique it +is simple to read files or databases to fill timeseries. Using a +timeseries C++ includes: timeseries.h "; -Returns the left node of this connection. "; +%feature("docstring") cmf_core::timeseries::__init__ "def +__init__(self, args, kwargs) -%feature("docstring") cmf::water::SystemBridgeConnection::q "real -q(const flux_node &inquirer, cmf::math::Time t) +__init__(cmf::math::timeseries self, Time begin, Time step, int +interpolationmethod=1, size_t count=0) -> timeseries timeseries(const +cmf::math::timeseries &ts) "; -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +%feature("docstring") cmf_core::timeseries::__add__ "def +__add__(self, args) -%feature("docstring") cmf::water::SystemBridgeConnection::refresh "void refresh(cmf::math::Time t) +__add__(timeseries self, timeseries arg2) -> timeseries +__add__(timeseries self, double arg2) -> timeseries "; -Performes a new calculation of the flux. "; +%feature("docstring") cmf_core::timeseries::__getitem__ "def +__getitem__(self, index) "; -%feature("docstring") cmf::water::SystemBridgeConnection::right_node -"flux_node::ptr right_node() const +%feature("docstring") cmf_core::timeseries::__getstate__ "def +__getstate__(self) "; -returns the right node of this connection "; +%feature("docstring") cmf_core::timeseries::__iadd__ "def +__iadd__(self, args) -%feature("docstring") -cmf::water::SystemBridgeConnection::set_tracer_filter "void -set_tracer_filter(real value) +__iadd__(timeseries self, timeseries arg2) -> timeseries +__iadd__(timeseries self, double arg2) -> timeseries "; -A value ranging from 0 to 1 to filter tracers out of the water flux. +%feature("docstring") cmf_core::timeseries::__imul__ "def +__imul__(self, args) -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +__imul__(timeseries self, timeseries arg2) -> timeseries +__imul__(timeseries self, double arg2) -> timeseries "; -%feature("docstring") -cmf::water::SystemBridgeConnection::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; +%feature("docstring") cmf_core::timeseries::__isub__ "def +__isub__(self, args) -%feature("docstring") -cmf::water::SystemBridgeConnection::short_string "virtual std::string -short_string() const "; +__isub__(timeseries self, timeseries arg2) -> timeseries +__isub__(timeseries self, double arg2) -> timeseries "; -%feature("docstring") cmf::water::SystemBridgeConnection::to_string "virtual std::string to_string() const "; +%feature("docstring") cmf_core::timeseries::__iter__ "def +__iter__(self) "; +%feature("docstring") cmf_core::timeseries::__itruediv__ "def +__itruediv__(self, args) "; -// File: classcmf_1_1water_1_1_technical_flux.xml -%feature("docstring") cmf::water::TechnicalFlux " +%feature("docstring") cmf_core::timeseries::__len__ "def +__len__(self, args, kwargs) -Produces a constant but changeable flux from a source to a target, if -enough water is present in the source. +__len__(timeseries self) -> ptrdiff_t "; +%feature("docstring") cmf_core::timeseries::__mul__ "def +__mul__(self, args) +__mul__(timeseries self, timeseries arg2) -> timeseries +__mul__(timeseries self, double arg2) -> timeseries "; -.. math:: +%feature("docstring") cmf_core::timeseries::__neg__ "def +__neg__(self, args, kwargs) - q=\\\\begin{cases}0 & V_{source}\\\\le V_{min}\\\\\\\\ q_0 - \\\\frac{V_{source} - V_{min}}{t_{decr} q_{0} - V_{min}} & V_{source} - \\\\le t_{decr} q_{0}\\\\\\\\ q_{0} & \\\\end{cases} +__neg__(timeseries self) -> timeseries "; -This is similar to a neumann boundary, however this is not a boundary -condition, but water is taken from the source (left) water storage and -limited by that water storage. +%feature("docstring") cmf_core::timeseries::__radd__ "def +__radd__(self, other) "; -C++ includes: simple_connections.h "; +%feature("docstring") cmf_core::timeseries::__rdiv__ "def +__rdiv__(self, other) "; -%feature("docstring") cmf::water::TechnicalFlux::TechnicalFlux "TechnicalFlux(cmf::water::WaterStorage::ptr source, -cmf::water::flux_node::ptr target, real maximum_flux, real -minimal_state=0, cmf::math::Time flux_decrease_time=cmf::math::h) +%feature("docstring") cmf_core::timeseries::__repr__ "def +__repr__(self) "; -Produces a constant but changeable flux from a source to a target, if -enough water is present in the source. +%feature("docstring") cmf_core::timeseries::__rmul__ "def +__rmul__(self, other) "; -Parameters: ------------ +%feature("docstring") cmf_core::timeseries::__rsub__ "def +__rsub__(self, other) "; -source: The source of the water +%feature("docstring") cmf_core::timeseries::__setitem__ "def +__setitem__(self, index, value) "; -target: The target of the water +%feature("docstring") cmf_core::timeseries::__setstate__ "def +__setstate__(self, data) "; -maximum_flux: The requested flux :math:`q_{0}` +%feature("docstring") cmf_core::timeseries::__sub__ "def +__sub__(self, args) -minimal_state: Minimal volume of stored water in source +__sub__(timeseries self, timeseries arg2) -> timeseries +__sub__(timeseries self, double arg2) -> timeseries "; -flux_decrease_time: ( cmf::math::Time) "; +%feature("docstring") cmf_core::timeseries::__truediv__ "def +__truediv__(self, args) "; + +%feature("docstring") cmf_core::timeseries::add "def add(self, args, +kwargs) -%feature("docstring") cmf::water::TechnicalFlux::conc "real -conc(cmf::math::Time t, const cmf::water::solute &_Solute) +add(timeseries self, double Value) void add(double Value) Appends a +measurement. "; -Returns the concentration of the flux. +%feature("docstring") cmf_core::timeseries::adress "def adress(self, +args, kwargs) -If not overridden, it returns the concentration of the source of the -flux (direction depending) "; +adress(timeseries self) -> size_t size_t adress() const "; -%feature("docstring") cmf::water::TechnicalFlux::exchange_target "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr -newTarget) "; +%feature("docstring") cmf_core::timeseries::as_array "def +as_array(self, args, kwargs) -%feature("docstring") cmf::water::TechnicalFlux::get_ptr "ptr -get_ptr() const "; +as_array(timeseries self) -> cmf::math::num_array cmf::math::num_array +as_array() const "; -%feature("docstring") cmf::water::TechnicalFlux::get_target "flux_node::ptr get_target(const flux_node &inquirer) +%feature("docstring") cmf_core::timeseries::clear "def clear(self, +args, kwargs) -Returns the other end of a connection than the asking end. "; +clear(timeseries self) void clear() "; -%feature("docstring") cmf::water::TechnicalFlux::get_target "flux_node::ptr get_target(int index) const +%feature("docstring") cmf_core::timeseries::copy "def copy(self, +args, kwargs) -With index 0, the left node is returned, with index 1 the right node -of the connection. "; +copy(timeseries self) -> timeseries timeseries copy() const "; -%feature("docstring") cmf::water::TechnicalFlux::get_tracer_filter "real get_tracer_filter() +%feature("docstring") cmf_core::timeseries::count_values "def +count_values(self, args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. +count_values(timeseries self) -> size_t size_t count_values() const +Number of valid values (=size - # of NaN's) "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::timeseries::exp "def exp(self, args, +kwargs) -%feature("docstring") cmf::water::TechnicalFlux::get_tracer_filter "real get_tracer_filter(solute S) +exp(timeseries self) -> timeseries timeseries exp() const "; -A value ranging from 0 to 1 to filter tracers out of the water flux. -"; +%feature("docstring") cmf_core::timeseries::extend "def extend(self, +list) -%feature("docstring") cmf::water::TechnicalFlux::kill_me "bool -kill_me() +Adds the values of a sequence to the timeseries "; -Deregisters this connection from its nodes. Returns true if only one -reference is left. "; +%feature("docstring") cmf_core::timeseries::floating_avg "def +floating_avg(self, args) -%feature("docstring") cmf::water::TechnicalFlux::left_node "flux_node::ptr left_node() const +floating_avg(timeseries self, Time window_width) -> timeseries +floating_avg(timeseries self, size_t window_size) -> timeseries +timeseries floating_avg(size_t window_size) const "; -Returns the left node of this connection. "; +%feature("docstring") cmf_core::timeseries::floating_max "def +floating_max(self, args, kwargs) -%feature("docstring") cmf::water::TechnicalFlux::q "real q(const -flux_node &inquirer, cmf::math::Time t) +floating_max(timeseries self, Time window_width) -> timeseries +timeseries floating_max(cmf::math::Time window_width) const "; -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +%feature("docstring") cmf_core::timeseries::floating_min "def +floating_min(self, args, kwargs) -%feature("docstring") cmf::water::TechnicalFlux::refresh "void -refresh(cmf::math::Time t) +floating_min(timeseries self, Time window_width) -> timeseries +timeseries floating_min(cmf::math::Time window_width) const "; -Performes a new calculation of the flux. "; +%feature("docstring") cmf_core::timeseries::from_array "def +from_array(args, kwargs) -%feature("docstring") cmf::water::TechnicalFlux::right_node "flux_node::ptr right_node() const +from_array(Time begin, Time step, cmf::math::num_array const & data) +-> timeseries "; -returns the right node of this connection "; +%feature("docstring") cmf_core::timeseries::from_buffer "def +from_buffer(cls, buf) "; -%feature("docstring") cmf::water::TechnicalFlux::set_tracer_filter "void set_tracer_filter(real value) +%feature("docstring") cmf_core::timeseries::from_file "def +from_file(args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. +from_file(std::string filename) -> timeseries "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::timeseries::from_file "def +from_file(cls, f) -%feature("docstring") cmf::water::TechnicalFlux::set_tracer_filter "void set_tracer_filter(solute S, real value) "; +Loads a timeseries saved with to_file from a file Description of the +file layout: byte: 0 Number of (int64) 8 Begin of timeseries (in +ms since 31.12.1899 00:00) (int64) 16 Step size of timeseries (in ms) +(int64) 24 Interpolation power (int64) 32 First value of timeseries +(float64) "; -%feature("docstring") cmf::water::TechnicalFlux::short_string "virtual std::string short_string() const "; +%feature("docstring") cmf_core::timeseries::from_scalar "def +from_scalar(args, kwargs) -%feature("docstring") cmf::water::TechnicalFlux::to_string "virtual -std::string to_string() const "; +from_scalar(double scalar) -> timeseries "; +%feature("docstring") cmf_core::timeseries::from_sequence "def +from_sequence(cls, begin, step, sequence, interpolation_mode=1) "; -// File: classcmf_1_1math_1_1_time.xml -%feature("docstring") cmf::math::Time " +%feature("docstring") cmf_core::timeseries::get_i "def get_i(self, +args, kwargs) -A time class, used to pass around current modelling times. +get_i(timeseries self, ptrdiff_t i) -> double double get_i(ptrdiff_t +i) const "; -Timespans and dates in cmf are used with a special object, called -Time. An extra class has the advantage, that the user does not have to -remember, which unit of time he or she uses or what time unit is -accepted by a specific function of the model. Arithmetic and boolean -operators are supported by Time. Internally the time classes stores -the time as integer milliseconds, therefore rounding issues will only -appear at very small time ranges. Absolute time (like dates) are -represented as milliseconds gone by from Dec, 31st 1899. Microsoft -Excel dates are represented as days from that time, using floating -point numbers, therefore it is very simple to convert Excel time -representations to cmf time. +%feature("docstring") cmf_core::timeseries::get_slice "def +get_slice(self, args) -Another object is Date, which is doesn't provide the operators, but -has a nice printed version and some special date functions, like day -of year (DOY) and provides access to the current hour of day and so -on, which only applyto dates and not to time spans. You can convert -Time to Date an vice versa. The printing is not culture aware and uses -the European representation. If you use the Python standard library -datetime, conversion between Python time and cmf time is possible +get_slice(timeseries self, Time _begin, Time _end, Time _step) -> +timeseries get_slice(timeseries self, ptrdiff_t _begin, ptrdiff_t +_end, ptrdiff_t step=1) -> timeseries cmf::math::timeseries +get_slice(ptrdiff_t _begin, ptrdiff_t _end, ptrdiff_t step=1) "; -Creating absolute time values (dates) Creating time spans +%feature("docstring") cmf_core::timeseries::get_t "def get_t(self, +args, kwargs) -In principle, there are three ways to create time spans. One is to use -one of the static functions, another is to multiply an existing time -span (like one of the build in constants) or to substrate two absolute -times. +get_t(timeseries self, Time t) -> double double get_t(cmf::math::Time +t) const "; -Available constants : 4.1 seconds +%feature("docstring") cmf_core::timeseries::interpolate "def +interpolate(self, begin, end, step) -: 2.3 hours (138 min) +Returns a generator returning the interpolated values at the timesteps +"; -: 2.3 hours (138 min) +%feature("docstring") cmf_core::timeseries::interpolationpower "def +interpolationpower(self, args, kwargs) -: 60 hours (2.5 days) +interpolationpower(timeseries self) -> int int interpolationpower() +const Method for the interpolation (0 - Nearest neighbor, 1- linear, +2 - cubic spline (not implemented yet) "; -: 7 days +%feature("docstring") cmf_core::timeseries::inv "def inv(self, args, +kwargs) -: 365/12 days (30.4167 days) +inv(timeseries self) -> timeseries timeseries inv() const "; -: 365 days +%feature("docstring") cmf_core::timeseries::is_empty "def +is_empty(self, args, kwargs) -Available operators: +is_empty(timeseries self) -> bool bool is_empty() const returns true +if no values are added to the timeseries "; -time + time = time, time - time = time +%feature("docstring") cmf_core::timeseries::iter_time "def +iter_time(self) -time * float = time ,time / float = time +Returns an iterator to iterate over each timestep "; -time/time=float +%feature("docstring") cmf_core::timeseries::log "def log(self, args, +kwargs) ->, <, ==, != +log(timeseries self) -> timeseries timeseries log() const "; -Conversions +%feature("docstring") cmf_core::timeseries::log10 "def log10(self, +args, kwargs) -Converting to python datetime +log10(timeseries self) -> timeseries timeseries log10() const "; -Converting to numbers +%feature("docstring") cmf_core::timeseries::max "def max(self, args, +kwargs) -t.AsMilliseconds() +max(timeseries self) -> double double max() const "; -t.AsSeconds() +%feature("docstring") cmf_core::timeseries::mean "def mean(self, +args, kwargs) -t.AsMinutes() +mean(timeseries self) -> double double mean() const "; -t.AsHours() +%feature("docstring") cmf_core::timeseries::min "def min(self, args, +kwargs) -t.AsDays() +min(timeseries self) -> double double min() const "; -t.AsYears() +%feature("docstring") cmf_core::timeseries::power "def power(self, +args, kwargs) -Creating time ranges +power(timeseries self, double exponent) -> timeseries timeseries +power(double exponent) const "; -C++ includes: time.h "; +%feature("docstring") cmf_core::timeseries::reduce_avg "def +reduce_avg(self, args, kwargs) -/* Constructors */ +reduce_avg(timeseries self, Time begin, Time step) -> timeseries +timeseries reduce_avg(cmf::math::Time begin, cmf::math::Time step) +const Creates a timeseries with a bigger timestep, containing the +average. "; -%feature("docstring") cmf::math::Time::Time "Time(int day, int -month, int year, int hour=0, int minute=0, int second=0, int ms=0) +%feature("docstring") cmf_core::timeseries::reduce_max "def +reduce_max(self, args, kwargs) -Construction from date and stores the time as Excel-Time (0 = -31.12.1899 0:00:00) "; +reduce_max(timeseries self, Time begin, Time step) -> timeseries +timeseries reduce_max(cmf::math::Time begin, cmf::math::Time step) +const Creates a timeseries with a bigger timestep, containing the +maximum. "; -%feature("docstring") cmf::math::Time::Time "Time(Date date) +%feature("docstring") cmf_core::timeseries::reduce_min "def +reduce_min(self, args, kwargs) -Conversion constructor. "; +reduce_min(timeseries self, Time begin, Time step) -> timeseries +timeseries reduce_min(cmf::math::Time begin, cmf::math::Time step) +const Creates a timeseries with a bigger timestep, containing the +minimum. "; -%feature("docstring") cmf::math::Time::Time "Time(const Time &t) +%feature("docstring") cmf_core::timeseries::reduce_sum "def +reduce_sum(self, args, kwargs) -Copy constructor. "; +reduce_sum(timeseries self, Time begin, Time step) -> timeseries +timeseries reduce_sum(cmf::math::Time begin, cmf::math::Time step) +const Creates a timeseries with a bigger timestep, containing the +sum. "; -%feature("docstring") cmf::math::Time::Time "Time() +%feature("docstring") cmf_core::timeseries::remove_nodata "def +remove_nodata(self, args, kwargs) -Standard constructor. "; +remove_nodata(timeseries self, double nodata_value) void +remove_nodata(double nodata_value) "; -%feature("docstring") cmf::math::Time::Time "Time(long long -milliseconds) "; +%feature("docstring") cmf_core::timeseries::set_begin "def +set_begin(self, args, kwargs) -/* Time unit conversion */ +set_begin(timeseries self, Time new_begin) void +set_begin(cmf::math::Time new_begin) "; -%feature("docstring") cmf::math::Time::AsDays "double AsDays() const +%feature("docstring") cmf_core::timeseries::set_i "def set_i(self, +args, kwargs) -Time in days. "; +set_i(timeseries self, ptrdiff_t i, double value) void +set_i(ptrdiff_t i, double value) "; -%feature("docstring") cmf::math::Time::AsHours "double AsHours() -const +%feature("docstring") cmf_core::timeseries::set_interpolationpower "def set_interpolationpower(self, args, kwargs) -Time in hours. "; +set_interpolationpower(timeseries self, int new_ip) void +set_interpolationpower(int new_ip) "; -%feature("docstring") cmf::math::Time::AsMinutes "double AsMinutes() -const +%feature("docstring") cmf_core::timeseries::set_slice "def +set_slice(self, args) -Time in minutes. "; +set_slice(timeseries self, Time _begin, Time _end, timeseries values) +set_slice(timeseries self, ptrdiff_t _begin, ptrdiff_t _end, +timeseries _values) void set_slice(ptrdiff_t _begin, ptrdiff_t _end, +cmf::math::timeseries _values) "; -%feature("docstring") cmf::math::Time::AsSeconds "double AsSeconds() -const +%feature("docstring") cmf_core::timeseries::set_step "def +set_step(self, args, kwargs) -Time in seconds. "; +set_step(timeseries self, Time new_step) void +set_step(cmf::math::Time new_step) "; -%feature("docstring") cmf::math::Time::AsMilliseconds "long long -AsMilliseconds() const +%feature("docstring") cmf_core::timeseries::set_t "def set_t(self, +args, kwargs) -Time in milliseconds. "; +set_t(timeseries self, Time t, double value) void +set_t(cmf::math::Time t, double value) "; -%feature("docstring") cmf::math::Time::AsDate "Date AsDate() const -"; +%feature("docstring") cmf_core::timeseries::size "def size(self, +args, kwargs) -%feature("docstring") cmf::math::Time::to_string "std::string -to_string(char seperator=':') "; +size(timeseries self) -> size_t size_t size() const Number of items +in the timeseries. "; -%feature("docstring") cmf::math::Time::is_not_0 "bool is_not_0() -const "; +%feature("docstring") cmf_core::timeseries::to_buffer "def +to_buffer(self) -%feature("docstring") cmf::math::Time::DOY "double DOY() const "; +Returns a binary buffer filled with the data of self "; -/* Arithmetic operators */ +%feature("docstring") cmf_core::timeseries::to_file "def +to_file(self, f) -%feature("docstring") cmf::math::Time::times_in "long long -times_in(const Time &t1) const +Saves a timeseries in a special binary format. The format consists of +4 integers with 64 bit, indicating the milliseconds after the +31.12.1899 00:00 of the beginning of the timeseries, the milliseconds +of the time step, the interpolation power and the number of values. +The following 64 bit floats, are the values of the timeseries "; -Returns the number of times this is included in t1. "; +%feature("docstring") cmf_core::timeseries::to_pandas "def +to_pandas(self) -/* Boolean Operators */ +Returns the timeseries as a pandas Series object :return: A +pandas.Series object with the timesteps as index "; // File: classcmf_1_1math_1_1timeseries.xml @@ -16466,37 +35161,289 @@ q(const flux_node &inquirer, cmf::math::Time t) Returns the current flux through a connection. Negative signs mean out of the inquirer, positive are inflows to the inquirer. "; -%feature("docstring") cmf::upslope::ET::timeseriesETpot::refresh "void refresh(cmf::math::Time t) +%feature("docstring") cmf::upslope::ET::timeseriesETpot::refresh "void refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") cmf::upslope::ET::timeseriesETpot::right_node "flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") +cmf::upslope::ET::timeseriesETpot::set_stressfunction "void +set_stressfunction(const RootUptakeStessFunction &stressfunction) + +Sets the stress function to limit water uptake. "; + +%feature("docstring") +cmf::upslope::ET::timeseriesETpot::set_tracer_filter "void +set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") +cmf::upslope::ET::timeseriesETpot::set_tracer_filter "void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf::upslope::ET::timeseriesETpot::short_string +"virtual std::string short_string() const "; + +%feature("docstring") cmf::upslope::ET::timeseriesETpot::to_string "std::string to_string() const "; + + +// File: classcmf__core_1_1timeseries_e_tpot.xml +%feature("docstring") cmf_core::timeseriesETpot " + +A timeseries driven evapotranspiration. Uses a timeseries of measured +or elsewhere modelled ETpot. Actual Evapotranspiration is calculated +from rootdepth and actual matrix potential in the layers using Tact. +The value of ETpot can be changed during runtime C++ includes: ET.h +"; + +%feature("docstring") cmf_core::timeseriesETpot::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::ET::timeseriesETpot self, +cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr +ET_target, timeseries ETpot_values) -> timeseriesETpot +timeseriesETpot(cmf::upslope::SoilLayer::ptr source, +cmf::water::flux_node::ptr ET_target, cmf::math::timeseries +ETpot_values) "; + +%feature("docstring") cmf_core::timeseriesETpot::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::timeseriesETpot::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::timeseriesETpot::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::timeseriesETpot::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::timeseriesETpot::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::timeseriesETpot::conc "def +conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") cmf_core::timeseriesETpot::ETpot "def +ETpot(self, args, kwargs) + +ETpot(stressedET self, Time t) -> real virtual real +ETpot(cmf::math::Time t) const "; + +%feature("docstring") cmf_core::timeseriesETpot::exchange_target "def exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::timeseriesETpot::get_layer "def +get_layer(self, args, kwargs) + +get_layer(stressedET self) -> cmf::upslope::SoilLayer::ptr +SoilLayer::ptr get_layer() const "; + +%feature("docstring") cmf_core::timeseriesETpot::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::timeseriesETpot::get_tracer_filter "def get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::timeseriesETpot::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::timeseriesETpot::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::timeseriesETpot::q "def q(self, +args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::timeseriesETpot::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::timeseriesETpot::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::timeseriesETpot::set_stressfunction "def set_stressfunction(self, args, kwargs) + +set_stressfunction(stressedET self, RootUptakeStessFunction +stressfunction) void set_stressfunction(const RootUptakeStessFunction +&stressfunction) Sets the stress function to limit water uptake. "; + +%feature("docstring") cmf_core::timeseriesETpot::set_tracer_filter "def set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::timeseriesETpot::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::timeseriesETpot::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + +// File: classcmf__core_1_1_timeseries_rain_source.xml +%feature("docstring") cmf_core::TimeseriesRainSource " + +A rainsource with a timeseries. Simpler to use than a rainfall +station if there are only few cells in the project C++ includes: +precipitation.h "; + +%feature("docstring") cmf_core::TimeseriesRainSource::__init__ "def +__init__(self, args, kwargs) "; + +%feature("docstring") cmf_core::TimeseriesRainSource::__call__ "def +__call__(self, args, kwargs) + +__call__(RainSource self, Time t) -> real "; + +%feature("docstring") cmf_core::TimeseriesRainSource::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_node self, flux_node other) -> bool "; + +%feature("docstring") cmf_core::TimeseriesRainSource::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::TimeseriesRainSource::conc "def +conc(self, args, kwargs) + +conc(flux_node self, Time t, solute Solute) -> real virtual real +conc(cmf::math::Time t, const cmf::water::solute &Solute) const +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; + +%feature("docstring") cmf_core::TimeseriesRainSource::connected_nodes +"def connected_nodes(self) "; + +%feature("docstring") cmf_core::TimeseriesRainSource::connection_to "def connection_to(self, args, kwargs) + +connection_to(flux_node self, flux_node target) -> flux_connection +cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) Returns the connection between this and target. "; + +%feature("docstring") cmf_core::TimeseriesRainSource::flux3d_to "def +flux3d_to(self, args, kwargs) + +flux3d_to(flux_node self, flux_node target, Time t) -> point +cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; + +%feature("docstring") cmf_core::TimeseriesRainSource::flux_to "def +flux_to(self, args, kwargs) + +flux_to(flux_node self, flux_node target, Time t) -> real real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; + +%feature("docstring") cmf_core::TimeseriesRainSource::fluxes "def +fluxes(self, t) "; + +%feature("docstring") cmf_core::TimeseriesRainSource::get_3d_flux "def get_3d_flux(self, args, kwargs) + +get_3d_flux(flux_node self, Time t) -> point cmf::geometry::point +get_3d_flux(cmf::math::Time t) Returns the sum of all flux vectors. +"; + +%feature("docstring") cmf_core::TimeseriesRainSource::get_intensity "def get_intensity(self, args, kwargs) + +get_intensity(RainSource self, Time t) -> real virtual real +get_intensity(cmf::math::Time t) const =0 Returns the actual rainfall +intensity in mm/day. "; + +%feature("docstring") cmf_core::TimeseriesRainSource::is_empty "def +is_empty(self, args, kwargs) -Performes a new calculation of the flux. "; +is_empty(flux_node self) -> double virtual double is_empty() const +Returns true if the node has no water. "; -%feature("docstring") cmf::upslope::ET::timeseriesETpot::right_node "flux_node::ptr right_node() const +%feature("docstring") cmf_core::TimeseriesRainSource::is_storage "def is_storage(self, args, kwargs) -returns the right node of this connection "; +is_storage(flux_node self) -> bool virtual bool is_storage() const +true, if this is a waterstorage "; -%feature("docstring") -cmf::upslope::ET::timeseriesETpot::set_stressfunction "void -set_stressfunction(const RootUptakeStessFunction &stressfunction) +%feature("docstring") cmf_core::TimeseriesRainSource::RecalcFluxes "def RecalcFluxes(self, args, kwargs) -Sets the stress function to limit water uptake. "; +RecalcFluxes(flux_node self, Time t) -> bool virtual bool +RecalcFluxes(cmf::math::Time t) Pure flux_nodes do not influence +fluxes, therefore no recalculation of fluxes is required by flux_node. +WaterStorage overrides this, since state changes require an update of +the fluxes "; %feature("docstring") -cmf::upslope::ET::timeseriesETpot::set_tracer_filter "void -set_tracer_filter(real value) +cmf_core::TimeseriesRainSource::remove_connection "def +remove_connection(self, args, kwargs) -A value ranging from 0 to 1 to filter tracers out of the water flux. +remove_connection(flux_node self, cmf::water::flux_node::ptr To) -> +bool bool remove_connection(cmf::water::flux_node::ptr To) Remove +the connection. "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::TimeseriesRainSource::to_string "def +to_string(self, args, kwargs) -%feature("docstring") -cmf::upslope::ET::timeseriesETpot::set_tracer_filter "void -set_tracer_filter(solute S, real value) "; +to_string(flux_node self) -> std::string virtual std::string +to_string() const "; -%feature("docstring") cmf::upslope::ET::timeseriesETpot::short_string -"virtual std::string short_string() const "; +%feature("docstring") cmf_core::TimeseriesRainSource::waterbalance "def waterbalance(self, args, kwargs) -%feature("docstring") cmf::upslope::ET::timeseriesETpot::to_string "std::string to_string() const "; +waterbalance(flux_node self, Time t, flux_connection Without=None) -> +real real waterbalance(cmf::math::Time t, const flux_connection +*Without=0) const Returns the sum of all fluxes (positive and +negative) at time t. Single fluxes can be excluded from the +calculation Parameters: ----------- t: Time of the query Without: +A flux_connection that is excluded from the waterbalance (e.g. to +prevent closed circuits) "; // File: classcmf_1_1atmosphere_1_1_timeseries_rain_source.xml @@ -16614,6 +35561,139 @@ Without: A flux_connection that is excluded from the waterbalance (e.g. to prevent closed circuits) "; +// File: classcmf__core_1_1_t_o_p_model_flow.xml +%feature("docstring") cmf_core::TOPModelFlow " + +Calculates a flux from a soil layer using TOPMODELs (Beven & Kirkby +1979) exponential transmissivity concept. .. math:: T = T_0 +\\\\\\\\exp(-D_i/m) where: :math:`T` is the actual transmissivity +of the profile in :math:`m^2/day` :math:`T0` is the transmissivity of +the profile at saturation :math:`D_i` is the drained depth in m, +calculated as :math:`(C-V)/A`, the capacity of the layer - volume per +area :math:`m` a scaling factor in m By using the transmissivity in +Darcy's law and assuming the GW gradient to be parallel to the +topographic slope we get for the flow: .. math:: q = T_0 +\\\\\\\\exp(-D_i/m) w s where: :math:`q` is the flux in +:math:`m^3/day` :math:`w` is the flow width (unit contour length) +:math:`s` is the topographic slope between layer and outlet TOPMODEL +is based on the concept of drained depth, not, as cmf on the concept +of stored volume. Hence, negative volumes can occur if C++ includes: +subsurfacefluxes.h "; + +%feature("docstring") cmf_core::TOPModelFlow::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::connections::TOPModelFlow self, +cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right, +real T0, real m, real flowwidth, real distance=0) -> TOPModelFlow +TOPModelFlow(cmf::upslope::SoilLayer::ptr left, +cmf::water::flux_node::ptr right, real T0, real m, real flowwidth, +real distance=0) "; + +%feature("docstring") cmf_core::TOPModelFlow::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::TOPModelFlow::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::TOPModelFlow::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::TOPModelFlow::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::TOPModelFlow::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::TOPModelFlow::conc "def conc(self, +args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") cmf_core::TOPModelFlow::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::TOPModelFlow::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::TOPModelFlow::get_tracer_filter "def +get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::TOPModelFlow::kill_me "def +kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::TOPModelFlow::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::TOPModelFlow::q "def q(self, args, +kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::TOPModelFlow::refresh "def +refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::TOPModelFlow::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::TOPModelFlow::set_tracer_filter "def +set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::TOPModelFlow::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::TOPModelFlow::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + // File: classcmf_1_1upslope_1_1connections_1_1_t_o_p_model_flow.xml %feature("docstring") cmf::upslope::connections::TOPModelFlow " @@ -16756,6 +35836,134 @@ cmf::upslope::connections::TOPModelFlow::to_string "virtual std::string to_string() const "; +// File: classcmf__core_1_1_topographic_gradient_darcy.xml +%feature("docstring") cmf_core::TopographicGradientDarcy " + +Calculates the lateral flow using the topographic gradient. .. +math:: q_{lat} = \\\\\\\\frac{z_1 - +z_2}{\\\\\\\\|C_1-C_2\\\\\\\\|} \\\\\\\\frac 12 (T(C_1)+T(C_2)) w +where :math:`z_1 - z_2` is the topographic height difference +:math:`\\\\\\\\|C_1-C_2\\\\\\\\|` is the distance from Cell 1 to Cell +2 :math:`T(C)` is the transmissivity of cell C, calculated by +SoilType::Transmissivity :math:`w` is the width of the connection of +the cells C++ includes: subsurfacefluxes.h "; + +%feature("docstring") cmf_core::TopographicGradientDarcy::__init__ "def __init__(self, args, kwargs) + +__init__(cmf::upslope::connections::TopographicGradientDarcy self, +cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right, +real FlowWidth, real Distance=0) -> TopographicGradientDarcy +TopographicGradientDarcy(cmf::upslope::SoilLayer::ptr left, +cmf::water::flux_node::ptr right, real FlowWidth, real Distance=0) +Creates the connection. Parameters: ----------- left: Left node of +the connection (needs to be soil water storage) right: Right node of +the connection (can be any node) FlowWidth: the width of the +connection - is multiplied by layer thickness to get the interface +area Distance: the length of the connection. If 0, the distance is +calculated from the position of the nodes "; + +%feature("docstring") +cmf_core::TopographicGradientDarcy::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::TopographicGradientDarcy::__eq__ "def __eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::TopographicGradientDarcy::__getitem__ +"def __getitem__(self, index) "; + +%feature("docstring") cmf_core::TopographicGradientDarcy::__iter__ "def __iter__(self) "; + +%feature("docstring") cmf_core::TopographicGradientDarcy::__repr__ "def __repr__(self) "; + +%feature("docstring") cmf_core::TopographicGradientDarcy::conc "def +conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") +cmf_core::TopographicGradientDarcy::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::TopographicGradientDarcy::get_target +"def get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") +cmf_core::TopographicGradientDarcy::get_tracer_filter "def +get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::TopographicGradientDarcy::kill_me "def kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::TopographicGradientDarcy::left_node "def left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::TopographicGradientDarcy::q "def +q(self, args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::TopographicGradientDarcy::refresh "def refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::TopographicGradientDarcy::right_node +"def right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") +cmf_core::TopographicGradientDarcy::set_tracer_filter "def +set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") +cmf_core::TopographicGradientDarcy::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::TopographicGradientDarcy::to_string "def to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + // File: classcmf_1_1upslope_1_1connections_1_1_topographic_gradient_darcy.xml %feature("docstring") cmf::upslope::connections::TopographicGradientDarcy " @@ -16895,6 +36103,72 @@ cmf::upslope::connections::TopographicGradientDarcy::short_string "virtual std:: cmf::upslope::connections::TopographicGradientDarcy::to_string "virtual std::string to_string() const "; +// File: classcmf__core_1_1_topology.xml +%feature("docstring") cmf_core::Topology " + +represents the connectivity of cells to each other C++ includes: +Topology.h "; + +%feature("docstring") cmf_core::Topology::__init__ "def +__init__(self, args, kwargs) "; + +%feature("docstring") cmf_core::Topology::__eq__ "def __eq__(self, +args, kwargs) + +__eq__(Topology self, Topology cmp) -> bool "; + +%feature("docstring") cmf_core::Topology::AddNeighbor "def +AddNeighbor(self, args) + +AddNeighbor(Topology self, Cell target, double flowwidth) +AddNeighbor(Topology self, Topology target, double flowwidth) void +AddNeighbor(Topology &target, double flowwidth) "; + +%feature("docstring") cmf_core::Topology::calculate_contributing_area +"def calculate_contributing_area(args, kwargs) + +calculate_contributing_area(cell_vector arg1) "; + +%feature("docstring") cmf_core::Topology::ContributingArea "def +ContributingArea(self, args, kwargs) + +ContributingArea(Topology self) -> double double ContributingArea() +const Get the contributing area (steepest path upwards) "; + +%feature("docstring") cmf_core::Topology::flowwidth "def +flowwidth(self, args) + +flowwidth(Topology self, Cell target) -> double flowwidth(Topology +self, Topology target) -> double double flowwidth(Topology &target) +"; + +%feature("docstring") cmf_core::Topology::get_position "def +get_position(self, args, kwargs) + +get_position(Topology self) -> point cmf::geometry::point +get_position() const Returns the center of the cell. "; + +%feature("docstring") cmf_core::Topology::MainOutlet "def +MainOutlet(self, args, kwargs) + +MainOutlet(Topology self, bool forceRecalc=False) -> Cell Cell* +MainOutlet(bool forceRecalc=false) Returns the mainoutlet (steepest +lower neighbor) "; + +%feature("docstring") cmf_core::Topology::neighbor_count "def +neighbor_count(self, args, kwargs) + +neighbor_count(Topology self) -> size_t size_t neighbor_count() const +Returns the number of neighbors. "; + +%feature("docstring") cmf_core::Topology::RemoveNeighbor "def +RemoveNeighbor(self, args, kwargs) + +RemoveNeighbor(Topology self, Topology target) void +RemoveNeighbor(Topology &target) Removes the topological relation to +the given cell. "; + + // File: classcmf_1_1upslope_1_1_topology.xml %feature("docstring") cmf::upslope::Topology " @@ -17070,6 +36344,131 @@ typecode() const "; V(double h) const "; +// File: classcmf__core_1_1_triangular_reach.xml +%feature("docstring") cmf_core::TriangularReach " + +Structure for the description of reaches with a triangular cross +section. Although double triangular cross section reach are rarely +met, a triangular reach does scale with its water load, and is +therefore preferable in case where nothing about IChannel geometry is +known C++ includes: ReachType.h "; + +%feature("docstring") cmf_core::TriangularReach::__init__ "def +__init__(self, args) + +__init__(cmf::river::TriangularReach self, double l, double +bankSlope=2) -> TriangularReach __init__(cmf::river::TriangularReach +self, TriangularReach copy) -> TriangularReach TriangularReach(const +TriangularReach ©) "; + +%feature("docstring") cmf_core::TriangularReach::A "def A(self, +args, kwargs) + +A(IVolumeHeightFunction self, double V) -> double virtual double +A(double V) const =0 Returns the area of the surface for a given +volume. "; + +%feature("docstring") cmf_core::TriangularReach::copy "def +copy(self, args, kwargs) + +copy(TriangularReach self) -> TriangularReach TriangularReach* copy() +const "; + +%feature("docstring") cmf_core::TriangularReach::get_channel_width "def get_channel_width(self, args, kwargs) + +get_channel_width(IChannel self, double depth) -> double virtual +double get_channel_width(double depth) const =0 Calculates the flow +width from a given actual depth [m] using the actual IChannel +geometry. "; + +%feature("docstring") cmf_core::TriangularReach::get_depth "def +get_depth(self, args, kwargs) + +get_depth(IChannel self, double area) -> double virtual double +get_depth(double area) const =0 Calculates the actual depth of the +reach using the IChannel geometry. get_depth of the reach [m] +Parameters: ----------- area: Wetted area of a river cross section +[m2], can be obtained by V/l, where V is the stored volume and l is +the reach length "; + +%feature("docstring") cmf_core::TriangularReach::get_flux_crossection +"def get_flux_crossection(self, args, kwargs) + +get_flux_crossection(IChannel self, double depth) -> double virtual +double get_flux_crossection(double depth) const =0 Calculates the +wetted area from a given depth using the IChannel geometry. In most +cases use get_flux_crossection=V/l, where V is the stored volume and l +is the reach length Wetted area of a river cross section [m2] +Parameters: ----------- depth: depth of the reach [m] "; + +%feature("docstring") cmf_core::TriangularReach::get_length "def +get_length(self, args, kwargs) + +get_length(IChannel self) -> double virtual double get_length() const +=0 Length of the reach. "; + +%feature("docstring") cmf_core::TriangularReach::get_nManning "def +get_nManning(self, args, kwargs) + +get_nManning(IChannel self) -> double virtual double get_nManning() +const =0 "; + +%feature("docstring") cmf_core::TriangularReach::get_wetted_perimeter +"def get_wetted_perimeter(self, args, kwargs) + +get_wetted_perimeter(IChannel self, double depth) -> double virtual +double get_wetted_perimeter(double depth) const =0 Calculates the +wetted perimeter from a given actual depth [m] using the actual +IChannel geometry. "; + +%feature("docstring") cmf_core::TriangularReach::h "def h(self, +args, kwargs) + +h(IVolumeHeightFunction self, double V) -> double virtual double +h(double V) const =0 Returns the depth of a given volume. "; + +%feature("docstring") cmf_core::TriangularReach::q "def q(self, +args, kwargs) + +q(IVolumeHeightFunction self, double h, double slope) -> double +virtual double q(double h, double slope) const "; + +%feature("docstring") cmf_core::TriangularReach::qManning "def +qManning(self, args, kwargs) + +qManning(IChannel self, double A, double slope) -> double virtual +double qManning(double A, double slope) const Calculates the flow +rate from a given water volume in the reach .. math:: q_{Manning}&=& +A R^{\\\\\\\\frac 2 3} \\\\\\\\sqrt{\\\\\\\\frac {\\\\\\\\Delta_z} +n} \\\\\\\\\\\\\\\\ A &=& \\\\\\\\frac V l \\\\\\\\mbox{, +(Crosssectional area of the wetted crossection, Volume per +length)} \\\\\\\\\\\\\\\\ R &=& \\\\\\\\frac A {P(d)} \\\\\\\\\\\\\\\\ +P(d) &=& \\\\\\\\mbox{ the perimeter of the wetted crosssection, a +function of reach depth} \\\\\\\\\\\\\\\\ d(V) &=& \\\\\\\\mbox{ +the depth of the reach a function of the volume} \\\\\\\\\\\\\\\\ +\\\\\\\\Delta_z &=& \\\\\\\\frac{z_{max} - z_{min}}{l} +\\\\\\\\mbox{ Slope of the reach} . Flow rate [m3/s] Parameters: +----------- A: The area of the cross section [m2] slope: The slope +of the reach [m/m] "; + +%feature("docstring") cmf_core::TriangularReach::set_nManning "def +set_nManning(self, args, kwargs) + +set_nManning(IChannel self, double val) virtual void +set_nManning(double val)=0 "; + +%feature("docstring") cmf_core::TriangularReach::typecode "def +typecode(self, args, kwargs) + +typecode(IChannel self) -> char virtual char typecode() const =0 "; + +%feature("docstring") cmf_core::TriangularReach::V "def V(self, +args, kwargs) + +V(IVolumeHeightFunction self, double h) -> double virtual double +V(double h) const =0 "; + + // File: classcmf_1_1upslope_1_1_e_t_1_1_turc_e_t.xml %feature("docstring") cmf::upslope::ET::TurcET " @@ -17151,34 +36550,334 @@ Returns the left node of this connection. "; %feature("docstring") cmf::upslope::ET::TurcET::q "real q(const flux_node &inquirer, cmf::math::Time t) -Returns the current flux through a connection. Negative signs mean out -of the inquirer, positive are inflows to the inquirer. "; +Returns the current flux through a connection. Negative signs mean out +of the inquirer, positive are inflows to the inquirer. "; + +%feature("docstring") cmf::upslope::ET::TurcET::refresh "void +refresh(cmf::math::Time t) + +Performes a new calculation of the flux. "; + +%feature("docstring") cmf::upslope::ET::TurcET::right_node "flux_node::ptr right_node() const + +returns the right node of this connection "; + +%feature("docstring") cmf::upslope::ET::TurcET::set_stressfunction "void set_stressfunction(const RootUptakeStessFunction &stressfunction) + +Sets the stress function to limit water uptake. "; + +%feature("docstring") cmf::upslope::ET::TurcET::set_tracer_filter "void set_tracer_filter(real value) + +A value ranging from 0 to 1 to filter tracers out of the water flux. + +1.0 is no filter and 0.0 means no solute is crossing this connection +"; + +%feature("docstring") cmf::upslope::ET::TurcET::set_tracer_filter "void set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf::upslope::ET::TurcET::short_string "virtual std::string short_string() const "; + +%feature("docstring") cmf::upslope::ET::TurcET::to_string "std::string to_string() const "; + + +// File: classcmf__core_1_1_turc_e_t.xml +%feature("docstring") cmf_core::TurcET " + +Calculates ETpot after Turc (DVWK). ETact is calculated using a +WaterStressFunction :math:`ET_{pot,Turc} = 0.0031 C (R_G + 209) +\\\\\\\\frac{T}{T + 15}` C++ includes: ET.h "; + +%feature("docstring") cmf_core::TurcET::__init__ "def __init__(self, +args, kwargs) + +__init__(cmf::upslope::ET::TurcET self, cmf::upslope::SoilLayer::ptr +source, cmf::water::flux_node::ptr ET_target) -> TurcET +TurcET(cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr +ET_target) "; + +%feature("docstring") cmf_core::TurcET::__contains__ "def +__contains__(self, cmp) "; + +%feature("docstring") cmf_core::TurcET::__eq__ "def __eq__(self, +args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::TurcET::__getitem__ "def +__getitem__(self, index) "; + +%feature("docstring") cmf_core::TurcET::__iter__ "def __iter__(self) +"; + +%feature("docstring") cmf_core::TurcET::__repr__ "def __repr__(self) +"; + +%feature("docstring") cmf_core::TurcET::conc "def conc(self, args, +kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") cmf_core::TurcET::ETpot "def ETpot(self, args, +kwargs) + +ETpot(stressedET self, Time t) -> real virtual real +ETpot(cmf::math::Time t) const "; + +%feature("docstring") cmf_core::TurcET::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::TurcET::get_layer "def +get_layer(self, args, kwargs) + +get_layer(stressedET self) -> cmf::upslope::SoilLayer::ptr +SoilLayer::ptr get_layer() const "; + +%feature("docstring") cmf_core::TurcET::get_target "def +get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") cmf_core::TurcET::get_tracer_filter "def +get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::TurcET::kill_me "def kill_me(self, +args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::TurcET::left_node "def +left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::TurcET::q "def q(self, args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::TurcET::refresh "def refresh(self, +args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::TurcET::right_node "def +right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") cmf_core::TurcET::set_stressfunction "def +set_stressfunction(self, args, kwargs) + +set_stressfunction(stressedET self, RootUptakeStessFunction +stressfunction) void set_stressfunction(const RootUptakeStessFunction +&stressfunction) Sets the stress function to limit water uptake. "; + +%feature("docstring") cmf_core::TurcET::set_tracer_filter "def +set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::TurcET::short_string "def +short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::TurcET::to_string "def +to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + +%feature("docstring") cmf_core::TurcET::use_for_cell "def +use_for_cell(args, kwargs) + +use_for_cell(Cell cell) "; -%feature("docstring") cmf::upslope::ET::TurcET::refresh "void -refresh(cmf::math::Time t) -Performes a new calculation of the flux. "; +// File: classcmf__core_1_1_van_genuchten_mualem.xml +%feature("docstring") cmf_core::VanGenuchtenMualem " -%feature("docstring") cmf::upslope::ET::TurcET::right_node "flux_node::ptr right_node() const +Provides the use of the Van Genuchten - Mualem retention curve (Van +Genuchten 1980) Head - moisture relationship: .. math:: +W(\\\\\\\\theta) &=& \\\\\\\\frac{\\\\\\\\theta - +\\\\\\\\theta_r}{\\\\\\\\theta_s - \\\\\\\\theta_r} \\\\\\\\\\\\\\\\ +K(W) &=& K_{sat} \\\\\\\\sqrt{W} +\\\\\\\\left(1-\\\\\\\\left(1-W^{1/m}\\\\\\\\right)^m\\\\\\\\right)^2 +\\\\\\\\\\\\\\\\ m &=& 1-\\\\\\\\frac 1 n \\\\\\\\\\\\\\\\ +\\\\\\\\Psi(W) &=& 0.01 \\\\\\\\frac{m}{cm} +\\\\\\\\frac{{\\\\\\\\left(1-{W}^{\\\\\\\\frac{1}{m}}\\\\\\\\right) +}^{\\\\\\\\frac{1}{n}}}{\\\\\\\\alpha\\\\\\\\,{W}^{\\\\\\\\frac{1}{m\\\\\\\\,n}}} +\\\\\\\\\\\\\\\\ W(\\\\\\\\Psi) &=& +\\\\\\\\left(1+\\\\\\\\left(\\\\\\\\alpha\\\\\\\\,100\\\\\\\\frac{cm}{m}\\\\\\\\Psi\\\\\\\\right)^n\\\\\\\\right)^{-m} +where: :math:`K` is the conductivity in :math:`\\\\\\\\frac m{day}` +:math:`W` is the wetness (Volume of soil water per volume of pores) +:math:`n` is a shape parameter of the retention curve +:math:`\\\\\\\\alpha` is inverse of the air entry potential in +:math:`cm^{-1}` :math:`\\\\\\\\Psi(W)` is the matric potential in +:math:`m H_2O` at wetness W C++ includes: RetentionCurve.h "; + +%feature("docstring") cmf_core::VanGenuchtenMualem::__init__ "def +__init__(self, args, kwargs) -returns the right node of this connection "; +__init__(cmf::upslope::VanGenuchtenMualem self, real Ksat=15, real +phi=0.5, real alpha=0.2178, real n=1.211, real m=-1, real theta_r=0.0, +real w0=0.99) -> VanGenuchtenMualem VanGenuchtenMualem(real Ksat=15, +real phi=0.5, real alpha=0.2178, real n=1.211, real m=-1, real +theta_r=0.0, real w0=0.99) Creates a van Genuchten-Mualem retention +curve. Parameters: ----------- Ksat: Saturated conductivity in +:math:`\\\\\\\\frac m{day}` phi: Porosity in :math:`\\\\\\\\frac{m^3 +Pores}{m^3 Soil}` alpha: Van Genuchten :math:`\\\\\\\\alpha` in +:math:`\\\\\\\\frac 1{cm}` n: Van Genuchten n m: Van Genuchten m +parameter, if negative m is calculated as :math:`1-\\\\\\\\frac 1 n` +theta_r: Water content for +:math:`\\\\\\\\lim\\\\\\\\limits_{\\\\\\\\Psi_M \\\\\\\\rightarrow +-\\\\\\\\infty}{\\\\\\\\theta(\\\\\\\\Psi_M)}` w0: Wetness above the +parabolic extrapolation is used instead of the Van Genuchten curve +(usually calculated with fit_w0) "; -%feature("docstring") cmf::upslope::ET::TurcET::set_stressfunction "void set_stressfunction(const RootUptakeStessFunction &stressfunction) +%feature("docstring") cmf_core::VanGenuchtenMualem::__repr__ "def +__repr__(self) "; -Sets the stress function to limit water uptake. "; +%feature("docstring") cmf_core::VanGenuchtenMualem::__str__ "def +__str__(self) "; + +%feature("docstring") cmf_core::VanGenuchtenMualem::copy "def +copy(self, args, kwargs) + +copy(VanGenuchtenMualem self) -> VanGenuchtenMualem +VanGenuchtenMualem* copy() const "; + +%feature("docstring") cmf_core::VanGenuchtenMualem::Diffusivity "def +Diffusivity(self, args) + +Diffusivity(RetentionCurve self, real wetness) -> real +Diffusivity(RetentionCurve self, cmf::math::num_array & wetness) -> +cmf::math::num_array cmf::math::num_array +Diffusivity(cmf::math::num_array &wetness) "; + +%feature("docstring") cmf_core::VanGenuchtenMualem::dPsiM_dW "def +dPsiM_dW(self, args) + +dPsiM_dW(RetentionCurve self, real wetness) -> real +dPsiM_dW(RetentionCurve self, cmf::math::num_array const & wetness) -> +cmf::math::num_array cmf::math::num_array dPsiM_dW(const +cmf::math::num_array &wetness) const "; + +%feature("docstring") cmf_core::VanGenuchtenMualem::FillHeight "def +FillHeight(self, args, kwargs) + +FillHeight(RetentionCurve self, real lowerDepth, real Area, real +Volume) -> real virtual real FillHeight(real lowerDepth, real Area, +real Volume) const Returns the thickness of a soil column with a +certain pore volume. "; + +%feature("docstring") cmf_core::VanGenuchtenMualem::fit_w0 "def +fit_w0(self, args, kwargs) + +fit_w0(VanGenuchtenMualem self, real w1=1.01, real Psi_p=1.0, real +tolerance=0.05) -> real real fit_w0(real w1=1.01, real Psi_p=1.0, +real tolerance=0.05) Fits the break point wetness w0, to ensure a +specific oversaturation at a given hydrostatic potential. Parameters: +----------- w1: The oversaturation wetness to archieve (>1), default += 1.01 Psi_p: the hydrostatic potential for w1, default = +1.0 m +tolerance: "; + +%feature("docstring") cmf_core::VanGenuchtenMualem::K "def K(self, +args) + +K(RetentionCurve self, real wetness) -> real K(RetentionCurve self, +cmf::math::num_array const & wetness) -> cmf::math::num_array +cmf::math::num_array K(const cmf::math::num_array &wetness) const "; + +%feature("docstring") cmf_core::VanGenuchtenMualem::MatricPotential "def MatricPotential(self, args) + +MatricPotential(RetentionCurve self, real wetness) -> real +MatricPotential(RetentionCurve self, cmf::math::num_array const & +wetness) -> cmf::math::num_array cmf::math::num_array +MatricPotential(const cmf::math::num_array &wetness) const "; + +%feature("docstring") cmf_core::VanGenuchtenMualem::Porosity "def +Porosity(self, args, kwargs) + +Porosity(RetentionCurve self, real depth=0.0) -> real virtual real +Porosity(real depth=0.0) const =0 Returns the porosity at a certain +depth. "; + +%feature("docstring") cmf_core::VanGenuchtenMualem::theta "def +theta(self, args) + +theta(RetentionCurve self, real wetness) -> real theta(RetentionCurve +self, cmf::math::num_array const & wetness) -> cmf::math::num_array +cmf::math::num_array theta(const cmf::math::num_array &wetness) const +"; + +%feature("docstring") cmf_core::VanGenuchtenMualem::Transmissivity "def Transmissivity(self, args, kwargs) + +Transmissivity(VanGenuchtenMualem self, real upperDepth, real +lowerDepth, real wetness) -> real virtual real Transmissivity(real +upperDepth, real lowerDepth, real wetness) const "; + +%feature("docstring") cmf_core::VanGenuchtenMualem::VoidVolume "def +VoidVolume(self, args, kwargs) + +VoidVolume(RetentionCurve self, real upperDepth, real lowerDepth, real +Area) -> real virtual real VoidVolume(real upperDepth, real +lowerDepth, real Area) const Returns the void volume of a soil +column. "; -%feature("docstring") cmf::upslope::ET::TurcET::set_tracer_filter "void set_tracer_filter(real value) +%feature("docstring") cmf_core::VanGenuchtenMualem::Wetness "def +Wetness(self, args) -A value ranging from 0 to 1 to filter tracers out of the water flux. +Wetness(RetentionCurve self, real suction) -> real +Wetness(RetentionCurve self, cmf::math::num_array const & suction) -> +cmf::math::num_array cmf::math::num_array Wetness(const +cmf::math::num_array &suction) const "; -1.0 is no filter and 0.0 means no solute is crossing this connection -"; +%feature("docstring") cmf_core::VanGenuchtenMualem::Wetness_eff "def +Wetness_eff(self, args, kwargs) -%feature("docstring") cmf::upslope::ET::TurcET::set_tracer_filter "void set_tracer_filter(solute S, real value) "; +Wetness_eff(RetentionCurve self, real wetness, real pF_r=4.2) -> real +virtual real Wetness_eff(real wetness, real pF_r=4.2) const Returns +the effective wetness, using a residual pF value .. math:: w_{eff} += +\\\\\\\\frac{w_{act}-w\\\\\\\\left(pF_r\\\\\\\\right)}{1-w\\\\\\\\left(pF_r\\\\\\\\right)} +. "; -%feature("docstring") cmf::upslope::ET::TurcET::short_string "virtual std::string short_string() const "; +%feature("docstring") cmf_core::VanGenuchtenMualem::Wetness_pF "def +Wetness_pF(self, args) -%feature("docstring") cmf::upslope::ET::TurcET::to_string "std::string to_string() const "; +Wetness_pF(RetentionCurve self, real pF) -> real +Wetness_pF(RetentionCurve self, cmf::math::num_array const & pF) -> +cmf::math::num_array cmf::math::num_array Wetness_pF(const +cmf::math::num_array &pF) const "; // File: classcmf_1_1upslope_1_1_van_genuchten_mualem.xml @@ -17382,47 +37081,649 @@ cmf::upslope::VanGenuchtenMualem::Transmissivity "virtual real Transmissivity(real upperDepth, real lowerDepth, real wetness) const "; -%feature("docstring") cmf::upslope::VanGenuchtenMualem::VoidVolume "virtual real VoidVolume(real upperDepth, real lowerDepth, real Area) -const +%feature("docstring") cmf::upslope::VanGenuchtenMualem::VoidVolume "virtual real VoidVolume(real upperDepth, real lowerDepth, real Area) +const + +Returns the void volume of a soil column. "; + +%feature("docstring") cmf::upslope::VanGenuchtenMualem::Wetness "cmf::math::num_array Wetness(const cmf::math::num_array &suction) +const "; + +%feature("docstring") cmf::upslope::VanGenuchtenMualem::Wetness "virtual real Wetness(real suction) const + +returns the saturation at a given suction (matrix potential). + + + +.. math:: + + W(\\\\Psi) = + \\\\left(1+\\\\left(\\\\alpha\\\\,100\\\\frac{cm}{m}\\\\Psi\\\\right)^n\\\\right)^{-m} + + +"; + +%feature("docstring") cmf::upslope::VanGenuchtenMualem::Wetness_eff "virtual real Wetness_eff(real wetness, real pF_r=4.2) const + +Returns the effective wetness, using a residual pF value + +.. math:: + + w_{eff} + = + \\\\frac{w_{act}-w\\\\left(pF_r\\\\right)}{1-w\\\\left(pF_r\\\\right)} + +. +"; + +%feature("docstring") cmf::upslope::VanGenuchtenMualem::Wetness_pF "real Wetness_pF(real pF) const + +returns the volumetric water content at a given pF value "; + +%feature("docstring") cmf::upslope::VanGenuchtenMualem::Wetness_pF "cmf::math::num_array Wetness_pF(const cmf::math::num_array &pF) const +"; + + +// File: classcmf__core_1_1vector__double.xml +%feature("docstring") cmf_core::vector_double " + +Proxy of C++ std::vector<(double)> class. "; + +%feature("docstring") cmf_core::vector_double::__init__ "def +__init__(self, args) + +__init__(std::vector<(double)> self) -> vector_double +__init__(std::vector<(double)> self, vector_double arg2) -> +vector_double __init__(std::vector<(double)> self, std::vector< double +>::size_type size) -> vector_double __init__(std::vector<(double)> +self, std::vector< double >::size_type size, std::vector< double +>::value_type const & value) -> vector_double "; + +%feature("docstring") cmf_core::vector_double::__bool__ "def +__bool__(self, args, kwargs) + +__bool__(vector_double self) -> bool "; + +%feature("docstring") cmf_core::vector_double::__delitem__ "def +__delitem__(self, args) + +__delitem__(vector_double self, std::vector< double >::difference_type +i) __delitem__(vector_double self, PySliceObject * slice) "; + +%feature("docstring") cmf_core::vector_double::__delslice__ "def +__delslice__(self, args, kwargs) + +__delslice__(vector_double self, std::vector< double +>::difference_type i, std::vector< double >::difference_type j) "; + +%feature("docstring") cmf_core::vector_double::__getitem__ "def +__getitem__(self, args) + +__getitem__(vector_double self, PySliceObject * slice) -> +vector_double __getitem__(vector_double self, std::vector< double +>::difference_type i) -> std::vector< double >::value_type const & "; + +%feature("docstring") cmf_core::vector_double::__getslice__ "def +__getslice__(self, args, kwargs) + +__getslice__(vector_double self, std::vector< double +>::difference_type i, std::vector< double >::difference_type j) -> +vector_double "; + +%feature("docstring") cmf_core::vector_double::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::vector_double::__len__ "def +__len__(self, args, kwargs) + +__len__(vector_double self) -> std::vector< double >::size_type "; + +%feature("docstring") cmf_core::vector_double::__nonzero__ "def +__nonzero__(self, args, kwargs) + +__nonzero__(vector_double self) -> bool "; + +%feature("docstring") cmf_core::vector_double::__setitem__ "def +__setitem__(self, args) + +__setitem__(vector_double self, PySliceObject * slice, vector_double +v) __setitem__(vector_double self, PySliceObject * slice) +__setitem__(vector_double self, std::vector< double >::difference_type +i, std::vector< double >::value_type const & x) "; + +%feature("docstring") cmf_core::vector_double::__setslice__ "def +__setslice__(self, args) + +__setslice__(vector_double self, std::vector< double +>::difference_type i, std::vector< double >::difference_type j) +__setslice__(vector_double self, std::vector< double +>::difference_type i, std::vector< double >::difference_type j, +vector_double v) "; + +%feature("docstring") cmf_core::vector_double::append "def +append(self, args, kwargs) + +append(vector_double self, std::vector< double >::value_type const & +x) "; + +%feature("docstring") cmf_core::vector_double::assign "def +assign(self, args, kwargs) + +assign(vector_double self, std::vector< double >::size_type n, +std::vector< double >::value_type const & x) "; + +%feature("docstring") cmf_core::vector_double::back "def back(self, +args, kwargs) + +back(vector_double self) -> std::vector< double >::value_type const & +"; + +%feature("docstring") cmf_core::vector_double::begin "def +begin(self, args, kwargs) + +begin(vector_double self) -> std::vector< double >::iterator "; + +%feature("docstring") cmf_core::vector_double::capacity "def +capacity(self, args, kwargs) + +capacity(vector_double self) -> std::vector< double >::size_type "; + +%feature("docstring") cmf_core::vector_double::clear "def +clear(self, args, kwargs) + +clear(vector_double self) "; + +%feature("docstring") cmf_core::vector_double::empty "def +empty(self, args, kwargs) + +empty(vector_double self) -> bool "; + +%feature("docstring") cmf_core::vector_double::end "def end(self, +args, kwargs) + +end(vector_double self) -> std::vector< double >::iterator "; + +%feature("docstring") cmf_core::vector_double::erase "def +erase(self, args) + +erase(vector_double self, std::vector< double >::iterator pos) -> +std::vector< double >::iterator erase(vector_double self, std::vector< +double >::iterator first, std::vector< double >::iterator last) -> +std::vector< double >::iterator "; + +%feature("docstring") cmf_core::vector_double::front "def +front(self, args, kwargs) + +front(vector_double self) -> std::vector< double >::value_type const & +"; + +%feature("docstring") cmf_core::vector_double::get_allocator "def +get_allocator(self, args, kwargs) + +get_allocator(vector_double self) -> std::vector< double +>::allocator_type "; + +%feature("docstring") cmf_core::vector_double::insert "def +insert(self, args) + +insert(vector_double self, std::vector< double >::iterator pos, +std::vector< double >::value_type const & x) -> std::vector< double +>::iterator insert(vector_double self, std::vector< double >::iterator +pos, std::vector< double >::size_type n, std::vector< double +>::value_type const & x) "; + +%feature("docstring") cmf_core::vector_double::iterator "def +iterator(self, args, kwargs) + +iterator(vector_double self) -> SwigPyIterator "; + +%feature("docstring") cmf_core::vector_double::pop "def pop(self, +args, kwargs) + +pop(vector_double self) -> std::vector< double >::value_type "; + +%feature("docstring") cmf_core::vector_double::pop_back "def +pop_back(self, args, kwargs) + +pop_back(vector_double self) "; + +%feature("docstring") cmf_core::vector_double::push_back "def +push_back(self, args, kwargs) + +push_back(vector_double self, std::vector< double >::value_type const +& x) "; + +%feature("docstring") cmf_core::vector_double::rbegin "def +rbegin(self, args, kwargs) + +rbegin(vector_double self) -> std::vector< double >::reverse_iterator +"; + +%feature("docstring") cmf_core::vector_double::rend "def rend(self, +args, kwargs) + +rend(vector_double self) -> std::vector< double >::reverse_iterator "; + +%feature("docstring") cmf_core::vector_double::reserve "def +reserve(self, args, kwargs) + +reserve(vector_double self, std::vector< double >::size_type n) "; + +%feature("docstring") cmf_core::vector_double::resize "def +resize(self, args) + +resize(vector_double self, std::vector< double >::size_type new_size) +resize(vector_double self, std::vector< double >::size_type new_size, +std::vector< double >::value_type const & x) "; + +%feature("docstring") cmf_core::vector_double::size "def size(self, +args, kwargs) + +size(vector_double self) -> std::vector< double >::size_type "; + +%feature("docstring") cmf_core::vector_double::swap "def swap(self, +args, kwargs) + +swap(vector_double self, vector_double v) "; + + +// File: classcmf__core_1_1vector__int.xml +%feature("docstring") cmf_core::vector_int " + +Proxy of C++ std::vector<(int)> class. "; + +%feature("docstring") cmf_core::vector_int::__init__ "def +__init__(self, args) + +__init__(std::vector<(int)> self) -> vector_int +__init__(std::vector<(int)> self, vector_int arg2) -> vector_int +__init__(std::vector<(int)> self, std::vector< int >::size_type size) +-> vector_int __init__(std::vector<(int)> self, std::vector< int +>::size_type size, std::vector< int >::value_type const & value) -> +vector_int "; + +%feature("docstring") cmf_core::vector_int::__bool__ "def +__bool__(self, args, kwargs) + +__bool__(vector_int self) -> bool "; + +%feature("docstring") cmf_core::vector_int::__delitem__ "def +__delitem__(self, args) + +__delitem__(vector_int self, std::vector< int >::difference_type i) +__delitem__(vector_int self, PySliceObject * slice) "; + +%feature("docstring") cmf_core::vector_int::__delslice__ "def +__delslice__(self, args, kwargs) + +__delslice__(vector_int self, std::vector< int >::difference_type i, +std::vector< int >::difference_type j) "; + +%feature("docstring") cmf_core::vector_int::__getitem__ "def +__getitem__(self, args) + +__getitem__(vector_int self, PySliceObject * slice) -> vector_int +__getitem__(vector_int self, std::vector< int >::difference_type i) -> +std::vector< int >::value_type const & "; + +%feature("docstring") cmf_core::vector_int::__getslice__ "def +__getslice__(self, args, kwargs) + +__getslice__(vector_int self, std::vector< int >::difference_type i, +std::vector< int >::difference_type j) -> vector_int "; + +%feature("docstring") cmf_core::vector_int::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::vector_int::__len__ "def +__len__(self, args, kwargs) + +__len__(vector_int self) -> std::vector< int >::size_type "; + +%feature("docstring") cmf_core::vector_int::__nonzero__ "def +__nonzero__(self, args, kwargs) + +__nonzero__(vector_int self) -> bool "; + +%feature("docstring") cmf_core::vector_int::__setitem__ "def +__setitem__(self, args) + +__setitem__(vector_int self, PySliceObject * slice, vector_int v) +__setitem__(vector_int self, PySliceObject * slice) +__setitem__(vector_int self, std::vector< int >::difference_type i, +std::vector< int >::value_type const & x) "; + +%feature("docstring") cmf_core::vector_int::__setslice__ "def +__setslice__(self, args) + +__setslice__(vector_int self, std::vector< int >::difference_type i, +std::vector< int >::difference_type j) __setslice__(vector_int self, +std::vector< int >::difference_type i, std::vector< int +>::difference_type j, vector_int v) "; + +%feature("docstring") cmf_core::vector_int::append "def append(self, +args, kwargs) + +append(vector_int self, std::vector< int >::value_type const & x) "; + +%feature("docstring") cmf_core::vector_int::assign "def assign(self, +args, kwargs) + +assign(vector_int self, std::vector< int >::size_type n, std::vector< +int >::value_type const & x) "; + +%feature("docstring") cmf_core::vector_int::back "def back(self, +args, kwargs) + +back(vector_int self) -> std::vector< int >::value_type const & "; + +%feature("docstring") cmf_core::vector_int::begin "def begin(self, +args, kwargs) + +begin(vector_int self) -> std::vector< int >::iterator "; + +%feature("docstring") cmf_core::vector_int::capacity "def +capacity(self, args, kwargs) + +capacity(vector_int self) -> std::vector< int >::size_type "; + +%feature("docstring") cmf_core::vector_int::clear "def clear(self, +args, kwargs) + +clear(vector_int self) "; + +%feature("docstring") cmf_core::vector_int::empty "def empty(self, +args, kwargs) + +empty(vector_int self) -> bool "; + +%feature("docstring") cmf_core::vector_int::end "def end(self, args, +kwargs) + +end(vector_int self) -> std::vector< int >::iterator "; + +%feature("docstring") cmf_core::vector_int::erase "def erase(self, +args) + +erase(vector_int self, std::vector< int >::iterator pos) -> +std::vector< int >::iterator erase(vector_int self, std::vector< int +>::iterator first, std::vector< int >::iterator last) -> std::vector< +int >::iterator "; + +%feature("docstring") cmf_core::vector_int::front "def front(self, +args, kwargs) + +front(vector_int self) -> std::vector< int >::value_type const & "; + +%feature("docstring") cmf_core::vector_int::get_allocator "def +get_allocator(self, args, kwargs) + +get_allocator(vector_int self) -> std::vector< int >::allocator_type +"; + +%feature("docstring") cmf_core::vector_int::insert "def insert(self, +args) + +insert(vector_int self, std::vector< int >::iterator pos, std::vector< +int >::value_type const & x) -> std::vector< int >::iterator +insert(vector_int self, std::vector< int >::iterator pos, std::vector< +int >::size_type n, std::vector< int >::value_type const & x) "; + +%feature("docstring") cmf_core::vector_int::iterator "def +iterator(self, args, kwargs) + +iterator(vector_int self) -> SwigPyIterator "; + +%feature("docstring") cmf_core::vector_int::pop "def pop(self, args, +kwargs) + +pop(vector_int self) -> std::vector< int >::value_type "; + +%feature("docstring") cmf_core::vector_int::pop_back "def +pop_back(self, args, kwargs) + +pop_back(vector_int self) "; + +%feature("docstring") cmf_core::vector_int::push_back "def +push_back(self, args, kwargs) + +push_back(vector_int self, std::vector< int >::value_type const & x) +"; + +%feature("docstring") cmf_core::vector_int::rbegin "def rbegin(self, +args, kwargs) + +rbegin(vector_int self) -> std::vector< int >::reverse_iterator "; + +%feature("docstring") cmf_core::vector_int::rend "def rend(self, +args, kwargs) + +rend(vector_int self) -> std::vector< int >::reverse_iterator "; + +%feature("docstring") cmf_core::vector_int::reserve "def +reserve(self, args, kwargs) + +reserve(vector_int self, std::vector< int >::size_type n) "; + +%feature("docstring") cmf_core::vector_int::resize "def resize(self, +args) + +resize(vector_int self, std::vector< int >::size_type new_size) +resize(vector_int self, std::vector< int >::size_type new_size, +std::vector< int >::value_type const & x) "; + +%feature("docstring") cmf_core::vector_int::size "def size(self, +args, kwargs) + +size(vector_int self) -> std::vector< int >::size_type "; + +%feature("docstring") cmf_core::vector_int::swap "def swap(self, +args, kwargs) + +swap(vector_int self, vector_int v) "; + + +// File: classcmf__core_1_1vector__size__t.xml +%feature("docstring") cmf_core::vector_size_t " + +Proxy of C++ std::vector<(size_t)> class. "; + +%feature("docstring") cmf_core::vector_size_t::__init__ "def +__init__(self, args) + +__init__(std::vector<(size_t)> self) -> vector_size_t +__init__(std::vector<(size_t)> self, vector_size_t arg2) -> +vector_size_t __init__(std::vector<(size_t)> self, std::vector< size_t +>::size_type size) -> vector_size_t __init__(std::vector<(size_t)> +self, std::vector< size_t >::size_type size, std::vector< size_t +>::value_type const & value) -> vector_size_t "; + +%feature("docstring") cmf_core::vector_size_t::__bool__ "def +__bool__(self, args, kwargs) + +__bool__(vector_size_t self) -> bool "; + +%feature("docstring") cmf_core::vector_size_t::__delitem__ "def +__delitem__(self, args) + +__delitem__(vector_size_t self, std::vector< size_t >::difference_type +i) __delitem__(vector_size_t self, PySliceObject * slice) "; + +%feature("docstring") cmf_core::vector_size_t::__delslice__ "def +__delslice__(self, args, kwargs) + +__delslice__(vector_size_t self, std::vector< size_t +>::difference_type i, std::vector< size_t >::difference_type j) "; + +%feature("docstring") cmf_core::vector_size_t::__getitem__ "def +__getitem__(self, args) + +__getitem__(vector_size_t self, PySliceObject * slice) -> +vector_size_t __getitem__(vector_size_t self, std::vector< size_t +>::difference_type i) -> std::vector< size_t >::value_type const & "; + +%feature("docstring") cmf_core::vector_size_t::__getslice__ "def +__getslice__(self, args, kwargs) + +__getslice__(vector_size_t self, std::vector< size_t +>::difference_type i, std::vector< size_t >::difference_type j) -> +vector_size_t "; + +%feature("docstring") cmf_core::vector_size_t::__iter__ "def +__iter__(self) "; + +%feature("docstring") cmf_core::vector_size_t::__len__ "def +__len__(self, args, kwargs) + +__len__(vector_size_t self) -> std::vector< size_t >::size_type "; + +%feature("docstring") cmf_core::vector_size_t::__nonzero__ "def +__nonzero__(self, args, kwargs) + +__nonzero__(vector_size_t self) -> bool "; + +%feature("docstring") cmf_core::vector_size_t::__setitem__ "def +__setitem__(self, args) + +__setitem__(vector_size_t self, PySliceObject * slice, vector_size_t +v) __setitem__(vector_size_t self, PySliceObject * slice) +__setitem__(vector_size_t self, std::vector< size_t >::difference_type +i, std::vector< size_t >::value_type const & x) "; + +%feature("docstring") cmf_core::vector_size_t::__setslice__ "def +__setslice__(self, args) + +__setslice__(vector_size_t self, std::vector< size_t +>::difference_type i, std::vector< size_t >::difference_type j) +__setslice__(vector_size_t self, std::vector< size_t +>::difference_type i, std::vector< size_t >::difference_type j, +vector_size_t v) "; + +%feature("docstring") cmf_core::vector_size_t::append "def +append(self, args, kwargs) + +append(vector_size_t self, std::vector< size_t >::value_type const & +x) "; + +%feature("docstring") cmf_core::vector_size_t::assign "def +assign(self, args, kwargs) + +assign(vector_size_t self, std::vector< size_t >::size_type n, +std::vector< size_t >::value_type const & x) "; + +%feature("docstring") cmf_core::vector_size_t::back "def back(self, +args, kwargs) + +back(vector_size_t self) -> std::vector< size_t >::value_type const & +"; + +%feature("docstring") cmf_core::vector_size_t::begin "def +begin(self, args, kwargs) + +begin(vector_size_t self) -> std::vector< size_t >::iterator "; + +%feature("docstring") cmf_core::vector_size_t::capacity "def +capacity(self, args, kwargs) + +capacity(vector_size_t self) -> std::vector< size_t >::size_type "; + +%feature("docstring") cmf_core::vector_size_t::clear "def +clear(self, args, kwargs) + +clear(vector_size_t self) "; + +%feature("docstring") cmf_core::vector_size_t::empty "def +empty(self, args, kwargs) + +empty(vector_size_t self) -> bool "; + +%feature("docstring") cmf_core::vector_size_t::end "def end(self, +args, kwargs) + +end(vector_size_t self) -> std::vector< size_t >::iterator "; + +%feature("docstring") cmf_core::vector_size_t::erase "def +erase(self, args) + +erase(vector_size_t self, std::vector< size_t >::iterator pos) -> +std::vector< size_t >::iterator erase(vector_size_t self, std::vector< +size_t >::iterator first, std::vector< size_t >::iterator last) -> +std::vector< size_t >::iterator "; + +%feature("docstring") cmf_core::vector_size_t::front "def +front(self, args, kwargs) + +front(vector_size_t self) -> std::vector< size_t >::value_type const & +"; + +%feature("docstring") cmf_core::vector_size_t::get_allocator "def +get_allocator(self, args, kwargs) + +get_allocator(vector_size_t self) -> std::vector< size_t +>::allocator_type "; + +%feature("docstring") cmf_core::vector_size_t::insert "def +insert(self, args) -Returns the void volume of a soil column. "; +insert(vector_size_t self, std::vector< size_t >::iterator pos, +std::vector< size_t >::value_type const & x) -> std::vector< size_t +>::iterator insert(vector_size_t self, std::vector< size_t >::iterator +pos, std::vector< size_t >::size_type n, std::vector< size_t +>::value_type const & x) "; -%feature("docstring") cmf::upslope::VanGenuchtenMualem::Wetness "cmf::math::num_array Wetness(const cmf::math::num_array &suction) -const "; +%feature("docstring") cmf_core::vector_size_t::iterator "def +iterator(self, args, kwargs) -%feature("docstring") cmf::upslope::VanGenuchtenMualem::Wetness "virtual real Wetness(real suction) const +iterator(vector_size_t self) -> SwigPyIterator "; -returns the saturation at a given suction (matrix potential). +%feature("docstring") cmf_core::vector_size_t::pop "def pop(self, +args, kwargs) +pop(vector_size_t self) -> std::vector< size_t >::value_type "; +%feature("docstring") cmf_core::vector_size_t::pop_back "def +pop_back(self, args, kwargs) -.. math:: +pop_back(vector_size_t self) "; - W(\\\\Psi) = - \\\\left(1+\\\\left(\\\\alpha\\\\,100\\\\frac{cm}{m}\\\\Psi\\\\right)^n\\\\right)^{-m} - +%feature("docstring") cmf_core::vector_size_t::push_back "def +push_back(self, args, kwargs) + +push_back(vector_size_t self, std::vector< size_t >::value_type const +& x) "; +%feature("docstring") cmf_core::vector_size_t::rbegin "def +rbegin(self, args, kwargs) + +rbegin(vector_size_t self) -> std::vector< size_t >::reverse_iterator "; -%feature("docstring") cmf::upslope::VanGenuchtenMualem::Wetness_eff "virtual real Wetness_eff(real wetness, real pF_r=4.2) const +%feature("docstring") cmf_core::vector_size_t::rend "def rend(self, +args, kwargs) -Returns the effective wetness, using a residual pF value +rend(vector_size_t self) -> std::vector< size_t >::reverse_iterator "; -.. math:: +%feature("docstring") cmf_core::vector_size_t::reserve "def +reserve(self, args, kwargs) - w_{eff} - = - \\\\frac{w_{act}-w\\\\left(pF_r\\\\right)}{1-w\\\\left(pF_r\\\\right)} +reserve(vector_size_t self, std::vector< size_t >::size_type n) "; -. -"; +%feature("docstring") cmf_core::vector_size_t::resize "def +resize(self, args) -%feature("docstring") cmf::upslope::VanGenuchtenMualem::Wetness_pF "real Wetness_pF(real pF) const +resize(vector_size_t self, std::vector< size_t >::size_type new_size) +resize(vector_size_t self, std::vector< size_t >::size_type new_size, +std::vector< size_t >::value_type const & x) "; -returns the volumetric water content at a given pF value "; +%feature("docstring") cmf_core::vector_size_t::size "def size(self, +args, kwargs) -%feature("docstring") cmf::upslope::VanGenuchtenMualem::Wetness_pF "cmf::math::num_array Wetness_pF(const cmf::math::num_array &pF) const -"; +size(vector_size_t self) -> std::vector< size_t >::size_type "; + +%feature("docstring") cmf_core::vector_size_t::swap "def swap(self, +args, kwargs) + +swap(vector_size_t self, vector_size_t v) "; // File: classcmf_1_1upslope_1_1vegetation_1_1_vegetation.xml @@ -17476,6 +37777,93 @@ const Returns the average root length in m/m2. "; +// File: classcmf__core_1_1_vegetation.xml +%feature("docstring") cmf_core::Vegetation " + +Holds the vegetation parameters for the calculation of ET and +fractionating rainfall. Not every ET method uses all parameters. C++ +includes: StructVegetation.h "; + +%feature("docstring") cmf_core::Vegetation::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::upslope::vegetation::Vegetation self, double _LAI=2.88, +double _Height=0.12, double _RootDepth=0.25, double +_StomatalResistance=100, double _albedo=0.23, double _CanopyClosure=1, +double _CanopyCapacityPerLAI=0.1, double _fraction_at_rootdepth=1.0) +-> Vegetation Vegetation(double _LAI=2.88, double _Height=0.12, +double _RootDepth=0.25, double _StomatalResistance=100, double +_albedo=0.23, double _CanopyClosure=1, double +_CanopyCapacityPerLAI=0.1, double _fraction_at_rootdepth=1.0) "; + +%feature("docstring") cmf_core::Vegetation::__repr__ "def +__repr__(self, args, kwargs) + +__repr__(Vegetation self) -> std::string "; + +%feature("docstring") cmf_core::Vegetation::RootFraction "def +RootFraction(self, args) + +RootFraction(Vegetation self, double upperBoundary, double +lowerBoundary) -> double RootFraction(Vegetation self, +cmf::math::num_array const & thickness) -> cmf::math::num_array +cmf::math::num_array RootFraction(const cmf::math::num_array +&thickness) const "; + +%feature("docstring") cmf_core::Vegetation::RootLength "def +RootLength(self, args, kwargs) + +RootLength(Vegetation self) -> double double RootLength() const +Returns the average root length in m/m2. "; + + +// File: classcmf__core_1_1volume__height__function.xml +%feature("docstring") cmf_core::volume_height_function " + +A wrapper class for volume / height functional relations. C++ +includes: ReachType.h "; + +%feature("docstring") cmf_core::volume_height_function::__init__ "def __init__(self, args) + +__init__(cmf::river::volume_height_function self, +volume_height_function for_copy) -> volume_height_function +__init__(cmf::river::volume_height_function self, +IVolumeHeightFunction for_copy) -> volume_height_function +volume_height_function(const IVolumeHeightFunction &for_copy) Wrapper +for any IVolumeHeightFunction. "; + +%feature("docstring") cmf_core::volume_height_function::A "def +A(self, args, kwargs) + +A(IVolumeHeightFunction self, double V) -> double virtual double +A(double V) const =0 Returns the area of the surface for a given +volume. "; + +%feature("docstring") cmf_core::volume_height_function::copy "def +copy(self, args, kwargs) + +copy(volume_height_function self) -> volume_height_function +volume_height_function* copy() const "; + +%feature("docstring") cmf_core::volume_height_function::h "def +h(self, args, kwargs) + +h(IVolumeHeightFunction self, double V) -> double virtual double +h(double V) const =0 Returns the depth of a given volume. "; + +%feature("docstring") cmf_core::volume_height_function::q "def +q(self, args, kwargs) + +q(IVolumeHeightFunction self, double h, double slope) -> double +virtual double q(double h, double slope) const "; + +%feature("docstring") cmf_core::volume_height_function::V "def +V(self, args, kwargs) + +V(IVolumeHeightFunction self, double h) -> double virtual double +V(double h) const =0 "; + + // File: classcmf_1_1river_1_1volume__height__function.xml %feature("docstring") cmf::river::volume_height_function " @@ -17562,6 +37950,45 @@ Actual flux from layer in m3/day "; %feature("docstring") cmf::upslope::ET::VolumeStress::to_string "std::string to_string() const "; +// File: classcmf__core_1_1_volume_stress.xml +%feature("docstring") cmf_core::VolumeStress " + +A WaterStressFunction based on the stored water volume of a layer. If +the layer contains more water than V1, ET is not limited ( ET=ETpot). +Below V1 ET goes linear to 0.0 at V0 C++ includes: waterstress.h "; + +%feature("docstring") cmf_core::VolumeStress::__init__ "def +__init__(self, args) + +__init__(cmf::upslope::ET::VolumeStress self, real V1, real V0) -> +VolumeStress __init__(cmf::upslope::ET::VolumeStress self, +VolumeStress other) -> VolumeStress VolumeStress(const VolumeStress +&other) "; + +%feature("docstring") cmf_core::VolumeStress::copy "def copy(self, +args, kwargs) + +copy(VolumeStress self) -> VolumeStress +cmf::upslope::ET::VolumeStress* copy() const Creates a new copy of +this wetness. "; + +%feature("docstring") cmf_core::VolumeStress::Tact "def Tact(self, +args, kwargs) + +Tact(RootUptakeStessFunction self, stressedET connection, real Tpot) +-> real virtual real Tact(const stressedET *connection, real Tpot) +const =0 Calculates the water stress for a layer. Parameters: +----------- connection: The stressedET connection this stress +function belongs to Tpot: Potential Transpiration in mm/day (for the +full profile) Actual flux from layer in m3/day "; + +%feature("docstring") cmf_core::VolumeStress::to_string "def +to_string(self, args, kwargs) + +to_string(RootUptakeStessFunction self) -> std::string virtual +std::string to_string() const =0 "; + + // File: classcmf_1_1water_1_1waterbalance__connection.xml %feature("docstring") cmf::water::waterbalance_connection " @@ -17670,6 +38097,122 @@ std::string short_string() const "; "virtual std::string to_string() const "; +// File: classcmf__core_1_1waterbalance__connection.xml +%feature("docstring") cmf_core::waterbalance_connection " + +Routes the sum of all other fluxes to a target. .. math:: q_{1,0} = +\\\\\\\\sum_{i=2}^N{q_{1,i}(V_1,V_i,t)} where: :math:`q_{i,j}` is the +flux between the two node i and j. Subscript 0 is the right node, +subscript 1 is the left node and 2..N are the nodes connected to the +left node, except for the right node C++ includes: +simple_connections.h "; + +%feature("docstring") cmf_core::waterbalance_connection::__init__ "def __init__(self, args, kwargs) + +__init__(cmf::water::waterbalance_connection self, +cmf::water::flux_node::ptr source, cmf::water::flux_node::ptr target) +-> waterbalance_connection waterbalance_connection(flux_node::ptr +source, flux_node::ptr target) "; + +%feature("docstring") cmf_core::waterbalance_connection::__contains__ +"def __contains__(self, cmp) "; + +%feature("docstring") cmf_core::waterbalance_connection::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_connection self, flux_connection other) -> bool "; + +%feature("docstring") cmf_core::waterbalance_connection::__getitem__ +"def __getitem__(self, index) "; + +%feature("docstring") cmf_core::waterbalance_connection::__iter__ "def __iter__(self) "; + +%feature("docstring") cmf_core::waterbalance_connection::__repr__ "def __repr__(self) "; + +%feature("docstring") cmf_core::waterbalance_connection::conc "def +conc(self, args, kwargs) + +conc(flux_connection self, Time t, solute _Solute) -> real real +conc(cmf::math::Time t, const cmf::water::solute &_Solute) Returns +the concentration of the flux. If not overridden, it returns the +concentration of the source of the flux (direction depending) "; + +%feature("docstring") +cmf_core::waterbalance_connection::exchange_target "def +exchange_target(self, args, kwargs) + +exchange_target(flux_connection self, cmf::water::flux_node::ptr +oldtarget, cmf::water::flux_node::ptr newTarget) void +exchange_target(flux_node::ptr oldtarget, flux_node::ptr newTarget) "; + +%feature("docstring") cmf_core::waterbalance_connection::get_target "def get_target(self, args) + +get_target(flux_connection self, flux_node inquirer) -> +cmf::water::flux_node::ptr get_target(flux_connection self, int index) +-> cmf::water::flux_node::ptr flux_node::ptr get_target(int index) +const With index 0, the left node is returned, with index 1 the right +node of the connection. "; + +%feature("docstring") +cmf_core::waterbalance_connection::get_tracer_filter "def +get_tracer_filter(self, args) + +get_tracer_filter(flux_connection self) -> real +get_tracer_filter(flux_connection self, solute S) -> real real +get_tracer_filter(solute S) A value ranging from 0 to 1 to filter +tracers out of the water flux. "; + +%feature("docstring") cmf_core::waterbalance_connection::kill_me "def kill_me(self, args, kwargs) + +kill_me(flux_connection self) -> bool bool kill_me() Deregisters +this connection from its nodes. Returns true if only one reference is +left. "; + +%feature("docstring") cmf_core::waterbalance_connection::left_node "def left_node(self, args, kwargs) + +left_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr left_node() const Returns the left node of this +connection. "; + +%feature("docstring") cmf_core::waterbalance_connection::q "def +q(self, args, kwargs) + +q(flux_connection self, flux_node inquirer, Time t) -> real real +q(const flux_node &inquirer, cmf::math::Time t) Returns the current +flux through a connection. Negative signs mean out of the inquirer, +positive are inflows to the inquirer. "; + +%feature("docstring") cmf_core::waterbalance_connection::refresh "def refresh(self, args, kwargs) + +refresh(flux_connection self, Time t) void refresh(cmf::math::Time t) +Performes a new calculation of the flux. "; + +%feature("docstring") cmf_core::waterbalance_connection::right_node "def right_node(self, args, kwargs) + +right_node(flux_connection self) -> cmf::water::flux_node::ptr +flux_node::ptr right_node() const returns the right node of this +connection "; + +%feature("docstring") +cmf_core::waterbalance_connection::set_tracer_filter "def +set_tracer_filter(self, args) + +set_tracer_filter(flux_connection self, real value) +set_tracer_filter(flux_connection self, solute S, real value) void +set_tracer_filter(solute S, real value) "; + +%feature("docstring") cmf_core::waterbalance_connection::short_string +"def short_string(self, args, kwargs) + +short_string(flux_connection self) -> std::string virtual std::string +short_string() const "; + +%feature("docstring") cmf_core::waterbalance_connection::to_string "def to_string(self, args, kwargs) + +to_string(flux_connection self) -> std::string virtual std::string +to_string() const "; + + // File: classcmf_1_1water_1_1waterbalance__integrator.xml %feature("docstring") cmf::water::waterbalance_integrator " @@ -17720,6 +38263,58 @@ time [m3]. "; Returns the start time of the integration. "; +// File: classcmf__core_1_1waterbalance__integrator.xml +%feature("docstring") cmf_core::waterbalance_integrator " + +The waterbalance_integrator is an integratable for precise output of +the average water balance of a flux_node over time. It can be added +to a solver (any cmf::math::Integrator), which is than calling the +integrate method at each substep. C++ includes: flux_node.h "; + +%feature("docstring") cmf_core::waterbalance_integrator::__init__ "def __init__(self, args, kwargs) + +__init__(cmf::water::waterbalance_integrator self, +cmf::water::flux_node::ptr node) -> waterbalance_integrator +waterbalance_integrator(cmf::water::flux_node::ptr node) "; + +%feature("docstring") cmf_core::waterbalance_integrator::avg "def +avg(self, args, kwargs) + +avg(integratable self) -> double virtual double avg() const =0 +Returns average of the integrated variable (eg. flux) from the last +reset until the last call of integrate. "; + +%feature("docstring") cmf_core::waterbalance_integrator::integrate "def integrate(self, args, kwargs) + +integrate(integratable self, Time t) virtual void integrate(Time t)=0 +Integrates the variable until time t. "; + +%feature("docstring") +cmf_core::waterbalance_integrator::integration_t "def +integration_t(self, args, kwargs) + +integration_t(waterbalance_integrator self) -> Time cmf::math::Time +integration_t() const Returns the duration of the integration. "; + +%feature("docstring") cmf_core::waterbalance_integrator::reset "def +reset(self, args, kwargs) + +reset(integratable self, Time t) virtual void reset(Time t)=0 Sets +the start time of the integral. "; + +%feature("docstring") cmf_core::waterbalance_integrator::sum "def +sum(self, args, kwargs) + +sum(integratable self) -> double virtual double sum() const =0 Get +the integral from the last reset until the last call of integrate. "; + +%feature("docstring") cmf_core::waterbalance_integrator::t0 "def +t0(self, args, kwargs) + +t0(waterbalance_integrator self) -> Time cmf::math::Time t0() const +Returns the start time of the integration. "; + + // File: classcmf_1_1water_1_1_water_storage.xml %feature("docstring") cmf::water::WaterStorage " @@ -17777,6 +38372,10 @@ InitialState: Initial water content in m3 scale: A kind of \"standard size\" in m3 of the water storage to scale tolerances, default 1m3 "; +%feature("docstring") cmf::water::WaterStorage::add_connected_states +"virtual void add_connected_states(cmf::math::StateVariable::list +&states) "; + %feature("docstring") cmf::water::WaterStorage::conc "real conc(const cmf::water::solute &_Solute) const @@ -17798,9 +38397,7 @@ Sets a new concentration. "; Returns the connection between this and target. "; %feature("docstring") cmf::water::WaterStorage::dxdt "virtual real -dxdt(const cmf::math::Time &time) - -Returns the derivate of the state variable at time time. "; +dxdt(const cmf::math::Time &time) "; %feature("docstring") cmf::water::WaterStorage::flux3d_to "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, cmf::math::Time t) "; @@ -17850,6 +38447,10 @@ real get_volume() const Returns the volume of water in this storage in m3 "; +%feature("docstring") cmf::water::WaterStorage::is_connected "virtual bool is_connected(const cmf::math::StateVariable &other) const + +Returns True if this waterstorage is effected by another state. "; + %feature("docstring") cmf::water::WaterStorage::is_storage "virtual bool is_storage() const @@ -17870,36 +38471,323 @@ set_state(real newState) "; cmf::water::WaterStorage::set_state_variable_content "void set_state_variable_content(char content) -A character indicating the integrated variable (either 'V' for Volume -or 'h' for head) "; +A character indicating the integrated variable (either 'V' for Volume +or 'h' for head) "; + +%feature("docstring") cmf::water::WaterStorage::set_volume "virtual +void set_volume(real newwatercontent) + +Sets the volume of water in this storage in m3 "; + +%feature("docstring") cmf::water::WaterStorage::Solute "SoluteStorage& Solute(const cmf::water::solute _Solute) + +Returns the water quality of the water storage. "; + +%feature("docstring") cmf::water::WaterStorage::Solute "const +SoluteStorage& Solute(const cmf::water::solute _Solute) const "; + +%feature("docstring") cmf::water::WaterStorage::waterbalance "real +waterbalance(cmf::math::Time t, const flux_connection *Without=0) +const + +Returns the sum of all fluxes (positive and negative) at time t. + +Single fluxes can be excluded from the calculation + +Parameters: +----------- + +t: Time of the query + +Without: A flux_connection that is excluded from the waterbalance +(e.g. to prevent closed circuits) "; + + +// File: classcmf__core_1_1_water_storage.xml +%feature("docstring") cmf_core::WaterStorage " + +A state variable for the storage of water. A class for the storage of +water. The state is the volume of water stored in :math:`m^3` The +derivative function is given by: .. math:: +\\\\\\\\frac{dV}{dt}&=&\\\\\\\\sum_{f=1}^{F} q_f \\\\\\\\\\\\\\\\ F&=& +\\\\\\\\mbox{Number of fluxes in water storage} \\\\\\\\\\\\\\\\ +q_f&=& \\\\\\\\mbox{Water flux in } \\\\\\\\frac{m^3}{day} +\\\\\\\\\\\\\\\\ Todo Check the head based state mode C++ +includes: WaterStorage.h "; + +%feature("docstring") cmf_core::WaterStorage::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::water::WaterStorage self, project project, std::string +const & Name, double InitialState=0, double scale=1) -> WaterStorage +WaterStorage(cmf::project &project, const std::string &Name=\"\", +double InitialState=0, double scale=1) creates a water storage +(abstract class) Parameters: ----------- project: The project the +waterstorage belongs to Name: Name of the water storage +InitialState: Initial water content in m3 scale: A kind of +\"standard size\" in m3 of the water storage to scale tolerances, +default 1m3 "; + +%feature("docstring") cmf_core::WaterStorage::__call__ "def +__call__(self, args, kwargs) + +__call__(flux_node self, Time t) -> real "; + +%feature("docstring") cmf_core::WaterStorage::__eq__ "def +__eq__(self, args, kwargs) + +__eq__(flux_node self, flux_node other) -> bool "; + +%feature("docstring") cmf_core::WaterStorage::__getitem__ "def +__getitem__(self, args, kwargs) + +__getitem__(WaterStorage self, solute X) -> SoluteStorage "; + +%feature("docstring") cmf_core::WaterStorage::__repr__ "def +__repr__(self) "; + +%feature("docstring") cmf_core::WaterStorage::cast "def cast(args, +kwargs) + +cast(std::shared_ptr< cmf::water::flux_node > node) -> +std::shared_ptr< cmf::water::WaterStorage > "; + +%feature("docstring") cmf_core::WaterStorage::conc "def conc(self, +args, kwargs) + +conc(flux_node self, Time t, solute Solute) -> real virtual real +conc(cmf::math::Time t, const cmf::water::solute &Solute) const +Returns the water quality of the flux_node, if it is not overridden +this is the mix of the incoming fluxes. "; + +%feature("docstring") cmf_core::WaterStorage::conc "def conc(self, +args) + +conc(WaterStorage self, solute _Solute) -> real conc(WaterStorage +self, Time t, solute _Solute) -> real conc(WaterStorage self, solute +_Solute, real NewConcetration) void conc(const cmf::water::solute +&_Solute, real NewConcetration) Sets a new concentration. "; + +%feature("docstring") cmf_core::WaterStorage::connected_nodes "def +connected_nodes(self) "; + +%feature("docstring") cmf_core::WaterStorage::connection_to "def +connection_to(self, args, kwargs) + +connection_to(flux_node self, flux_node target) -> flux_connection +cmf::water::flux_connection* connection_to(const cmf::water::flux_node +&target) Returns the connection between this and target. "; + +%feature("docstring") cmf_core::WaterStorage::create "def +create(args, kwargs) + +create(project _project, real initial_state=0.0, real scale=1.0) -> +std::shared_ptr< cmf::water::WaterStorage > "; + +%feature("docstring") cmf_core::WaterStorage::dxdt "def dxdt(self, +args, kwargs) + +dxdt(StateVariable self, Time time) -> real virtual real dxdt(const +cmf::math::Time &time)=0 Returns the derivate of the state variable +at time time. "; + +%feature("docstring") cmf_core::WaterStorage::flux3d_to "def +flux3d_to(self, args, kwargs) + +flux3d_to(flux_node self, flux_node target, Time t) -> point +cmf::geometry::point flux3d_to(const cmf::water::flux_node &target, +cmf::math::Time t) "; + +%feature("docstring") cmf_core::WaterStorage::flux_to "def +flux_to(self, args, kwargs) + +flux_to(flux_node self, flux_node target, Time t) -> real real +flux_to(const cmf::water::flux_node &target, cmf::math::Time t) +Returns the actual flux between this and target (positive sign means +\"from this into target\") "; + +%feature("docstring") cmf_core::WaterStorage::fluxes "def +fluxes(self, t) "; + +%feature("docstring") cmf_core::WaterStorage::from_node "def +from_node(args, kwargs) + +from_node(cmf::water::flux_node::ptr node) -> std::shared_ptr< +cmf::water::WaterStorage > "; + +%feature("docstring") cmf_core::WaterStorage::get_3d_flux "def +get_3d_flux(self, args, kwargs) + +get_3d_flux(flux_node self, Time t) -> point cmf::geometry::point +get_3d_flux(cmf::math::Time t) Returns the sum of all flux vectors. +"; + +%feature("docstring") cmf_core::WaterStorage::get_abs_errtol "def +get_abs_errtol(self, args, kwargs) + +get_abs_errtol(StateVariable self, real rel_errtol) -> real virtual +real get_abs_errtol(real rel_errtol) const "; + +%feature("docstring") cmf_core::WaterStorage::get_states "def +get_states(self, args, kwargs) + +get_states(StateVariableOwner self) -> StateVariableList virtual +StateVariableList get_states()=0 Add the state variables, owned by an +object derived from StateVariableOwner, to the given vector. "; + +%feature("docstring") cmf_core::WaterStorage::is_connected "def +is_connected(self, args, kwargs) + +is_connected(StateVariable self, StateVariable other) -> bool virtual +bool is_connected(const cmf::math::StateVariable &other) const "; + +%feature("docstring") cmf_core::WaterStorage::is_empty "def +is_empty(self, args, kwargs) + +is_empty(flux_node self) -> double virtual double is_empty() const +Returns true if the node has no water. "; + +%feature("docstring") cmf_core::WaterStorage::is_storage "def +is_storage(self, args, kwargs) + +is_storage(flux_node self) -> bool virtual bool is_storage() const +true, if this is a waterstorage "; + +%feature("docstring") cmf_core::WaterStorage::RecalcFluxes "def +RecalcFluxes(self, args, kwargs) + +RecalcFluxes(flux_node self, Time t) -> bool virtual bool +RecalcFluxes(cmf::math::Time t) Pure flux_nodes do not influence +fluxes, therefore no recalculation of fluxes is required by flux_node. +WaterStorage overrides this, since state changes require an update of +the fluxes "; + +%feature("docstring") cmf_core::WaterStorage::remove_connection "def +remove_connection(self, args, kwargs) + +remove_connection(flux_node self, cmf::water::flux_node::ptr To) -> +bool bool remove_connection(cmf::water::flux_node::ptr To) Remove +the connection. "; + +%feature("docstring") cmf_core::WaterStorage::Solute "def +Solute(self, args) + +Solute(WaterStorage self, solute _Solute) -> SoluteStorage +Solute(WaterStorage self, solute _Solute) -> SoluteStorage const +SoluteStorage& Solute(const cmf::water::solute _Solute) const "; + +%feature("docstring") cmf_core::WaterStorage::to_string "def +to_string(self, args, kwargs) + +to_string(StateVariable self) -> std::string virtual std::string +to_string() const =0 "; + +%feature("docstring") cmf_core::WaterStorage::to_string "def +to_string(self, args, kwargs) + +to_string(flux_node self) -> std::string virtual std::string +to_string() const "; + +%feature("docstring") cmf_core::WaterStorage::waterbalance "def +waterbalance(self, args, kwargs) + +waterbalance(flux_node self, Time t, flux_connection Without=None) -> +real real waterbalance(cmf::math::Time t, const flux_connection +*Without=0) const Returns the sum of all fluxes (positive and +negative) at time t. Single fluxes can be excluded from the +calculation Parameters: ----------- t: Time of the query Without: +A flux_connection that is excluded from the waterbalance (e.g. to +prevent closed circuits) "; + + +// File: classcmf__core_1_1_weather.xml +%feature("docstring") cmf_core::Weather " + +A structure holding meteorological information, excluding +precipitation C++ includes: Weather.h "; + +%feature("docstring") cmf_core::Weather::__init__ "def +__init__(self, args, kwargs) + +__init__(cmf::atmosphere::Weather self, double T=15.0, double +Tmax=17.0, double Tmin=13.0, double rH=70.0, double wind=2.0, double +sunshine=0.5, double Rs=15, double Ra=30, double daylength=12) -> +Weather Weather(double T=15.0, double Tmax=17.0, double Tmin=13.0, +double rH=70.0, double wind=2.0, double sunshine=0.5, double Rs=15, +double daylength=12) Creates a \"weather\" from given data. +Parameters: ----------- T: actual Temperature in deg C Tmax: daily +maximum Temperature in deg C Tmin: daily minimum Temperature in deg +C rH: actual relative humidity in % [0..100] wind: actual wind +speed in m/s sunshine: actual fraction of sunshine duration per +potential sunshine duration in h/h Rs: actual incoming shortwave +global radiation in MJ/(m2 day) daylength: length of the day in h "; + +%feature("docstring") cmf_core::Weather::__add__ "def __add__(self, +args, kwargs) + +__add__(Weather self, Weather w) -> Weather "; + +%feature("docstring") cmf_core::Weather::__iadd__ "def +__iadd__(self, args, kwargs) + +__iadd__(Weather self, Weather w) -> Weather "; + +%feature("docstring") cmf_core::Weather::__imul__ "def +__imul__(self, args, kwargs) + +__imul__(Weather self, double factor) -> Weather "; + +%feature("docstring") cmf_core::Weather::__mul__ "def __mul__(self, +args, kwargs) -%feature("docstring") cmf::water::WaterStorage::set_volume "virtual -void set_volume(real newwatercontent) +__mul__(Weather self, double factor) -> Weather "; -Sets the volume of water in this storage in m3 "; +%feature("docstring") cmf_core::Weather::__repr__ "def +__repr__(self) "; -%feature("docstring") cmf::water::WaterStorage::Solute "SoluteStorage& Solute(const cmf::water::solute _Solute) +%feature("docstring") cmf_core::Weather::__str__ "def __str__(self) +"; -Returns the water quality of the water storage. "; +%feature("docstring") cmf_core::Weather::get_snow_threshold "def +get_snow_threshold(args, kwargs) -%feature("docstring") cmf::water::WaterStorage::Solute "const -SoluteStorage& Solute(const cmf::water::solute _Solute) const "; +get_snow_threshold() -> double "; -%feature("docstring") cmf::water::WaterStorage::waterbalance "real -waterbalance(cmf::math::Time t, const flux_connection *Without=0) -const +%feature("docstring") cmf_core::Weather::Rn "def Rn(self, args, +kwargs) -Returns the sum of all fluxes (positive and negative) at time t. +Rn(Weather self, double albedo, bool daily=False) -> double double +Rn(double albedo, bool daily=false) const Calculates the net +radiation flux :math:`R_n \\\\\\\\left[\\\\\\\\frac{MJ}{m^2 +day}\\\\\\\\right]`. .. math:: R_{n} &=& R_{ns} - R_{nl} +\\\\\\\\\\\\\\\\ \\\\\\\\mbox{ Net short wave radiation: }R_{ns} +&=& (1-\\\\\\\\alpha) R_s \\\\\\\\\\\\\\\\ \\\\\\\\mbox{ Net long +wave radiation: }R_{nl} &=& R_{black}\\\\\\\\ \\\\\\\\beta_{v}\\\\\\\\ +\\\\\\\\beta_{c} \\\\\\\\\\\\\\\\ \\\\\\\\mbox{Black body radiation: } +R_{black} &=& \\\\\\\\left\\\\\\\\{\\\\\\\\begin{array}{cl} +\\\\\\\\sigma T^4 & \\\\\\\\mbox{for less than daily time steps} +\\\\\\\\\\\\\\\\ \\\\\\\\sigma \\\\\\\\frac {T_{max}^4 + T_{min}^4} 2 +& \\\\\\\\mbox{for daily time steps} \\\\\\\\end{array} \\\\\\\\right. +\\\\\\\\\\\\\\\\ T &=& \\\\\\\\mbox{Temperature }[K] \\\\\\\\\\\\\\\\ +\\\\\\\\sigma &=& 4.903\\\\\\\\ 10^{-9} \\\\\\\\frac{MJ}{K^4 m^2 +day} \\\\\\\\mbox{ Stefan- Boltzmann constant } \\\\\\\\\\\\\\\\ +\\\\\\\\mbox{Long wave reflectance: } \\\\\\\\\\\\\\\\ \\\\\\\\mbox{by +water vapor: }\\\\\\\\beta_{v} &=& 0.34 - 0.14 \\\\\\\\sqrt{e_a} +\\\\\\\\\\\\\\\\ \\\\\\\\mbox{ by clouds: }\\\\\\\\beta_{c} &=& 0.1 + +0.9 \\\\\\\\frac n N Parameters: ----------- albedo: the albedo +:math:`\\\\\\\\alpha` of the surface daily: If true, the net +radiation for daily averages will be calculated "; -Single fluxes can be excluded from the calculation +%feature("docstring") cmf_core::Weather::set_snow_threshold "def +set_snow_threshold(args, kwargs) -Parameters: ------------ +set_snow_threshold(double new_threshold) "; -t: Time of the query +%feature("docstring") cmf_core::Weather::to_string "def +to_string(self, args, kwargs) -Without: A flux_connection that is excluded from the waterbalance -(e.g. to prevent closed circuits) "; +to_string(Weather self) -> std::string std::string to_string() const +Returns a string representation. "; // File: structcmf_1_1atmosphere_1_1_weather.xml @@ -17912,7 +38800,7 @@ C++ includes: Weather.h "; %feature("docstring") cmf::atmosphere::Weather::Weather "Weather(double T=15.0, double Tmax=17.0, double Tmin=13.0, double rH=70.0, double wind=2.0, double sunshine=0.5, double Rs=15, double -daylength=12) +Ra=30, double daylength=12) Creates a \"weather\" from given data. @@ -17934,6 +38822,8 @@ duration in h/h Rs: actual incoming shortwave global radiation in MJ/(m2 day) +Ra: actual extraterrestrial shortwave global radiation in MJ/(m2 day) + daylength: length of the day in h "; %feature("docstring") cmf::atmosphere::Weather::Rn "double Rn(double @@ -17945,19 +38835,19 @@ Calculates the net radiation flux :math:`R_n \\\\left[\\\\frac{MJ}{m^2 day}\\\\r .. math:: - R_{n} &=& R_{ns} - R_{nl} \\\\\\\\ \\\\mbox{ Net - short wave radiation: }R_{ns} &=& (1-\\\\alpha) R_s \\\\\\\\ \\\\mbox{ - Net long wave radiation: }R_{nl} &=& R_{black}\\\\ \\\\beta_{v}\\\\ - \\\\beta_{c} \\\\\\\\ \\\\mbox{Black body radiation: } R_{black} &=& + R_{n} = R_{ns} - R_{nl} \\\\\\\\ \\\\mbox{ Net + short wave radiation: }R_{ns} = (1-\\\\alpha) R_s \\\\\\\\ \\\\mbox{ + Net long wave radiation: }R_{nl} = R_{black}\\\\ \\\\beta_{v}\\\\ + \\\\beta_{c} \\\\\\\\ \\\\mbox{Black body radiation: } R_{black} = \\\\left\\\\{\\\\begin{array}{cl} \\\\sigma T^4 & \\\\mbox{for less than daily time steps} \\\\\\\\ \\\\sigma \\\\frac {T_{max}^4 + T_{min}^4} 2 & \\\\mbox{for daily time steps} \\\\end{array} - \\\\right. \\\\\\\\ T &=& \\\\mbox{Temperature }[K] \\\\\\\\ \\\\sigma - &=& 4.903\\\\ 10^{-9} \\\\frac{MJ}{K^4 m^2 day} \\\\mbox{ Stefan- - Boltzmann constant } \\\\\\\\ \\\\mbox{Long wave reflectance: } - \\\\\\\\ \\\\mbox{by water vapor: }\\\\beta_{v} &=& 0.34 - 0.14 - \\\\sqrt{e_a} \\\\\\\\ \\\\mbox{ by clouds: }\\\\beta_{c} &=& 0.1 + - 0.9 \\\\frac n N + \\\\right. \\\\\\\\ T = \\\\mbox{Temperature }[K] \\\\\\\\ \\\\sigma = + 4.903\\\\ 10^{-9} \\\\frac{MJ}{K^4 m^2 day} \\\\mbox{ Stefan-Boltzmann + constant } \\\\\\\\ \\\\mbox{Long wave reflectance: } \\\\\\\\ + \\\\mbox{by water vapor: }\\\\beta_{v} = 0.34 - 0.14 \\\\sqrt{e_a} + \\\\\\\\ \\\\mbox{ by clouds: }\\\\beta_{c} = 0.1 + 0.9 \\\\frac n N + @@ -17978,7 +38868,7 @@ Returns a string representation. "; // File: namespacecmf.xml -%feature("docstring") cmf::atmosphere::connect_cells_with_flux "def +%feature("docstring") cmf::apps::connect_cells_with_flux "def cmf.connect_cells_with_flux(cells, connection, start_at_layer=0) Connects all cells in cells (sequence or generator) with a flux @@ -17988,11 +38878,18 @@ subsurface fluxes and surface manning flux) start_at_layer : if the flux connection should only be used for deeper layers "; +// File: namespacecmf_1_1apps.xml +%feature("docstring") cmf::apps::run_nash_cascade "int +cmf::apps::run_nash_cascade(int size) "; + +%feature("docstring") cmf::apps::run_reaches "int +cmf::apps::run_reaches(int levels, SolverType solver, int steps=0) "; + + // File: namespacecmf_1_1atmosphere.xml -%feature("docstring") cmf::atmosphere::global_radiation "double -cmf::atmosphere::global_radiation(cmf::math::Time t, double height, -double sunshine_fraction, double longitude=8, double latitude=51, -double time_zone=1, bool daily=0) +%feature("docstring") cmf::atmosphere::extraterrestrial_radiation "double cmf::atmosphere::extraterrestrial_radiation(cmf::math::Time t, +double longitude=8, double latitude=51, double time_zone=1, bool +daily=0) Calculates the global radiation in MJ/(m2 day) from the sun position and the sunshine fraction. @@ -18002,11 +38899,6 @@ Parameters: t: actual time step -height: Height above sea level - -sunshine_fraction: Fraction of sunshine hours per potential sunshine -duration in h/h - longitude: latitude: Geographical position in degree. Latitude is only taken into acount for subdaily calculation @@ -18020,43 +38912,66 @@ the current hour is returned The calculation of the global radiation followshttp://www.fao.org/docrep/X0490E/x0490e07.htm#radiation. -The following formula is used: +The following formula is used: :math:`\\\\phi` Latitude in :math:`rad` -.. math:: +:math:`\\\\delta = 0.409 \\\\sin\\\\left(\\\\frac{2\\\\pi}{365}DOY - 1.39\\\\right)` Declination, DOY is day of year - \\\\phi &=& - \\\\frac{(\\\\mbox{geogr. Latitude})^\\\\circ \\\\pi}{180^\\\\circ} - \\\\mbox{ Latitude in }rad \\\\\\\\ \\\\delta &=& 0.409 - \\\\sin\\\\left(\\\\frac{2\\\\pi}{365}DOY - 1.39\\\\right) \\\\mbox{ - Declination, DOY is day of year}\\\\\\\\ \\\\omega_s &=& - \\\\arccos(-\\\\tan\\\\phi\\\\tan\\\\delta) \\\\mbox{ Sunset angle} - \\\\\\\\ G_{sc} &=& 0.0802 \\\\frac{MJ}{m^2min} \\\\mbox{Solar - constant} \\\\\\\\ d_r &=& 1+0.033 - \\\\cos\\\\left(\\\\frac{2\\\\pi}{365}DOY\\\\right) \\\\mbox{Inverse - relative distance Earth-Sun} \\\\\\\\ b &=& - \\\\frac{2\\\\pi(DOY-81)}{364}\\\\\\\\ S_c &=& - 0.1645\\\\sin(2b)-0.1255\\\\cos(b)-0.025\\\\sin(b) \\\\mbox{ Seasonal - correction for solar time} \\\\\\\\ \\\\omega &=& \\\\frac {\\\\pi} - {12} \\\\left(t_h+\\\\frac{(\\\\mbox{geogr. - Longitude})^\\\\circ}{15}-\\\\mbox{Timezone}+S_c-12\\\\right) - \\\\mbox{ solar time in }rad \\\\\\\\ \\\\mbox{If daily} \\\\\\\\ R_a - &=& \\\\frac{24\\\\ 60}{\\\\pi}G_{sc}\\\\ d_r \\\\left(\\\\omega_s - \\\\sin\\\\phi \\\\sin\\\\delta + \\\\cos\\\\phi \\\\cos\\\\delta - \\\\sin\\\\omega_s\\\\right) \\\\mbox{Extraterrestrial radiation } - \\\\frac{MJ}{m^2 day} \\\\\\\\ \\\\mbox{If hourly} \\\\\\\\ R_a &=& - \\\\frac{12\\\\ 24\\\\ 60}{\\\\pi}G_{sc}\\\\ d_r - \\\\left(\\\\left(\\\\omega^+ -\\\\omega^-\\\\right) \\\\sin\\\\phi - \\\\sin\\\\delta + \\\\cos\\\\phi \\\\cos\\\\delta - \\\\left(\\\\sin\\\\omega^+ - \\\\sin\\\\omega^-\\\\right)\\\\right) - \\\\\\\\ && \\\\omega^+,\\\\omega^- = \\\\omega - \\\\pm\\\\frac{\\\\pi}{24} \\\\\\\\ \\\\frac n N &=& - \\\\mbox{Fractional sunshine duration} \\\\\\\\ R_s &=& - \\\\left(0.25+\\\\left(0.5+2\\\\ - 10^{-5}z\\\\right)\\\\frac{n}{N}\\\\right)R_a \\\\mbox{Global - radiation in }\\\\frac{MJ}{m^2 day} \\\\\\\\ && z=\\\\mbox{Height - a.s.l. in }m \\\\\\\\ +:math:`\\\\omega_s = \\\\arccos(-\\\\tan\\\\phi\\\\tan\\\\delta)` Sunset +angle - "; +:math:`G_{sc} = 0.0802 \\\\frac{MJ}{m^2min}` Solar constant + +:math:`d_r = 1+0.033 \\\\cos\\\\left(\\\\frac{2\\\\pi}{365}DOY\\\\right)` +Inverse relative distance Earth-Sun + +:math:`b = \\\\frac{2\\\\pi(DOY-81)}{364}` + +:math:`S_c = 0.1645\\\\sin(2b)-0.1255\\\\cos(b)-0.025\\\\sin(b)` Seasonal +correction for solar time + +:math:`\\\\omega = \\\\frac{\\\\pi}{12} \\\\left(t_h+\\\\frac{(\\\\mbox{geogr. Longitude})^\\\\circ}{15^\\\\circ}-\\\\mbox{Timezone}+S_c-12\\\\right)` solar time in :math:`rad` + +If daily: :math:`R_a = \\\\frac{24\\\\ 60}{\\\\pi}G_{sc}\\\\ d_r \\\\left(\\\\omega_s \\\\sin\\\\phi \\\\sin\\\\delta + \\\\cos\\\\phi \\\\cos\\\\delta \\\\sin\\\\omega_s\\\\right)` + +If sub daily: :math:`R_a = \\\\frac{12\\\\ 24\\\\ 60}{\\\\pi}G_{sc}\\\\ d_r \\\\left(\\\\left(\\\\omega^+ -\\\\omega^-\\\\right) \\\\sin\\\\phi \\\\sin\\\\delta + \\\\cos\\\\phi \\\\cos\\\\delta \\\\left(\\\\sin\\\\omega^+ - \\\\sin\\\\omega^-\\\\right)\\\\right)` + +:math:`\\\\omega^+,\\\\omega^- = \\\\omega \\\\pm\\\\frac{\\\\pi}{24}` "; + +%feature("docstring") cmf::atmosphere::global_radiation "double +cmf::atmosphere::global_radiation(double Ra, double height, double +sunshine_fraction) + +Calculates the global radiation in MJ/(m2 day) from the sun position +and the sunshine fraction. + +Parameters: +----------- + +Ra: extra terrestrial radiation + +height: Height above sea level + +sunshine_fraction: Fraction of sunshine hours per potential sunshine +duration in h/h + +The calculation of the global radiation +followshttp://www.fao.org/docrep/X0490E/x0490e07.htm#radiation. + +The following formula is used: :math:`R_a(t, \\\\phi, \\\\lambda)` +Extraterrestrial radiation ( +cmf::atmosphere::extraterrestrial_radiation) :math:`\\\\frac{MJ}{m^2 day}` + +:math:`\\\\frac n N` Fractional sunshine duration + +:math:`R_s = \\\\left(0.25+\\\\left(0.5+2\\\\ 10^{-5}z\\\\right)\\\\frac{n}{N}\\\\right)R_a` Global radiation in +:math:`\\\\frac{MJ}{m^2 day}` + +:math:`z`: Height a.s.l. in m "; + +%feature("docstring") cmf::atmosphere::MJ_to_watts "double +cmf::atmosphere::MJ_to_watts(double MJ) + +Transforms an energy flux from MJ/day to W. "; %feature("docstring") cmf::atmosphere::Pressure "double cmf::atmosphere::Pressure(double height) @@ -18135,6 +39050,11 @@ rH: Rel. humidity in % :math:`e_s(T)` is calculated using cmf::atmosphere::vapor_pressure(double) "; +%feature("docstring") cmf::atmosphere::watts_to_MJ "double +cmf::atmosphere::watts_to_MJ(double Watts) + +Transforms an energy flux from W to MJ/day. "; + // File: namespacecmf_1_1describe.xml %feature("docstring") cmf::describe::describe "def @@ -18248,9 +39168,6 @@ warnings :return: "; // File: namespacecmf_1_1geometry_1_1qtree.xml -// File: namespacecmf_1_1geos__shapereader.xml - - // File: namespacecmf_1_1jacobian.xml %feature("docstring") cmf::jacobian::connected_states "def cmf.jacobian.connected_states(states) @@ -18554,976 +39471,730 @@ boundary condition, providing the potential of the lower node. "; // File: namespacecmf__core.xml +%feature("docstring") cmf_core::aquifer_cast "def +cmf_core.aquifer_cast(args, kwargs) +aquifer_cast(cmf::water::flux_node::ptr for_cast) -> +cmf::upslope::aquifer::ptr "; -// File: namespacestd.xml -%feature("docstring") std::isfinite "bool std::isfinite(double v) "; - -%feature("docstring") std::to_string "std::string std::to_string(T -val) "; - - -// File: ____init_____8py.xml - - -// File: draw_2____init_____8py.xml - - -// File: geometry_2____init_____8py.xml - - -// File: meteorology_8h.xml - - -// File: precipitation_8h.xml - - -// File: _weather_8h.xml - - -// File: cmfmemory_8h.xml - - -// File: geometry_8h.xml - - -// File: bdf2_8h.xml - - -// File: cvodeintegrator_8h.xml - - -// File: explicit__euler_8h.xml - - -// File: implicit__euler_8h.xml - - -// File: integrator_8h.xml - +%feature("docstring") cmf_core::AsCMFtime "def +cmf_core.AsCMFtime(date) -// File: multiintegrator_8h.xml - - -// File: _r_k_fintegrator_8h.xml +Converts a python datetime to cmf.Time "; +%feature("docstring") cmf_core::boltzmann "def +cmf_core.boltzmann(args, kwargs) -// File: cvode_8h.xml -%feature("docstring") CVode "SUNDIALS_EXPORT int CVode(void -*cvode_mem, realtype tout, N_Vector yout, realtype *tret, int itask) -"; +boltzmann(real x, real x_half, real tau) -> real "; -%feature("docstring") CVodeCreate "SUNDIALS_EXPORT void* -CVodeCreate(int lmm, int iter) "; - -%feature("docstring") CVodeFree "SUNDIALS_EXPORT void CVodeFree(void -**cvode_mem) "; +%feature("docstring") +cmf_core::BrooksCoreyRetentionCurve_CreateFrom2Points "def +cmf_core.BrooksCoreyRetentionCurve_CreateFrom2Points(args, kwargs) -%feature("docstring") CVodeGetActualInitStep "SUNDIALS_EXPORT int -CVodeGetActualInitStep(void *cvode_mem, realtype *hinused) "; +BrooksCoreyRetentionCurve_CreateFrom2Points(real ksat, real porosity, +real theta1, real theta2, real psi_1, real psi_2) -> +BrooksCoreyRetentionCurve "; -%feature("docstring") CVodeGetCurrentOrder "SUNDIALS_EXPORT int -CVodeGetCurrentOrder(void *cvode_mem, int *qcur) "; +%feature("docstring") cmf_core::can_set_flux "def +cmf_core.can_set_flux(args, kwargs) -%feature("docstring") CVodeGetCurrentStep "SUNDIALS_EXPORT int -CVodeGetCurrentStep(void *cvode_mem, realtype *hcur) "; +can_set_flux(cmf::water::flux_node::ptr source, +cmf::water::flux_node::ptr target) -> bool bool +cmf::water::can_set_flux(flux_node::ptr source, flux_node::ptr target) +Checks if a constant flux between two nodes can be set. Returns true +if the nodes are connected by an external_control_connection "; -%feature("docstring") CVodeGetCurrentTime "SUNDIALS_EXPORT int -CVodeGetCurrentTime(void *cvode_mem, realtype *tcur) "; +%feature("docstring") cmf_core::CanopyOverflow_use_for_cell "def +cmf_core.CanopyOverflow_use_for_cell(args, kwargs) -%feature("docstring") CVodeGetDky "SUNDIALS_EXPORT int -CVodeGetDky(void *cvode_mem, realtype t, int k, N_Vector dky) "; +CanopyOverflow_use_for_cell(Cell cell) -> CanopyOverflow "; -%feature("docstring") CVodeGetErrWeights "SUNDIALS_EXPORT int -CVodeGetErrWeights(void *cvode_mem, N_Vector eweight) "; +%feature("docstring") cmf_core::cell2cellflux "def +cmf_core.cell2cellflux(args, kwargs) -%feature("docstring") CVodeGetEstLocalErrors "SUNDIALS_EXPORT int -CVodeGetEstLocalErrors(void *cvode_mem, N_Vector ele) "; +cell2cellflux(Cell source, Cell target, Time t, bool +subsurface_only=False) -> cmf::math::num_array "; -%feature("docstring") CVodeGetIntegratorStats "SUNDIALS_EXPORT int -CVodeGetIntegratorStats(void *cvode_mem, long int *nsteps, long int -*nfevals, long int *nlinsetups, long int *netfails, int *qlast, int -*qcur, realtype *hinused, realtype *hlast, realtype *hcur, realtype -*tcur) "; +%feature("docstring") cmf_core::cell_distance "def +cmf_core.cell_distance(args, kwargs) -%feature("docstring") CVodeGetLastOrder "SUNDIALS_EXPORT int -CVodeGetLastOrder(void *cvode_mem, int *qlast) "; +cell_distance(Cell c1, Cell c2) -> double "; -%feature("docstring") CVodeGetLastStep "SUNDIALS_EXPORT int -CVodeGetLastStep(void *cvode_mem, realtype *hlast) "; +%feature("docstring") cmf_core::cell_flux_directions "def +cmf_core.cell_flux_directions(args, kwargs) -%feature("docstring") CVodeGetNonlinSolvStats "SUNDIALS_EXPORT int -CVodeGetNonlinSolvStats(void *cvode_mem, long int *nniters, long int -*nncfails) "; +cell_flux_directions(cell_vector cells, Time arg2) -> point_vector "; -%feature("docstring") CVodeGetNumErrTestFails "SUNDIALS_EXPORT int -CVodeGetNumErrTestFails(void *cvode_mem, long int *netfails) "; +%feature("docstring") cmf_core::cell_positions "def +cmf_core.cell_positions(args, kwargs) -%feature("docstring") CVodeGetNumGEvals "SUNDIALS_EXPORT int -CVodeGetNumGEvals(void *cvode_mem, long int *ngevals) "; +cell_positions(cell_vector cells) -> point_vector "; -%feature("docstring") CVodeGetNumLinSolvSetups "SUNDIALS_EXPORT int -CVodeGetNumLinSolvSetups(void *cvode_mem, long int *nlinsetups) "; +%feature("docstring") cmf_core::connect_cells_with_flux "def +cmf_core.connect_cells_with_flux(args, kwargs) -%feature("docstring") CVodeGetNumNonlinSolvConvFails "SUNDIALS_EXPORT int CVodeGetNumNonlinSolvConvFails(void *cvode_mem, -long int *nncfails) "; +connect_cells_with_flux(cell_vector cells, CellConnector connect, int +start_at_layer=0) "; -%feature("docstring") CVodeGetNumNonlinSolvIters "SUNDIALS_EXPORT -int CVodeGetNumNonlinSolvIters(void *cvode_mem, long int *nniters) "; +%feature("docstring") cmf_core::count_node_references "def +cmf_core.count_node_references(args, kwargs) -%feature("docstring") CVodeGetNumRhsEvals "SUNDIALS_EXPORT int -CVodeGetNumRhsEvals(void *cvode_mem, long int *nfevals) "; +count_node_references(cmf::water::flux_node::ptr node) -> int int +cmf::water::count_node_references(flux_node::ptr node) "; -%feature("docstring") CVodeGetNumStabLimOrderReds "SUNDIALS_EXPORT -int CVodeGetNumStabLimOrderReds(void *cvode_mem, long int *nslred) "; +%feature("docstring") cmf_core::CVodeIntegrator "def +cmf_core.CVodeIntegrator(project, tolerance=1e-9) -%feature("docstring") CVodeGetNumSteps "SUNDIALS_EXPORT int -CVodeGetNumSteps(void *cvode_mem, long int *nsteps) "; +Backwards compatibility layer for the CVodeIntegrator. Will return a +CVodeKrylov solver as in cmf 1.x. Parameters ---------- project CMF +project tolerance: Solver tolerance Returns ------- CVodeKrylov +The integrator "; -%feature("docstring") CVodeGetReturnFlagName "SUNDIALS_EXPORT char* -CVodeGetReturnFlagName(int flag) "; +%feature("docstring") +cmf_core::DiffusiveSurfaceRunoff_get_linear_slope "def +cmf_core.DiffusiveSurfaceRunoff_get_linear_slope(args) -%feature("docstring") CVodeGetRootInfo "SUNDIALS_EXPORT int -CVodeGetRootInfo(void *cvode_mem, int *rootsfound) "; +DiffusiveSurfaceRunoff_get_linear_slope() -> real "; -%feature("docstring") CVodeGetTolScaleFactor "SUNDIALS_EXPORT int -CVodeGetTolScaleFactor(void *cvode_mem, realtype *tolsfac) "; +%feature("docstring") +cmf_core::DiffusiveSurfaceRunoff_set_linear_slope "def +cmf_core.DiffusiveSurfaceRunoff_set_linear_slope(args, kwargs) -%feature("docstring") CVodeGetWorkSpace "SUNDIALS_EXPORT int -CVodeGetWorkSpace(void *cvode_mem, long int *lenrw, long int *leniw) -"; +DiffusiveSurfaceRunoff_set_linear_slope(real width) "; -%feature("docstring") CVodeInit "SUNDIALS_EXPORT int CVodeInit(void -*cvode_mem, CVRhsFn f, realtype t0, N_Vector y0) "; +%feature("docstring") cmf_core::distance "def +cmf_core.distance(args, kwargs) -%feature("docstring") CVodeReInit "SUNDIALS_EXPORT int -CVodeReInit(void *cvode_mem, realtype t0, N_Vector y0) "; +distance(point p1, point p2) -> double "; -%feature("docstring") CVodeRootInit "SUNDIALS_EXPORT int -CVodeRootInit(void *cvode_mem, int nrtfn, CVRootFn g) "; +%feature("docstring") cmf_core::dot "def cmf_core.dot(args, kwargs) -%feature("docstring") CVodeSetErrFile "SUNDIALS_EXPORT int -CVodeSetErrFile(void *cvode_mem, FILE *errfp) "; +dot(point p1, point p2) -> double "; -%feature("docstring") CVodeSetErrHandlerFn "SUNDIALS_EXPORT int -CVodeSetErrHandlerFn(void *cvode_mem, CVErrHandlerFn ehfun, void -*eh_data) "; +%feature("docstring") cmf_core::EnergyBudgetSnowMelt_use_for_cell "def cmf_core.EnergyBudgetSnowMelt_use_for_cell(args, kwargs) -%feature("docstring") CVodeSetInitStep "SUNDIALS_EXPORT int -CVodeSetInitStep(void *cvode_mem, realtype hin) "; +EnergyBudgetSnowMelt_use_for_cell(Cell cell) "; -%feature("docstring") CVodeSetIterType "SUNDIALS_EXPORT int -CVodeSetIterType(void *cvode_mem, int iter) "; +%feature("docstring") cmf_core::extraterrestrial_radiation "def +cmf_core.extraterrestrial_radiation(args, kwargs) -%feature("docstring") CVodeSetMaxConvFails "SUNDIALS_EXPORT int -CVodeSetMaxConvFails(void *cvode_mem, int maxncf) "; +extraterrestrial_radiation(Time t, double longitude=8, double +latitude=51, double time_zone=1, bool daily=False) -> double "; -%feature("docstring") CVodeSetMaxErrTestFails "SUNDIALS_EXPORT int -CVodeSetMaxErrTestFails(void *cvode_mem, int maxnef) "; +%feature("docstring") cmf_core::fill_sinks "def +cmf_core.fill_sinks(args, kwargs) -%feature("docstring") CVodeSetMaxHnilWarns "SUNDIALS_EXPORT int -CVodeSetMaxHnilWarns(void *cvode_mem, int mxhnil) "; +fill_sinks(cell_vector cells, double min_difference=0.001) -> int "; -%feature("docstring") CVodeSetMaxNonlinIters "SUNDIALS_EXPORT int -CVodeSetMaxNonlinIters(void *cvode_mem, int maxcor) "; +%feature("docstring") cmf_core::find_cell "def +cmf_core.find_cell(args, kwargs) -%feature("docstring") CVodeSetMaxNumSteps "SUNDIALS_EXPORT int -CVodeSetMaxNumSteps(void *cvode_mem, long int mxsteps) "; +find_cell(cell_vector arg1, point p, double max_dist=1e20) -> Cell "; -%feature("docstring") CVodeSetMaxOrd "SUNDIALS_EXPORT int -CVodeSetMaxOrd(void *cvode_mem, int maxord) "; +%feature("docstring") cmf_core::geo_mean "def +cmf_core.geo_mean(args, kwargs) -%feature("docstring") CVodeSetMaxStep "SUNDIALS_EXPORT int -CVodeSetMaxStep(void *cvode_mem, realtype hmax) "; +geo_mean(real a, real b) -> real "; -%feature("docstring") CVodeSetMinStep "SUNDIALS_EXPORT int -CVodeSetMinStep(void *cvode_mem, realtype hmin) "; +%feature("docstring") cmf_core::get_area "def +cmf_core.get_area(args, kwargs) -%feature("docstring") CVodeSetNoInactiveRootWarn "SUNDIALS_EXPORT -int CVodeSetNoInactiveRootWarn(void *cvode_mem) "; +get_area(cell_vector cells) -> double "; -%feature("docstring") CVodeSetNonlinConvCoef "SUNDIALS_EXPORT int -CVodeSetNonlinConvCoef(void *cvode_mem, realtype nlscoef) "; +%feature("docstring") cmf_core::get_boundary_cells "def +cmf_core.get_boundary_cells(args, kwargs) -%feature("docstring") CVodeSetRootDirection "SUNDIALS_EXPORT int -CVodeSetRootDirection(void *cvode_mem, int *rootdir) "; +get_boundary_cells(cell_vector cells) -> cell_vector "; -%feature("docstring") CVodeSetStabLimDet "SUNDIALS_EXPORT int -CVodeSetStabLimDet(void *cvode_mem, booleantype stldet) "; +%feature("docstring") cmf_core::get_center "def +cmf_core.get_center(args, kwargs) -%feature("docstring") CVodeSetStopTime "SUNDIALS_EXPORT int -CVodeSetStopTime(void *cvode_mem, realtype tstop) "; +get_center(cell_vector cells) -> point "; -%feature("docstring") CVodeSetUserData "SUNDIALS_EXPORT int -CVodeSetUserData(void *cvode_mem, void *user_data) "; +%feature("docstring") cmf_core::get_connections "def +cmf_core.get_connections(args, kwargs) -%feature("docstring") CVodeSStolerances "SUNDIALS_EXPORT int -CVodeSStolerances(void *cvode_mem, realtype reltol, realtype abstol) -"; +get_connections(cell_vector cells) -> connection_list "; -%feature("docstring") CVodeSVtolerances "SUNDIALS_EXPORT int -CVodeSVtolerances(void *cvode_mem, realtype reltol, N_Vector abstol) -"; +%feature("docstring") cmf_core::get_higher_node "def +cmf_core.get_higher_node(args, kwargs) -%feature("docstring") CVodeWFtolerances "SUNDIALS_EXPORT int -CVodeWFtolerances(void *cvode_mem, CVEwtFn efun) "; +get_higher_node(cmf::water::flux_node::ptr node1, +cmf::water::flux_node::ptr node2) -> cmf::water::flux_node::ptr +flux_node::ptr cmf::water::get_higher_node(flux_node::ptr node1, +flux_node::ptr node2) "; +%feature("docstring") cmf_core::get_lower_node "def +cmf_core.get_lower_node(args, kwargs) -// File: cvode__band_8h.xml -%feature("docstring") CVBand "SUNDIALS_EXPORT int CVBand(void -*cvode_mem, int N, int mupper, int mlower) "; +get_lower_node(cmf::water::flux_node::ptr node1, +cmf::water::flux_node::ptr node2) -> cmf::water::flux_node::ptr +flux_node::ptr cmf::water::get_lower_node(flux_node::ptr node1, +flux_node::ptr node2) "; +%feature("docstring") cmf_core::get_parallel_threads "def +cmf_core.get_parallel_threads(args) -// File: cvode__bandpre_8h.xml -%feature("docstring") CVBandPrecGetNumRhsEvals "SUNDIALS_EXPORT int -CVBandPrecGetNumRhsEvals(void *cvode_mem, long int *nfevalsBP) "; +get_parallel_threads() -> int "; -%feature("docstring") CVBandPrecGetWorkSpace "SUNDIALS_EXPORT int -CVBandPrecGetWorkSpace(void *cvode_mem, long int *lenrwLS, long int -*leniwLS) "; +%feature("docstring") cmf_core::global_radiation "def +cmf_core.global_radiation(args, kwargs) -%feature("docstring") CVBandPrecInit "SUNDIALS_EXPORT int -CVBandPrecInit(void *cvode_mem, int N, int mu, int ml) "; +global_radiation(double Ra, double height, double sunshine_fraction) +-> double double cmf::atmosphere::global_radiation(cmf::math::Time t, +double height, double sunshine_fraction, double longitude=8, double +latitude=51, double time_zone=1, bool daily=0) Calculates the global +radiation in MJ/(m2 day) from the sun position and the sunshine +fraction. Parameters: ----------- t: actual time step height: +Height above sea level sunshine_fraction: Fraction of sunshine hours +per potential sunshine duration in h/h longitude: latitude: +Geographical position in degree. Latitude is only taken into acount +for subdaily calculation time_zone: Offset by timezone from GMT, eg. +central Europe=1 US west coast = -8 daily: If true, the average +radiation for the whole day is given (therefore latitude and time zone +ignored), otherwise the average of the current hour is returned The +calculation of the global radiation +followshttp://www.fao.org/docrep/X0490E/x0490e07.htm#radiation. The +following formula is used: .. math:: \\\\\\\\phi &=& +\\\\\\\\frac{(\\\\\\\\mbox{geogr. Latitude})^\\\\\\\\circ +\\\\\\\\pi}{180^\\\\\\\\circ} \\\\\\\\mbox{ Latitude in }rad +\\\\\\\\\\\\\\\\ \\\\\\\\delta &=& 0.409 +\\\\\\\\sin\\\\\\\\left(\\\\\\\\frac{2\\\\\\\\pi}{365}DOY - +1.39\\\\\\\\right) \\\\\\\\mbox{ Declination, DOY is day of +year}\\\\\\\\\\\\\\\\ \\\\\\\\omega_s &=& +\\\\\\\\arccos(-\\\\\\\\tan\\\\\\\\phi\\\\\\\\tan\\\\\\\\delta) +\\\\\\\\mbox{ Sunset angle} \\\\\\\\\\\\\\\\ G_{sc} &=& 0.0802 +\\\\\\\\frac{MJ}{m^2min} \\\\\\\\mbox{Solar constant} +\\\\\\\\\\\\\\\\ d_r &=& 1+0.033 +\\\\\\\\cos\\\\\\\\left(\\\\\\\\frac{2\\\\\\\\pi}{365}DOY\\\\\\\\right) +\\\\\\\\mbox{Inverse relative distance Earth-Sun} \\\\\\\\\\\\\\\\ +b &=& \\\\\\\\frac{2\\\\\\\\pi(DOY-81)}{364}\\\\\\\\\\\\\\\\ S_c +&=& 0.1645\\\\\\\\sin(2b)-0.1255\\\\\\\\cos(b)-0.025\\\\\\\\sin(b) +\\\\\\\\mbox{ Seasonal correction for solar time} \\\\\\\\\\\\\\\\ +\\\\\\\\omega &=& \\\\\\\\frac {\\\\\\\\pi} {12} +\\\\\\\\left(t_h+\\\\\\\\frac{(\\\\\\\\mbox{geogr. +Longitude})^\\\\\\\\circ}{15}-\\\\\\\\mbox{Timezone}+S_c-12\\\\\\\\right) +\\\\\\\\mbox{ solar time in }rad \\\\\\\\\\\\\\\\ \\\\\\\\mbox{If +daily} \\\\\\\\\\\\\\\\ R_a &=& \\\\\\\\frac{24\\\\\\\\ +60}{\\\\\\\\pi}G_{sc}\\\\\\\\ d_r \\\\\\\\left(\\\\\\\\omega_s +\\\\\\\\sin\\\\\\\\phi \\\\\\\\sin\\\\\\\\delta + +\\\\\\\\cos\\\\\\\\phi \\\\\\\\cos\\\\\\\\delta +\\\\\\\\sin\\\\\\\\omega_s\\\\\\\\right) \\\\\\\\mbox{Extraterrestrial +radiation } \\\\\\\\frac{MJ}{m^2 day} \\\\\\\\\\\\\\\\ +\\\\\\\\mbox{If hourly} \\\\\\\\\\\\\\\\ R_a &=& +\\\\\\\\frac{12\\\\\\\\ 24\\\\\\\\ 60}{\\\\\\\\pi}G_{sc}\\\\\\\\ d_r +\\\\\\\\left(\\\\\\\\left(\\\\\\\\omega^+ +-\\\\\\\\omega^-\\\\\\\\right) \\\\\\\\sin\\\\\\\\phi +\\\\\\\\sin\\\\\\\\delta + \\\\\\\\cos\\\\\\\\phi +\\\\\\\\cos\\\\\\\\delta \\\\\\\\left(\\\\\\\\sin\\\\\\\\omega^+ - +\\\\\\\\sin\\\\\\\\omega^-\\\\\\\\right)\\\\\\\\right) +\\\\\\\\\\\\\\\\ && \\\\\\\\omega^+,\\\\\\\\omega^- = \\\\\\\\omega +\\\\\\\\pm\\\\\\\\frac{\\\\\\\\pi}{24} \\\\\\\\\\\\\\\\ \\\\\\\\frac n +N &=& \\\\\\\\mbox{Fractional sunshine duration} \\\\\\\\\\\\\\\\ +R_s &=& \\\\\\\\left(0.25+\\\\\\\\left(0.5+2\\\\\\\\ +10^{-5}z\\\\\\\\right)\\\\\\\\frac{n}{N}\\\\\\\\right)R_a +\\\\\\\\mbox{Global radiation in }\\\\\\\\frac{MJ}{m^2 day} +\\\\\\\\\\\\\\\\ && z=\\\\\\\\mbox{Height a.s.l. in }m +\\\\\\\\\\\\\\\\ "; +%feature("docstring") cmf_core::GreenAmptInfiltration_use_for_cell "def cmf_core.GreenAmptInfiltration_use_for_cell(args, kwargs) -// File: cvode__bbdpre_8h.xml -%feature("docstring") CVBBDPrecGetNumGfnEvals "SUNDIALS_EXPORT int -CVBBDPrecGetNumGfnEvals(void *cvode_mem, long int *ngevalsBBDP) "; +GreenAmptInfiltration_use_for_cell(Cell c) "; -%feature("docstring") CVBBDPrecGetWorkSpace "SUNDIALS_EXPORT int -CVBBDPrecGetWorkSpace(void *cvode_mem, long int *lenrwLS, long int -*leniwLS) "; +%feature("docstring") cmf_core::HargreaveET_use_for_cell "def +cmf_core.HargreaveET_use_for_cell(args, kwargs) -%feature("docstring") CVBBDPrecInit "SUNDIALS_EXPORT int -CVBBDPrecInit(void *cvode_mem, int Nlocal, int mudq, int mldq, int -mukeep, int mlkeep, realtype dqrely, CVLocalFn gloc, CVCommFn cfn) "; +HargreaveET_use_for_cell(Cell cell) "; -%feature("docstring") CVBBDPrecReInit "SUNDIALS_EXPORT int -CVBBDPrecReInit(void *cvode_mem, int mudq, int mldq, realtype dqrely) -"; +%feature("docstring") cmf_core::harmonic_mean "def +cmf_core.harmonic_mean(args, kwargs) +harmonic_mean(real a, real b) -> real "; -// File: cvode__dense_8h.xml -%feature("docstring") CVDense "SUNDIALS_EXPORT int CVDense(void -*cvode_mem, int N) "; +%feature("docstring") cmf_core::IDWRainfall_create "def +cmf_core.IDWRainfall_create(args, kwargs) +IDWRainfall_create(project project, point position, double z_weight, +double power) -> cmf::atmosphere::RainSource::ptr "; + +%feature("docstring") cmf_core::integrate_over "def +cmf_core.integrate_over(item, solver=None) + +Returns a suitable cmf.integratable implementation for item, if +available. The created integratable is integrated by solver, if given +"; + +%feature("docstring") cmf_core::MacroPore_cast "def +cmf_core.MacroPore_cast(args, kwargs) + +MacroPore_cast(cmf::water::flux_node::ptr node) -> +cmf::upslope::MacroPore::ptr "; + +%feature("docstring") cmf_core::MacroPore_create "def +cmf_core.MacroPore_create(args, kwargs) + +MacroPore_create(cmf::upslope::SoilLayer::ptr layer, real +porefraction=0.05, real Ksat=10, real density=0.05, real +porefraction_wilt=-1., real K_shape=0.0) -> +cmf::upslope::MacroPore::ptr "; + +%feature("docstring") cmf_core::make_river_gap "def +cmf_core.make_river_gap(args, kwargs) + +make_river_gap(cmf::river::Reach::ptr root_reach) -> double double +cmf::river::make_river_gap(Reach::ptr root_reach) Ensures that rivers +have a monotone downward flow direction. Reaches with a bottom higher +than any upstream reach are lowered to the minimum height of any +(possibly distant) upstream reach. "; + +%feature("docstring") cmf_core::MatrixInfiltration_use_for_cell "def +cmf_core.MatrixInfiltration_use_for_cell(args, kwargs) -// File: cvode__diag_8h.xml -%feature("docstring") CVDiag "SUNDIALS_EXPORT int CVDiag(void -*cvode_mem) "; +MatrixInfiltration_use_for_cell(Cell c) "; -%feature("docstring") CVDiagGetLastFlag "SUNDIALS_EXPORT int -CVDiagGetLastFlag(void *cvode_mem, int *flag) "; +%feature("docstring") cmf_core::maximum "def cmf_core.maximum(args, +kwargs) -%feature("docstring") CVDiagGetNumRhsEvals "SUNDIALS_EXPORT int -CVDiagGetNumRhsEvals(void *cvode_mem, long int *nfevalsLS) "; +maximum(real a, real b) -> real "; -%feature("docstring") CVDiagGetReturnFlagName "SUNDIALS_EXPORT char* -CVDiagGetReturnFlagName(int flag) "; +%feature("docstring") cmf_core::mean "def cmf_core.mean(args, +kwargs) -%feature("docstring") CVDiagGetWorkSpace "SUNDIALS_EXPORT int -CVDiagGetWorkSpace(void *cvode_mem, long int *lenrwLS, long int -*leniwLS) "; +mean(real a, real b) -> real "; +%feature("docstring") cmf_core::minimum "def cmf_core.minimum(args, +kwargs) -// File: cvode__direct_8h.xml -%feature("docstring") CVDlsGetLastFlag "SUNDIALS_EXPORT int -CVDlsGetLastFlag(void *cvode_mem, int *flag) "; +minimum(real a, real b) -> real "; -%feature("docstring") CVDlsGetNumJacEvals "SUNDIALS_EXPORT int -CVDlsGetNumJacEvals(void *cvode_mem, long int *njevals) "; +%feature("docstring") cmf_core::minmax "def cmf_core.minmax(args, +kwargs) -%feature("docstring") CVDlsGetNumRhsEvals "SUNDIALS_EXPORT int -CVDlsGetNumRhsEvals(void *cvode_mem, long int *nfevalsLS) "; +minmax(real x, real min, real max) -> real "; -%feature("docstring") CVDlsGetReturnFlagName "SUNDIALS_EXPORT char* -CVDlsGetReturnFlagName(int flag) "; +%feature("docstring") cmf_core::MJ_to_watts "def +cmf_core.MJ_to_watts(args, kwargs) -%feature("docstring") CVDlsGetWorkSpace "SUNDIALS_EXPORT int -CVDlsGetWorkSpace(void *cvode_mem, long int *lenrwLS, long int -*leniwLS) "; +MJ_to_watts(double MJ) -> double "; -%feature("docstring") CVDlsSetBandJacFn "SUNDIALS_EXPORT int -CVDlsSetBandJacFn(void *cvode_mem, CVDlsBandJacFn jac) "; +%feature("docstring") cmf_core::nash_sutcliffe "def +cmf_core.nash_sutcliffe(args, kwargs) -%feature("docstring") CVDlsSetDenseJacFn "SUNDIALS_EXPORT int -CVDlsSetDenseJacFn(void *cvode_mem, CVDlsDenseJacFn jac) "; +nash_sutcliffe(timeseries model, timeseries observation) -> double "; +%feature("docstring") cmf_core::NeumannBoundary_create "def +cmf_core.NeumannBoundary_create(args, kwargs) -// File: cvode__spbcgs_8h.xml -%feature("docstring") CVSpbcg "SUNDIALS_EXPORT int CVSpbcg(void -*cvode_mem, int pretype, int maxl) "; +NeumannBoundary_create(cmf::water::flux_node::ptr target) -> +cmf::water::NeumannBoundary::ptr "; +%feature("docstring") cmf_core::OpenWaterStorage_cast "def +cmf_core.OpenWaterStorage_cast(args, kwargs) -// File: cvode__spgmr_8h.xml -%feature("docstring") CVSpgmr "SUNDIALS_EXPORT int CVSpgmr(void -*cvode_mem, int pretype, int maxl) "; +OpenWaterStorage_cast(cmf::water::flux_node::ptr node) -> +cmf::river::OpenWaterStorage::ptr "; +%feature("docstring") cmf_core::OpenWaterStorage_create "def +cmf_core.OpenWaterStorage_create(args) -// File: cvode__spils_8h.xml -%feature("docstring") CVSpilsGetLastFlag "SUNDIALS_EXPORT int -CVSpilsGetLastFlag(void *cvode_mem, int *flag) "; +create(project _project, real Area) -> +cmf::river::OpenWaterStorage::ptr OpenWaterStorage_create(project +_project, IVolumeHeightFunction base_geo) -> +cmf::river::OpenWaterStorage::ptr "; -%feature("docstring") CVSpilsGetNumConvFails "SUNDIALS_EXPORT int -CVSpilsGetNumConvFails(void *cvode_mem, long int *nlcfails) "; +%feature("docstring") cmf_core::PenmanMonteith "def +cmf_core.PenmanMonteith(args) -%feature("docstring") CVSpilsGetNumJtimesEvals "SUNDIALS_EXPORT int -CVSpilsGetNumJtimesEvals(void *cvode_mem, long int *njvevals) "; +PenmanMonteith(real Rn, real ra, real rs, real T, real +vap_press_deficit) -> real PenmanMonteith(Weather A, Vegetation veg, +double h) -> real real +cmf::upslope::ET::PenmanMonteith(cmf::atmosphere::Weather A, const +cmf::upslope::vegetation::Vegetation &veg, double h) Returns the +potential ET after Penman-Monteith using some simplifications for a +weather and a vegetation object. aerodynamic and surface resistances, +and a vapor pressure deficit Parameters: ----------- A: Current +weather veg: Vegetation data h: Height above sea level in m (for +air pressure estimation) "; -%feature("docstring") CVSpilsGetNumLinIters "SUNDIALS_EXPORT int -CVSpilsGetNumLinIters(void *cvode_mem, long int *nliters) "; +%feature("docstring") cmf_core::PenmanMonteithET_r_a "def +cmf_core.PenmanMonteithET_r_a(args, kwargs) -%feature("docstring") CVSpilsGetNumPrecEvals "SUNDIALS_EXPORT int -CVSpilsGetNumPrecEvals(void *cvode_mem, long int *npevals) "; +PenmanMonteithET_r_a(Weather A, real veg_height) -> real "; -%feature("docstring") CVSpilsGetNumPrecSolves "SUNDIALS_EXPORT int -CVSpilsGetNumPrecSolves(void *cvode_mem, long int *npsolves) "; +%feature("docstring") cmf_core::PenmanMonteithET_r_s "def +cmf_core.PenmanMonteithET_r_s(args, kwargs) -%feature("docstring") CVSpilsGetNumRhsEvals "SUNDIALS_EXPORT int -CVSpilsGetNumRhsEvals(void *cvode_mem, long int *nfevalsLS) "; +PenmanMonteithET_r_s(Vegetation veg) -> real "; -%feature("docstring") CVSpilsGetReturnFlagName "SUNDIALS_EXPORT -char* CVSpilsGetReturnFlagName(int flag) "; +%feature("docstring") cmf_core::PenmanMonteithET_use_for_cell "def +cmf_core.PenmanMonteithET_use_for_cell(args, kwargs) -%feature("docstring") CVSpilsGetWorkSpace "SUNDIALS_EXPORT int -CVSpilsGetWorkSpace(void *cvode_mem, long int *lenrwLS, long int -*leniwLS) "; +PenmanMonteithET_use_for_cell(Cell cell) "; -%feature("docstring") CVSpilsSetEpsLin "SUNDIALS_EXPORT int -CVSpilsSetEpsLin(void *cvode_mem, realtype eplifac) "; +%feature("docstring") cmf_core::pF_to_waterhead "def +cmf_core.pF_to_waterhead(args, kwargs) -%feature("docstring") CVSpilsSetGSType "SUNDIALS_EXPORT int -CVSpilsSetGSType(void *cvode_mem, int gstype) "; +pF_to_waterhead(double pF) -> double "; -%feature("docstring") CVSpilsSetJacTimesVecFn "SUNDIALS_EXPORT int -CVSpilsSetJacTimesVecFn(void *cvode_mem, CVSpilsJacTimesVecFn jtv) "; +%feature("docstring") cmf_core::piecewise_linear "def +cmf_core.piecewise_linear(args, kwargs) -%feature("docstring") CVSpilsSetMaxl "SUNDIALS_EXPORT int -CVSpilsSetMaxl(void *cvode_mem, int maxl) "; +piecewise_linear(real x, real xmin, real xmax, real ymin=0, real +ymax=1) -> real "; -%feature("docstring") CVSpilsSetPreconditioner "SUNDIALS_EXPORT int -CVSpilsSetPreconditioner(void *cvode_mem, CVSpilsPrecSetupFn pset, -CVSpilsPrecSolveFn psolve) "; +%feature("docstring") cmf_core::point_distance "def +cmf_core.point_distance(args, kwargs) -%feature("docstring") CVSpilsSetPrecType "SUNDIALS_EXPORT int -CVSpilsSetPrecType(void *cvode_mem, int pretype) "; +point_distance(point p1, point p2) -> double "; +%feature("docstring") cmf_core::Pressure "def +cmf_core.Pressure(args, kwargs) -// File: cvode__sptfqmr_8h.xml -%feature("docstring") CVSptfqmr "SUNDIALS_EXPORT int CVSptfqmr(void -*cvode_mem, int pretype, int maxl) "; +Pressure(double height) -> double double +cmf::atmosphere::Pressure(double height) Returns the average air +pressure for a height (m a.s.l.) "; +%feature("docstring") cmf_core::pressure_to_waterhead "def +cmf_core.pressure_to_waterhead(args, kwargs) -// File: nvector__parallel_8h.xml -%feature("docstring") N_VAbs_Parallel "SUNDIALS_EXPORT void -N_VAbs_Parallel(N_Vector x, N_Vector z) "; +pressure_to_waterhead(double Pressure) -> double "; -%feature("docstring") N_VAddConst_Parallel "SUNDIALS_EXPORT void -N_VAddConst_Parallel(N_Vector x, realtype b, N_Vector z) "; +%feature("docstring") cmf_core::PriestleyTaylorET_use_for_cell "def +cmf_core.PriestleyTaylorET_use_for_cell(args, kwargs) -%feature("docstring") N_VClone_Parallel "SUNDIALS_EXPORT N_Vector -N_VClone_Parallel(N_Vector w) "; +PriestleyTaylorET_use_for_cell(Cell cell) "; -%feature("docstring") N_VCloneEmpty_Parallel "SUNDIALS_EXPORT -N_Vector N_VCloneEmpty_Parallel(N_Vector w) "; +%feature("docstring") cmf_core::RainfallStation_create "def +cmf_core.RainfallStation_create(args, kwargs) -%feature("docstring") N_VCloneVectorArray_Parallel "SUNDIALS_EXPORT -N_Vector* N_VCloneVectorArray_Parallel(int count, N_Vector w) "; +RainfallStation_create(size_t Id, std::string Name, timeseries Data, +point position) -> cmf::atmosphere::RainfallStation::ptr "; -%feature("docstring") N_VCloneVectorArrayEmpty_Parallel "SUNDIALS_EXPORT N_Vector* N_VCloneVectorArrayEmpty_Parallel(int count, -N_Vector w) "; +%feature("docstring") +cmf_core::RainfallStationReference_from_nearest_station "def +cmf_core.RainfallStationReference_from_nearest_station(args, kwargs) -%feature("docstring") N_VCompare_Parallel "SUNDIALS_EXPORT void -N_VCompare_Parallel(realtype c, N_Vector x, N_Vector z) "; +RainfallStationReference_from_nearest_station(project project, point +position, double z_weight) -> +cmf::atmosphere::RainfallStationReference::ptr "; -%feature("docstring") N_VConst_Parallel "SUNDIALS_EXPORT void -N_VConst_Parallel(realtype c, N_Vector z) "; +%feature("docstring") +cmf_core::RainfallStationReference_from_station_id "def +cmf_core.RainfallStationReference_from_station_id(args, kwargs) -%feature("docstring") N_VConstrMask_Parallel "SUNDIALS_EXPORT -booleantype N_VConstrMask_Parallel(N_Vector c, N_Vector x, N_Vector m) +RainfallStationReference_from_station_id(project project, point +position, size_t id) -> cmf::atmosphere::RainfallStationReference::ptr "; -%feature("docstring") N_VDestroy_Parallel "SUNDIALS_EXPORT void -N_VDestroy_Parallel(N_Vector v) "; - -%feature("docstring") N_VDestroyVectorArray_Parallel "SUNDIALS_EXPORT void N_VDestroyVectorArray_Parallel(N_Vector *vs, int -count) "; - -%feature("docstring") N_VDiv_Parallel "SUNDIALS_EXPORT void -N_VDiv_Parallel(N_Vector x, N_Vector y, N_Vector z) "; - -%feature("docstring") N_VDotProd_Parallel "SUNDIALS_EXPORT realtype -N_VDotProd_Parallel(N_Vector x, N_Vector y) "; - -%feature("docstring") N_VGetArrayPointer_Parallel "SUNDIALS_EXPORT -realtype* N_VGetArrayPointer_Parallel(N_Vector v) "; - -%feature("docstring") N_VInv_Parallel "SUNDIALS_EXPORT void -N_VInv_Parallel(N_Vector x, N_Vector z) "; - -%feature("docstring") N_VInvTest_Parallel "SUNDIALS_EXPORT -booleantype N_VInvTest_Parallel(N_Vector x, N_Vector z) "; - -%feature("docstring") N_VL1Norm_Parallel "SUNDIALS_EXPORT realtype -N_VL1Norm_Parallel(N_Vector x) "; - -%feature("docstring") N_VLinearSum_Parallel "SUNDIALS_EXPORT void -N_VLinearSum_Parallel(realtype a, N_Vector x, realtype b, N_Vector y, -N_Vector z) "; - -%feature("docstring") N_VMake_Parallel "SUNDIALS_EXPORT N_Vector -N_VMake_Parallel(MPI_Comm comm, long int local_length, long int -global_length, realtype *v_data) "; - -%feature("docstring") N_VMaxNorm_Parallel "SUNDIALS_EXPORT realtype -N_VMaxNorm_Parallel(N_Vector x) "; - -%feature("docstring") N_VMin_Parallel "SUNDIALS_EXPORT realtype -N_VMin_Parallel(N_Vector x) "; - -%feature("docstring") N_VMinQuotient_Parallel "SUNDIALS_EXPORT -realtype N_VMinQuotient_Parallel(N_Vector num, N_Vector denom) "; +%feature("docstring") cmf_core::Reach_create "def +cmf_core.Reach_create(args, kwargs) -%feature("docstring") N_VNew_Parallel "SUNDIALS_EXPORT N_Vector -N_VNew_Parallel(MPI_Comm comm, long int local_length, long int -global_length) "; +Reach_create(project project, IChannel shape, bool diffusive=False) -> +cmf::river::Reach::ptr "; -%feature("docstring") N_VNewEmpty_Parallel "SUNDIALS_EXPORT N_Vector -N_VNewEmpty_Parallel(MPI_Comm comm, long int local_length, long int -global_length) "; +%feature("docstring") cmf_core::replace_node "def +cmf_core.replace_node(args, kwargs) -%feature("docstring") N_VPrint_Parallel "SUNDIALS_EXPORT void -N_VPrint_Parallel(N_Vector v) "; - -%feature("docstring") N_VProd_Parallel "SUNDIALS_EXPORT void -N_VProd_Parallel(N_Vector x, N_Vector y, N_Vector z) "; - -%feature("docstring") N_VScale_Parallel "SUNDIALS_EXPORT void -N_VScale_Parallel(realtype c, N_Vector x, N_Vector z) "; - -%feature("docstring") N_VSetArrayPointer_Parallel "SUNDIALS_EXPORT -void N_VSetArrayPointer_Parallel(realtype *v_data, N_Vector v) "; - -%feature("docstring") N_VSpace_Parallel "SUNDIALS_EXPORT void -N_VSpace_Parallel(N_Vector v, long int *lrw, long int *liw) "; - -%feature("docstring") N_VWL2Norm_Parallel "SUNDIALS_EXPORT realtype -N_VWL2Norm_Parallel(N_Vector x, N_Vector w) "; - -%feature("docstring") N_VWrmsNorm_Parallel "SUNDIALS_EXPORT realtype -N_VWrmsNorm_Parallel(N_Vector x, N_Vector w) "; - -%feature("docstring") N_VWrmsNormMask_Parallel "SUNDIALS_EXPORT -realtype N_VWrmsNormMask_Parallel(N_Vector x, N_Vector w, N_Vector id) -"; - - -// File: nvector__serial_8h.xml -%feature("docstring") N_VAbs_Serial "SUNDIALS_EXPORT void -N_VAbs_Serial(N_Vector x, N_Vector z) "; +replace_node(cmf::water::flux_node::ptr oldnode, +cmf::water::flux_node::ptr newnode) -> int int +cmf::water::replace_node(cmf::water::flux_node::ptr oldnode, +cmf::water::flux_node::ptr newnode) "; -%feature("docstring") N_VAddConst_Serial "SUNDIALS_EXPORT void -N_VAddConst_Serial(N_Vector x, realtype b, N_Vector z) "; +%feature("docstring") cmf_core::rH_from_vpd "def +cmf_core.rH_from_vpd(args, kwargs) -%feature("docstring") N_VClone_Serial "SUNDIALS_EXPORT N_Vector -N_VClone_Serial(N_Vector w) "; +rH_from_vpd(double T, double vpd) -> double double +cmf::atmosphere::rH_from_vpd(double T, double vpd) Returns the rel. +humidity in % for temperature T [degC] and vapor pressure deficit vpd +[Pa] the rel. humidity is calculated from the vapor pressure deficit +:math:`vpd = e_s - e_a` as: .. math:: rH = 100 * +\\\\\\\\frac{e_a}{e_s(T)}, e_a = e_s(T) - vpd The definition is +fromhttp://www.fao.org/docrep/X0490E/x0490e07.htm#concepts Parameters: +----------- T: Air temperature in degC vpd: Vapor pressure deficit +in Pa :math:`e_s(T)` is calculated using +cmf::atmosphere::vapor_pressure(double) "; -%feature("docstring") N_VCloneEmpty_Serial "SUNDIALS_EXPORT N_Vector -N_VCloneEmpty_Serial(N_Vector w) "; +%feature("docstring") cmf_core::Richards_lateral_usebaseflow "def +cmf_core.Richards_lateral_usebaseflow(args, kwargs) -%feature("docstring") N_VCloneVectorArray_Serial "SUNDIALS_EXPORT -N_Vector* N_VCloneVectorArray_Serial(int count, N_Vector w) "; +Richards_lateral_usebaseflow(bool use) "; -%feature("docstring") N_VCloneVectorArrayEmpty_Serial "SUNDIALS_EXPORT N_Vector* N_VCloneVectorArrayEmpty_Serial(int count, -N_Vector w) "; +%feature("docstring") cmf_core::Richards_use_for_cell "def +cmf_core.Richards_use_for_cell(args, kwargs) -%feature("docstring") N_VCompare_Serial "SUNDIALS_EXPORT void -N_VCompare_Serial(realtype c, N_Vector x, N_Vector z) "; +Richards_use_for_cell(Cell cell, bool no_override=True) "; -%feature("docstring") N_VConst_Serial "SUNDIALS_EXPORT void -N_VConst_Serial(realtype c, N_Vector z) "; +%feature("docstring") cmf_core::RutterInterception_use_for_cell "def +cmf_core.RutterInterception_use_for_cell(args, kwargs) -%feature("docstring") N_VConstrMask_Serial "SUNDIALS_EXPORT -booleantype N_VConstrMask_Serial(N_Vector c, N_Vector x, N_Vector m) -"; +RutterInterception_use_for_cell(Cell cell) -> RutterInterception "; -%feature("docstring") N_VDestroy_Serial "SUNDIALS_EXPORT void -N_VDestroy_Serial(N_Vector v) "; +%feature("docstring") cmf_core::set_flux "def +cmf_core.set_flux(args, kwargs) -%feature("docstring") N_VDestroyVectorArray_Serial "SUNDIALS_EXPORT -void N_VDestroyVectorArray_Serial(N_Vector *vs, int count) "; +set_flux(cmf::water::flux_node::ptr source, cmf::water::flux_node::ptr +target, real flux_value) void cmf::water::set_flux(flux_node::ptr +source, flux_node::ptr target, real flux_value) Sets a constant flux +between two nodes, if an external_control_connection exists. "; -%feature("docstring") N_VDiv_Serial "SUNDIALS_EXPORT void -N_VDiv_Serial(N_Vector x, N_Vector y, N_Vector z) "; +%feature("docstring") cmf_core::set_parallel_threads "def +cmf_core.set_parallel_threads(args, kwargs) -%feature("docstring") N_VDotProd_Serial "SUNDIALS_EXPORT realtype -N_VDotProd_Serial(N_Vector x, N_Vector y) "; +set_parallel_threads(int numthreads) -> int "; -%feature("docstring") N_VGetArrayPointer_Serial "SUNDIALS_EXPORT -realtype* N_VGetArrayPointer_Serial(N_Vector v) "; +%feature("docstring") +cmf_core::ShuttleworthWallace_set_RSS_parameters "def +cmf_core.ShuttleworthWallace_set_RSS_parameters(args, kwargs) -%feature("docstring") N_VInv_Serial "SUNDIALS_EXPORT void -N_VInv_Serial(N_Vector x, N_Vector z) "; +ShuttleworthWallace_set_RSS_parameters(double _RSSa=500., double +_RSSb=1.0, double _RSSa_pot=-3.22) "; -%feature("docstring") N_VInvTest_Serial "SUNDIALS_EXPORT booleantype -N_VInvTest_Serial(N_Vector x, N_Vector z) "; +%feature("docstring") cmf_core::ShuttleworthWallace_use_for_cell "def cmf_core.ShuttleworthWallace_use_for_cell(args, kwargs) -%feature("docstring") N_VL1Norm_Serial "SUNDIALS_EXPORT realtype -N_VL1Norm_Serial(N_Vector x) "; +ShuttleworthWallace_use_for_cell(Cell cell) -> +cmf::upslope::ET::ShuttleworthWallace::ptr "; -%feature("docstring") N_VLinearSum_Serial "SUNDIALS_EXPORT void -N_VLinearSum_Serial(realtype a, N_Vector x, realtype b, N_Vector y, -N_Vector z) "; +%feature("docstring") cmf_core::sign "def cmf_core.sign(args, +kwargs) -%feature("docstring") N_VMake_Serial "SUNDIALS_EXPORT N_Vector -N_VMake_Serial(long int vec_length, realtype *v_data) "; +sign(real x) -> real "; -%feature("docstring") N_VMaxNorm_Serial "SUNDIALS_EXPORT realtype -N_VMaxNorm_Serial(N_Vector x) "; +%feature("docstring") cmf_core::SimpleInfiltration_use_for_cell "def +cmf_core.SimpleInfiltration_use_for_cell(args, kwargs) -%feature("docstring") N_VMin_Serial "SUNDIALS_EXPORT realtype -N_VMin_Serial(N_Vector x) "; +SimpleInfiltration_use_for_cell(Cell c) "; -%feature("docstring") N_VMinQuotient_Serial "SUNDIALS_EXPORT -realtype N_VMinQuotient_Serial(N_Vector num, N_Vector denom) "; +%feature("docstring") cmf_core::SimpleTindexSnowMelt_use_for_cell "def cmf_core.SimpleTindexSnowMelt_use_for_cell(args, kwargs) -%feature("docstring") N_VNew_Serial "SUNDIALS_EXPORT N_Vector -N_VNew_Serial(long int vec_length) "; +SimpleTindexSnowMelt_use_for_cell(Cell cell) "; -%feature("docstring") N_VNewEmpty_Serial "SUNDIALS_EXPORT N_Vector -N_VNewEmpty_Serial(long int vec_length) "; +%feature("docstring") cmf_core::SimplRichards_use_for_cell "def +cmf_core.SimplRichards_use_for_cell(args, kwargs) -%feature("docstring") N_VPrint_Serial "SUNDIALS_EXPORT void -N_VPrint_Serial(N_Vector v) "; +SimplRichards_use_for_cell(Cell cell, bool no_override=True) "; -%feature("docstring") N_VProd_Serial "SUNDIALS_EXPORT void -N_VProd_Serial(N_Vector x, N_Vector y, N_Vector z) "; +%feature("docstring") cmf_core::snowfraction "def +cmf_core.snowfraction(args, kwargs) -%feature("docstring") N_VScale_Serial "SUNDIALS_EXPORT void -N_VScale_Serial(realtype c, N_Vector x, N_Vector z) "; +snowfraction(real T) -> real real +cmf::upslope::connections::snowfraction(real T) A function to +calculate the snow fraction of the precipitation according to the air +temperature. Returns 0.0 for T>+1 degC, 1.0 for T<-1degC and +interpolates linear between. Values between 0 and 1 can be interpreted +as sleet "; -%feature("docstring") N_VSetArrayPointer_Serial "SUNDIALS_EXPORT -void N_VSetArrayPointer_Serial(realtype *v_data, N_Vector v) "; +%feature("docstring") cmf_core::SoilLayer_cast "def +cmf_core.SoilLayer_cast(args, kwargs) -%feature("docstring") N_VSpace_Serial "SUNDIALS_EXPORT void -N_VSpace_Serial(N_Vector v, long int *lrw, long int *liw) "; +SoilLayer_cast(cmf::water::flux_node::ptr node) -> +cmf::upslope::SoilLayer::ptr "; -%feature("docstring") N_VWL2Norm_Serial "SUNDIALS_EXPORT realtype -N_VWL2Norm_Serial(N_Vector x, N_Vector w) "; +%feature("docstring") cmf_core::square "def cmf_core.square(args, +kwargs) -%feature("docstring") N_VWrmsNorm_Serial "SUNDIALS_EXPORT realtype -N_VWrmsNorm_Serial(N_Vector x, N_Vector w) "; +square(real x) -> real "; -%feature("docstring") N_VWrmsNormMask_Serial "SUNDIALS_EXPORT -realtype N_VWrmsNormMask_Serial(N_Vector x, N_Vector w, N_Vector id) -"; +%feature("docstring") cmf_core::SurfaceWater_cast "def +cmf_core.SurfaceWater_cast(args, kwargs) +SurfaceWater_cast(cmf::water::flux_node::ptr node) -> +cmf::upslope::SurfaceWater::ptr "; -// File: sundials__band_8h.xml -%feature("docstring") bandAddIdentity "SUNDIALS_EXPORT void -bandAddIdentity(realtype **a, int n, int smu) "; +%feature("docstring") cmf_core::SWATPercolation_use_for_cell "def +cmf_core.SWATPercolation_use_for_cell(args, kwargs) -%feature("docstring") BandCopy "SUNDIALS_EXPORT void BandCopy(DlsMat -A, DlsMat B, int copymu, int copyml) "; +SWATPercolation_use_for_cell(Cell cell, bool no_override=True) "; -%feature("docstring") bandCopy "SUNDIALS_EXPORT void -bandCopy(realtype **a, realtype **b, int n, int a_smu, int b_smu, int -copymu, int copyml) "; +%feature("docstring") cmf_core::swig_import_helper "def +swig_import_helper() "; -%feature("docstring") BandGBTRF "SUNDIALS_EXPORT int -BandGBTRF(DlsMat A, int *p) "; +%feature("docstring") cmf_core::system_bridge "def +cmf_core.system_bridge(args, kwargs) -%feature("docstring") bandGBTRF "SUNDIALS_EXPORT int -bandGBTRF(realtype **a, int n, int mu, int ml, int smu, int *p) "; +system_bridge(project p, cmf::water::flux_node::ptr upper, +cmf::water::flux_node::ptr lower) -> cmf::water::SystemBridge::ptr +SystemBridge::ptr cmf::water::system_bridge(cmf::project &p, +flux_node::ptr upper, flux_node::ptr lower) Creates a SystemBridge +object. This is an advanced feature for tuning of the calculation +time. A SystemBridge can be used to replace an existing connection +between nodes. After installation, the two nodes can more safely be +added to different integrator systems. One node (called upper) is +connected with the system bridge with the connection formerly +connecting the nodes, the second node (called lower) is connected to +the system bridge with as a Neumann boundary condition. The flux +equals the average flux of the connection upper <-> SystemBridge. +Therefore, the system bridge must become an integratable of the +integrator system the upper node belongs to. Use as an upper system +(system upper node is belonging to) the faster reacting system. For +the connection between upper and SystemBridge, the SystemBridge reacts +as an Dirichlet boundary condition, providing the potential of the +lower node. "; -%feature("docstring") BandGBTRS "SUNDIALS_EXPORT void -BandGBTRS(DlsMat A, int *p, realtype *b) "; +%feature("docstring") cmf_core::timerange "def +cmf_core.timerange(start, end, step=day) -%feature("docstring") bandGBTRS "SUNDIALS_EXPORT void -bandGBTRS(realtype **a, int n, int smu, int ml, int *p, realtype *b) +Creates a generator of cmf.Time, similar to the Python range function "; -%feature("docstring") BandScale "SUNDIALS_EXPORT void -BandScale(realtype c, DlsMat A) "; - -%feature("docstring") bandScale "SUNDIALS_EXPORT void -bandScale(realtype c, realtype **a, int n, int mu, int ml, int smu) "; - - -// File: sundials__config_8h.xml - - -// File: sundials__dense_8h.xml -%feature("docstring") denseAddIdentity "SUNDIALS_EXPORT void -denseAddIdentity(realtype **a, int n) "; - -%feature("docstring") DenseCopy "SUNDIALS_EXPORT void -DenseCopy(DlsMat A, DlsMat B) "; - -%feature("docstring") denseCopy "SUNDIALS_EXPORT void -denseCopy(realtype **a, realtype **b, int m, int n) "; - -%feature("docstring") DenseGEQRF "SUNDIALS_EXPORT int -DenseGEQRF(DlsMat A, realtype *beta, realtype *wrk) "; - -%feature("docstring") denseGEQRF "SUNDIALS_EXPORT int -denseGEQRF(realtype **a, int m, int n, realtype *beta, realtype *v) "; - -%feature("docstring") DenseGETRF "SUNDIALS_EXPORT int -DenseGETRF(DlsMat A, int *p) "; - -%feature("docstring") denseGETRF "SUNDIALS_EXPORT int -denseGETRF(realtype **a, int m, int n, int *p) "; - -%feature("docstring") DenseGETRS "SUNDIALS_EXPORT void -DenseGETRS(DlsMat A, int *p, realtype *b) "; - -%feature("docstring") denseGETRS "SUNDIALS_EXPORT void -denseGETRS(realtype **a, int n, int *p, realtype *b) "; - -%feature("docstring") DenseORMQR "SUNDIALS_EXPORT int -DenseORMQR(DlsMat A, realtype *beta, realtype *vn, realtype *vm, -realtype *wrk) "; - -%feature("docstring") denseORMQR "SUNDIALS_EXPORT int -denseORMQR(realtype **a, int m, int n, realtype *beta, realtype *v, -realtype *w, realtype *wrk) "; - -%feature("docstring") DensePOTRF "SUNDIALS_EXPORT int -DensePOTRF(DlsMat A) "; - -%feature("docstring") densePOTRF "SUNDIALS_EXPORT int -densePOTRF(realtype **a, int m) "; - -%feature("docstring") DensePOTRS "SUNDIALS_EXPORT void -DensePOTRS(DlsMat A, realtype *b) "; - -%feature("docstring") densePOTRS "SUNDIALS_EXPORT void -densePOTRS(realtype **a, int m, realtype *b) "; - -%feature("docstring") DenseScale "SUNDIALS_EXPORT void -DenseScale(realtype c, DlsMat A) "; - -%feature("docstring") denseScale "SUNDIALS_EXPORT void -denseScale(realtype c, realtype **a, int m, int n) "; - - -// File: sundials__direct_8h.xml -%feature("docstring") AddIdentity "SUNDIALS_EXPORT void -AddIdentity(DlsMat A) "; - -%feature("docstring") DestroyArray "SUNDIALS_EXPORT void -DestroyArray(void *p) "; - -%feature("docstring") destroyArray "SUNDIALS_EXPORT void -destroyArray(void *v) "; - -%feature("docstring") DestroyMat "SUNDIALS_EXPORT void -DestroyMat(DlsMat A) "; - -%feature("docstring") destroyMat "SUNDIALS_EXPORT void -destroyMat(realtype **a) "; - -%feature("docstring") NewBandMat "SUNDIALS_EXPORT DlsMat -NewBandMat(int N, int mu, int ml, int smu) "; - -%feature("docstring") newBandMat "SUNDIALS_EXPORT realtype** -newBandMat(int n, int smu, int ml) "; - -%feature("docstring") NewDenseMat "SUNDIALS_EXPORT DlsMat -NewDenseMat(int M, int N) "; - -%feature("docstring") newDenseMat "SUNDIALS_EXPORT realtype** -newDenseMat(int m, int n) "; - -%feature("docstring") NewIntArray "SUNDIALS_EXPORT int* -NewIntArray(int N) "; +%feature("docstring") cmf_core::timeseries_from_array "def +cmf_core.timeseries_from_array(args, kwargs) -%feature("docstring") newIntArray "SUNDIALS_EXPORT int* -newIntArray(int n) "; +timeseries_from_array(Time begin, Time step, cmf::math::num_array +const & data) -> timeseries "; -%feature("docstring") NewRealArray "SUNDIALS_EXPORT realtype* -NewRealArray(int N) "; +%feature("docstring") cmf_core::timeseries_from_file "def +cmf_core.timeseries_from_file(args, kwargs) -%feature("docstring") newRealArray "SUNDIALS_EXPORT realtype* -newRealArray(int m) "; +timeseries_from_file(std::string filename) -> timeseries "; -%feature("docstring") PrintMat "SUNDIALS_EXPORT void PrintMat(DlsMat -A) "; +%feature("docstring") cmf_core::timeseries_from_scalar "def +cmf_core.timeseries_from_scalar(args, kwargs) -%feature("docstring") SetToZero "SUNDIALS_EXPORT void -SetToZero(DlsMat A) "; +timeseries_from_scalar(double scalar) -> timeseries "; +%feature("docstring") cmf_core::Topology_calculate_contributing_area +"def cmf_core.Topology_calculate_contributing_area(args, kwargs) -// File: sundials__fnvector_8h.xml +Topology_calculate_contributing_area(cell_vector arg2) "; +%feature("docstring") cmf_core::TurcET_use_for_cell "def +cmf_core.TurcET_use_for_cell(args, kwargs) -// File: sundials__iterative_8h.xml -%feature("docstring") ClassicalGS "SUNDIALS_EXPORT int -ClassicalGS(N_Vector *v, realtype **h, int k, int p, realtype -*new_vk_norm, N_Vector temp, realtype *s) "; +TurcET_use_for_cell(Cell cell) "; -%feature("docstring") ModifiedGS "SUNDIALS_EXPORT int -ModifiedGS(N_Vector *v, realtype **h, int k, int p, realtype -*new_vk_norm) "; - -%feature("docstring") QRfact "SUNDIALS_EXPORT int QRfact(int n, -realtype **h, realtype *q, int job) "; - -%feature("docstring") QRsol "SUNDIALS_EXPORT int QRsol(int n, -realtype **h, realtype *q, realtype *b) "; - - -// File: sundials__lapack_8h.xml -%feature("docstring") dcopy_f77 "void dcopy_f77(int *n, const double -*x, const int *inc_x, double *y, const int *inc_y) "; - -%feature("docstring") dgbtrf_f77 "void dgbtrf_f77(const int *m, -const int *n, const int *kl, const int *ku, double *ab, int *ldab, int -*ipiv, int *info) "; - -%feature("docstring") dgbtrs_f77 "void dgbtrs_f77(const char *trans, -const int *n, const int *kl, const int *ku, const int *nrhs, double -*ab, const int *ldab, int *ipiv, double *b, const int *ldb, int *info, -int len_trans) "; - -%feature("docstring") dgemv_f77 "void dgemv_f77(const char *trans, -int *m, int *n, const double *alpha, const double *a, int *lda, const -double *x, int *inc_x, const double *beta, double *y, int *inc_y, int -len_trans) "; - -%feature("docstring") dgeqp3_f77 "void dgeqp3_f77(const int *m, -const int *n, double *a, const int *lda, int *jpvt, double *tau, -double *work, const int *lwork, int *info) "; - -%feature("docstring") dgeqrf_f77 "void dgeqrf_f77(const int *m, -const int *n, double *a, const int *lda, double *tau, double *work, -const int *lwork, int *info) "; - -%feature("docstring") dgetrf_f77 "void dgetrf_f77(const int *m, -const int *n, double *a, int *lda, int *ipiv, int *info) "; - -%feature("docstring") dgetrs_f77 "void dgetrs_f77(const char *trans, -const int *n, const int *nrhs, double *a, const int *lda, int *ipiv, -double *b, const int *ldb, int *info, int len_trans) "; - -%feature("docstring") dormqr_f77 "void dormqr_f77(const char *side, -const char *trans, const int *m, const int *n, const int *k, double -*a, const int *lda, double *tau, double *c, const int *ldc, double -*work, const int *lwork, int *info, int len_side, int len_trans) "; - -%feature("docstring") dpotrf_f77 "void dpotrf_f77(const char *uplo, -const int *n, double *a, int *lda, int *info, int len_uplo) "; - -%feature("docstring") dpotrs_f77 "void dpotrs_f77(const char *uplo, -const int *n, const int *nrhs, double *a, const int *lda, double *b, -const int *ldb, int *info, int len_uplo) "; - -%feature("docstring") dscal_f77 "void dscal_f77(int *n, const double -*alpha, double *x, const int *inc_x) "; - -%feature("docstring") dsyrk_f77 "void dsyrk_f77(const char *uplo, -const char *trans, const int *n, const int *k, const double *alpha, -const double *a, const int *lda, const double *beta, const double *c, -const int *ldc, int len_uplo, int len_trans) "; - -%feature("docstring") dtrsv_f77 "void dtrsv_f77(const char *uplo, -const char *trans, const char *diag, const int *n, const double *a, -const int *lda, double *x, const int *inc_x, int len_uplo, int -len_trans, int len_diag) "; - - -// File: sundials__math_8h.xml -%feature("docstring") RAbs "SUNDIALS_EXPORT realtype RAbs(realtype -x) "; - -%feature("docstring") RExp "SUNDIALS_EXPORT realtype RExp(realtype -x) "; - -%feature("docstring") RPowerI "SUNDIALS_EXPORT realtype -RPowerI(realtype base, int exponent) "; - -%feature("docstring") RPowerR "SUNDIALS_EXPORT realtype -RPowerR(realtype base, realtype exponent) "; - -%feature("docstring") RSqrt "SUNDIALS_EXPORT realtype RSqrt(realtype -x) "; +%feature("docstring") cmf_core::vapour_pressure "def +cmf_core.vapour_pressure(args, kwargs) +vapour_pressure(double T) -> double double +cmf::atmosphere::vapour_pressure(double T) Returns the saturated +vapor pressure in Pa for temperature T [degC]. The saturated vapor +pressure :math:`e_s` is calculated follwing the following formula .. +math:: e_s = 0.6108 \\\\\\\\exp{\\\\\\\\frac{17.27 T}{T+237.3}} +The definition is +fromhttp://www.fao.org/docrep/X0490E/x0490e07.htm#concepts "; -// File: sundials__nvector_8h.xml -%feature("docstring") N_VAbs "SUNDIALS_EXPORT void N_VAbs(N_Vector -x, N_Vector z) "; +%feature("docstring") cmf_core::vpd_from_rH "def +cmf_core.vpd_from_rH(args, kwargs) -%feature("docstring") N_VAddConst "SUNDIALS_EXPORT void -N_VAddConst(N_Vector x, realtype b, N_Vector z) "; +vpd_from_rH(double T, double rH) -> double double +cmf::atmosphere::vpd_from_rH(double T, double rH) Returns the vapor +pressure deficit in Pa for temperature T [degC] and rel. humidity rH +[%] The vapor pressure deficit :math:`e_s - e_a` is calculated from +rel. humidity as: .. math:: e_s - e_a = (1-rH/100) * e_s(T) The +definition is +fromhttp://www.fao.org/docrep/X0490E/x0490e07.htm#concepts Parameters: +----------- T: Air temperature in degC rH: Rel. humidity in % +:math:`e_s(T)` is calculated using +cmf::atmosphere::vapor_pressure(double) "; -%feature("docstring") N_VClone "SUNDIALS_EXPORT N_Vector -N_VClone(N_Vector w) "; +%feature("docstring") cmf_core::waterhead_to_pF "def +cmf_core.waterhead_to_pF(args, kwargs) -%feature("docstring") N_VCloneEmpty "SUNDIALS_EXPORT N_Vector -N_VCloneEmpty(N_Vector w) "; +waterhead_to_pF(double waterhead) -> double "; -%feature("docstring") N_VCloneEmptyVectorArray "SUNDIALS_EXPORT -N_Vector* N_VCloneEmptyVectorArray(int count, N_Vector w) "; +%feature("docstring") cmf_core::waterhead_to_pressure "def +cmf_core.waterhead_to_pressure(args, kwargs) -%feature("docstring") N_VCloneVectorArray "SUNDIALS_EXPORT N_Vector* -N_VCloneVectorArray(int count, N_Vector w) "; +waterhead_to_pressure(double waterhead) -> double "; -%feature("docstring") N_VCompare "SUNDIALS_EXPORT void -N_VCompare(realtype c, N_Vector x, N_Vector z) "; +%feature("docstring") cmf_core::WaterStorage_cast "def +cmf_core.WaterStorage_cast(args, kwargs) -%feature("docstring") N_VConst "SUNDIALS_EXPORT void -N_VConst(realtype c, N_Vector z) "; +WaterStorage_cast(std::shared_ptr< cmf::water::flux_node > node) -> +std::shared_ptr< cmf::water::WaterStorage > "; -%feature("docstring") N_VConstrMask "SUNDIALS_EXPORT booleantype -N_VConstrMask(N_Vector c, N_Vector x, N_Vector m) "; +%feature("docstring") cmf_core::WaterStorage_create "def +cmf_core.WaterStorage_create(args, kwargs) -%feature("docstring") N_VDestroy "SUNDIALS_EXPORT void -N_VDestroy(N_Vector v) "; +WaterStorage_create(project _project, real initial_state=0.0, real +scale=1.0) -> std::shared_ptr< cmf::water::WaterStorage > "; -%feature("docstring") N_VDestroyVectorArray "SUNDIALS_EXPORT void -N_VDestroyVectorArray(N_Vector *vs, int count) "; +%feature("docstring") cmf_core::WaterStorage_from_node "def +cmf_core.WaterStorage_from_node(args, kwargs) -%feature("docstring") N_VDiv "SUNDIALS_EXPORT void N_VDiv(N_Vector -x, N_Vector y, N_Vector z) "; +WaterStorage_from_node(cmf::water::flux_node::ptr node) -> +std::shared_ptr< cmf::water::WaterStorage > "; -%feature("docstring") N_VDotProd "SUNDIALS_EXPORT realtype -N_VDotProd(N_Vector x, N_Vector y) "; +%feature("docstring") cmf_core::watts_to_MJ "def +cmf_core.watts_to_MJ(args, kwargs) -%feature("docstring") N_VGetArrayPointer "SUNDIALS_EXPORT realtype* -N_VGetArrayPointer(N_Vector v) "; +watts_to_MJ(double Watts) -> double "; -%feature("docstring") N_VInv "SUNDIALS_EXPORT void N_VInv(N_Vector -x, N_Vector z) "; +%feature("docstring") cmf_core::Weather_get_snow_threshold "def +cmf_core.Weather_get_snow_threshold(args) -%feature("docstring") N_VInvTest "SUNDIALS_EXPORT booleantype -N_VInvTest(N_Vector x, N_Vector z) "; +Weather_get_snow_threshold() -> double "; -%feature("docstring") N_VL1Norm "SUNDIALS_EXPORT realtype -N_VL1Norm(N_Vector x) "; +%feature("docstring") cmf_core::Weather_set_snow_threshold "def +cmf_core.Weather_set_snow_threshold(args, kwargs) -%feature("docstring") N_VLinearSum "SUNDIALS_EXPORT void -N_VLinearSum(realtype a, N_Vector x, realtype b, N_Vector y, N_Vector -z) "; +Weather_set_snow_threshold(double new_threshold) "; -%feature("docstring") N_VMaxNorm "SUNDIALS_EXPORT realtype -N_VMaxNorm(N_Vector x) "; -%feature("docstring") N_VMin "SUNDIALS_EXPORT realtype -N_VMin(N_Vector x) "; +// File: namespacestd.xml +%feature("docstring") std::isfinite "bool std::isfinite(double v) "; -%feature("docstring") N_VMinQuotient "SUNDIALS_EXPORT realtype -N_VMinQuotient(N_Vector num, N_Vector denom) "; +%feature("docstring") std::to_string "std::string std::to_string(T +val) "; -%feature("docstring") N_VProd "SUNDIALS_EXPORT void N_VProd(N_Vector -x, N_Vector y, N_Vector z) "; -%feature("docstring") N_VScale "SUNDIALS_EXPORT void -N_VScale(realtype c, N_Vector x, N_Vector z) "; +// File: ____init_____8py.xml -%feature("docstring") N_VSetArrayPointer "SUNDIALS_EXPORT void -N_VSetArrayPointer(realtype *v_data, N_Vector v) "; -%feature("docstring") N_VSpace "SUNDIALS_EXPORT void -N_VSpace(N_Vector v, long int *lrw, long int *liw) "; +// File: draw_2____init_____8py.xml -%feature("docstring") N_VWL2Norm "SUNDIALS_EXPORT realtype -N_VWL2Norm(N_Vector x, N_Vector w) "; -%feature("docstring") N_VWrmsNorm "SUNDIALS_EXPORT realtype -N_VWrmsNorm(N_Vector x, N_Vector w) "; +// File: geometry_2____init_____8py.xml -%feature("docstring") N_VWrmsNormMask "SUNDIALS_EXPORT realtype -N_VWrmsNormMask(N_Vector x, N_Vector w, N_Vector id) "; +// File: nash__cascade_8h.xml -// File: sundials__spbcgs_8h.xml -%feature("docstring") SpbcgFree "SUNDIALS_EXPORT void -SpbcgFree(SpbcgMem mem) "; -%feature("docstring") SpbcgMalloc "SUNDIALS_EXPORT SpbcgMem -SpbcgMalloc(int l_max, N_Vector vec_tmpl) "; +// File: reach__network_8h.xml -%feature("docstring") SpbcgSolve "SUNDIALS_EXPORT int -SpbcgSolve(SpbcgMem mem, void *A_data, N_Vector x, N_Vector b, int -pretype, realtype delta, void *P_data, N_Vector sx, N_Vector sb, -ATimesFn atimes, PSolveFn psolve, realtype *res_norm, int *nli, int -*nps) "; +// File: subsurface_8h.xml +%feature("docstring") run_subsurface_app "int run_subsurface_app() +"; -// File: sundials__spgmr_8h.xml -%feature("docstring") SpgmrFree "SUNDIALS_EXPORT void -SpgmrFree(SpgmrMem mem) "; -%feature("docstring") SpgmrMalloc "SUNDIALS_EXPORT SpgmrMem -SpgmrMalloc(int l_max, N_Vector vec_tmpl) "; +// File: meteorology_8h.xml -%feature("docstring") SpgmrSolve "SUNDIALS_EXPORT int -SpgmrSolve(SpgmrMem mem, void *A_data, N_Vector x, N_Vector b, int -pretype, int gstype, realtype delta, int max_restarts, void *P_data, -N_Vector s1, N_Vector s2, ATimesFn atimes, PSolveFn psolve, realtype -*res_norm, int *nli, int *nps) "; +// File: precipitation_8h.xml -// File: sundials__sptfqmr_8h.xml -%feature("docstring") SptfqmrFree "SUNDIALS_EXPORT void -SptfqmrFree(SptfqmrMem mem) "; -%feature("docstring") SptfqmrMalloc "SUNDIALS_EXPORT SptfqmrMem -SptfqmrMalloc(int l_max, N_Vector vec_tmpl) "; +// File: _weather_8h.xml -%feature("docstring") SptfqmrSolve "SUNDIALS_EXPORT int -SptfqmrSolve(SptfqmrMem mem, void *A_data, N_Vector x, N_Vector b, int -pretype, realtype delta, void *P_data, N_Vector sx, N_Vector sb, -ATimesFn atimes, PSolveFn psolve, realtype *res_norm, int *nli, int -*nps) "; +// File: cmf__core_8py.xml -// File: sundials__types_8h.xml +// File: cmfmemory_8h.xml -// File: cvode__bandpre__impl_8h.xml +// File: geometry_8h.xml -// File: cvode__bbdpre__impl_8h.xml +// File: bdf2_8h.xml -// File: cvode__diag__impl_8h.xml +// File: cvode_8h.xml -// File: cvode__direct__impl_8h.xml -%feature("docstring") cvDlsBandDQJac "int cvDlsBandDQJac(int N, int -mupper, int mlower, realtype t, N_Vector y, N_Vector fy, DlsMat Jac, -void *data, N_Vector tmp1, N_Vector tmp2, N_Vector tmp3) "; -%feature("docstring") cvDlsDenseDQJac "int cvDlsDenseDQJac(int N, -realtype t, N_Vector y, N_Vector fy, DlsMat Jac, void *data, N_Vector -tmp1, N_Vector tmp2, N_Vector tmp3) "; +// File: explicit__euler_8h.xml -// File: cvode__impl_8h.xml -%feature("docstring") CVErrHandler "void CVErrHandler(int -error_code, const char *module, const char *function, char *msg, void -*data) "; +// File: implicit__euler_8h.xml -%feature("docstring") CVEwtSet "int CVEwtSet(N_Vector ycur, N_Vector -weight, void *data) "; -%feature("docstring") CVProcessError "void CVProcessError(CVodeMem -cv_mem, int error_code, const char *module, const char *fname, const -char *msgfmt,...) "; +// File: integrator_8h.xml -// File: cvode__spils__impl_8h.xml -%feature("docstring") CVSpilsAtimes "int CVSpilsAtimes(void *cv_mem, -N_Vector v, N_Vector z) "; +// File: multiintegrator_8h.xml -%feature("docstring") CVSpilsDQJtimes "int CVSpilsDQJtimes(N_Vector -v, N_Vector Jv, realtype t, N_Vector y, N_Vector fy, void *data, -N_Vector work) "; -%feature("docstring") CVSpilsPSolve "int CVSpilsPSolve(void *cv_mem, -N_Vector r, N_Vector z, int lr) "; +// File: _r_k_fintegrator_8h.xml // File: _water_solute_integrator_8h.xml @@ -19723,9 +40394,6 @@ ymax=1) "; // File: qtree_8py.xml -// File: geos__shapereader_8py.xml - - // File: jacobian_8py.xml @@ -20095,6 +40763,9 @@ ymax=1) "; // File: deprecated.xml +// File: dir_a1b960d7648f0175b5e7cfeede519b17.xml + + // File: dir_a32c301defa8fda793cb40af11415647.xml @@ -20107,9 +40778,6 @@ ymax=1) "; // File: dir_276c0bb4402aea34a5542f6741d7a1ee.xml -// File: dir_b27729de313f47365c1def7a853e5f37.xml - - // File: dir_e99589850f294dbf4b725494ab1c642e.xml @@ -20119,33 +40787,18 @@ ymax=1) "; // File: dir_3f1ba486f713b268e033cb12ab59a41b.xml -// File: dir_42143f02bfda25d481ccd197ad2e57b1.xml - - // File: dir_6e764f1be992d70f16adadc29c086796.xml // File: dir_fb2b4d745793dfd5bb69790f90a5a545.xml -// File: dir_8fa323148029007c36ebe07b605c3d71.xml - - // File: dir_707fbb85f5f5a03168ae42ef8ba0d65d.xml // File: dir_73a48ad96f7ed71bd28db957498e0435.xml -// File: dir_682d55a973b4a7ac7b2d19556610a569.xml - - -// File: dir_96a140aa3db6477b947f608f4a8a5cf4.xml - - -// File: dir_15491d5ac9c000f99465febddd8f8d93.xml - - // File: dir_8d4c975dc4db6fbc37636ae91790b381.xml diff --git a/cmf/cmf_core_src/math/integrator.i b/cmf/cmf_core_src/math/integrator.i index 1d86191d..f5028302 100644 --- a/cmf/cmf_core_src/math/integrator.i +++ b/cmf/cmf_core_src/math/integrator.i @@ -10,7 +10,7 @@ #include "math/integrators/WaterSoluteIntegrator.h" %} -%attribute(cmf::math::CVodeIntegrator,int,order,get_order); +%attribute(cmf::math::CVode,int,order,get_order); %rename(__getitem__) cmf::math::Integrator::operator[]; %state_downcast(cmf::math::StateVariable::ptr cmf::math::Integrator::operator[])